# Vulkan® 1.4.304 - A Specification (with all registered extensions)

The Khronos® Vulkan Working Group
version 1.4.304, 2025-01-13 20:32:51Z
from git branch: Git branch not available commit: Git commit not available

Loading… please wait.

Search:

## 10. Pipelines

The following figure shows a block diagram of the Vulkan pipelines. Some Vulkan commands specify geometric objects to be drawn or computational work to be performed, while others specify state controlling how objects are handled by the various pipeline stages, or control data transfer between memory organized as images and buffers. Commands are effectively sent through a processing pipeline, either a graphics pipeline, a ray tracing pipeline, or a compute pipeline.

The graphics pipeline can be operated in two modes, as either primitive shading or mesh shading pipeline.

Primitive Shading

The first stage of the graphics pipeline (Input Assembler) assembles vertices to form geometric primitives such as points, lines, and triangles, based on a requested primitive topology. In the next stage (Vertex Shader) vertices can be transformed, computing positions and attributes for each vertex. If tessellation and/or geometry shaders are supported, they can then generate multiple primitives from a single input primitive, possibly changing the primitive topology or generating additional attribute data in the process.

Cluster Culling Shading

When using the Cluster Culling Shader, a compute-like shader will perform cluster-based culling, a set of new built-in output variables are used to express visible cluster, in addition, a new built-in function is used to emit these variables from the cluster culling shader to the Input Assembler(IA) stage, then IA can use these variables to fetches vertices of visible cluster and drive vertex shader to work.

Mesh Shading

When using the mesh shading pipeline input primitives are not assembled implicitly, but explicitly through the (Mesh Shader). The work on the mesh pipeline is initiated by the application drawing a set of mesh tasks.

If an optional (Task Shader) is active, each task triggers the execution of a task shader workgroup that will generate a new set of tasks upon completion. Each of these spawned tasks, or each of the original dispatched tasks if no task shader is present, triggers the execution of a mesh shader workgroup that produces an output mesh with a variable-sized number of primitives assembled from vertices stored in the output mesh.

Common

The final resulting primitives are clipped to a clip volume in preparation for the next stage, Rasterization. The rasterizer produces a series of fragments associated with a region of the framebuffer, from a two-dimensional description of a point, line segment, or triangle. These fragments are processed by fragment operations to determine whether generated values will be written to the framebuffer. Fragment shading determines the values to be written to the framebuffer attachments. Framebuffer operations then read and write the color and depth/stencil attachments of the framebuffer for a given subpass of a render pass instance. The attachments can be used as input attachments in the fragment shader in a later subpass of the same render pass.

The compute pipeline is a separate pipeline from the graphics pipeline, which operates on one-, two-, or three-dimensional workgroups which can read from and write to buffer and image memory.

This ordering is meant only as a tool for describing Vulkan, not as a strict rule of how Vulkan is implemented, and we present it only as a means to organize the various operations of the pipelines. Actual ordering guarantees between pipeline stages are explained in detail in the synchronization chapter.

Figure 2. Block diagram of the Vulkan pipeline

Each pipeline is controlled by a monolithic object created from a description of all of the shader stages and any relevant fixed-function stages. Linking the whole pipeline together allows the optimization of shaders based on their input/outputs and eliminates expensive draw time state validation.

A pipeline object is bound to the current state using vkCmdBindPipeline. Any pipeline object state that is specified as dynamic is not applied to the current state when the pipeline object is bound, but is instead set by dynamic state setting commands.

If the `commandBufferInheritance` feature is not enabled, then no state, including dynamic state, is inherited from one command buffer to another.

If the `commandBufferInheritance` feature is enabled, then all graphics and compute state that is valid at the end of the command buffer executed in a queue is inherited and valid at beginning of the command buffer next executed in the same queue. This applies to both primary and secondary command buffers, where a primary command buffer submitted to a queue will inherit state from the previously submitted command buffer to that queue, secondary command buffers will inherit state from the primary or seconard command buffer they are executed in, and after a seconard command buffer is executed, its state inherited by the primary or secondary command buffer that executed it. Command buffers executed in one queue do not inherit state from any command buffers executed in another queue.

Compute, ray tracing, and graphics pipelines are each represented by `VkPipeline` handles:

    // Provided by VK_VERSION_1_0
    VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)

### 10.1. Multiple Pipeline Creation

Multiple pipelines can be created in a single call by commands such as vkCreateExecutionGraphPipelinesAMDX, vkCreateRayTracingPipelinesKHR, vkCreateRayTracingPipelinesNV, vkCreateComputePipelines, and vkCreateGraphicsPipelines.

The creation commands are passed an array `pCreateInfos` of `Vk*PipelineCreateInfo` structures specifying parameters of each pipeline to be created, and return a corresponding array of handles in `pPipelines`. Each element index i of `pPipelines` is created based on the corresponding element i of `pCreateInfos`.

Applications can group together similar pipelines to be created in a single call, and implementations are encouraged to look for reuse opportunities when creating a group.

When attempting to create many pipelines in a single command, it is possible that creation may fail for a subset of them. In this case, the corresponding elements of `pPipelines` will be VK_NULL_HANDLE. If creation fails for a pipeline despite valid arguments (for example, due to out of memory errors), the VkResult code returned by the pipeline creation command will indicate why. The implementation will attempt to create all pipelines, and only return VK_NULL_HANDLE values for those that actually failed.

If creation fails for a pipeline that has the `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT` set in its `Vk*PipelineCreateInfo`, pipelines at an index in the `pPipelines` array greater than or equal to that of the failing pipeline will be VK_NULL_HANDLE.

If creation fails for multiple pipelines, the returned VkResult must be the return value of any one of the pipelines which did not succeed. An application can reliably clean up from a failed call by iterating over the `pPipelines` array and destroying every element that is not VK_NULL_HANDLE.

If the entire command fails and no pipelines are created, all elements of `pPipelines` will be VK_NULL_HANDLE.

### 10.2. Compute Pipelines

Compute pipelines consist of a single static compute shader stage and the pipeline layout.

The compute pipeline represents a compute shader and is created by calling `vkCreateComputePipelines` with `module` and `pName` selecting an entry point from a shader module, where that entry point defines a valid compute shader, in the VkPipelineShaderStageCreateInfo structure contained within the VkComputePipelineCreateInfo structure.

To create compute pipelines, call:

    // Provided by VK_VERSION_1_0
    VkResult vkCreateComputePipelines(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        uint32_t                                    createInfoCount,
        const VkComputePipelineCreateInfo*          pCreateInfos,
        const VkAllocationCallbacks*                pAllocator,
        VkPipeline*                                 pPipelines);

- `device` is the logical device that creates the compute pipelines.

- `pipelineCache` is either VK_NULL_HANDLE, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command.

- `createInfoCount` is the length of the `pCreateInfos` and `pPipelines` arrays.

- `pCreateInfos` is a pointer to an array of VkComputePipelineCreateInfo structures.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

- `pPipelines` is a pointer to an array of VkPipeline handles in which the resulting compute pipeline objects are returned.

Pipelines are created and returned as described for Multiple Pipeline Creation.

Valid Usage

- VUID-vkCreateComputePipelines-device-09661
  `device` must support at least one queue family with the `VK_QUEUE_COMPUTE_BIT` capability

- VUID-vkCreateComputePipelines-flags-00695
  If the `flags` member of any element of `pCreateInfos` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and the `basePipelineIndex` member of that same element is not `-1`, `basePipelineIndex` must be less than the index into `pCreateInfos` that corresponds to that element

- VUID-vkCreateComputePipelines-flags-00696
  If the `flags` member of any element of `pCreateInfos` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, the base pipeline must have been created with the `VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT` flag set

- VUID-vkCreateComputePipelines-pipelineCache-02873
  If `pipelineCache` was created with `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT`, host access to `pipelineCache` must be externally synchronized

- VUID-vkCreateComputePipelines-pNext-09616
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `pipelineCache` must be VK_NULL_HANDLE

- VUID-vkCreateComputePipelines-pNext-09617
  If a VkPipelineCreateFlags2CreateInfoKHR structure with the `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` flag set is included in the `pNext` chain of any element of `pCreateInfos`, `pipelineCache` must be VK_NULL_HANDLE

- VUID-vkCreateComputePipelines-binaryCount-09620
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT` must not be set in the `flags` of that element

- VUID-vkCreateComputePipelines-binaryCount-09621
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT` must not be set in the `flags` of that element

- VUID-vkCreateComputePipelines-binaryCount-09622
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT` must not be set in the `flags` of that element

Valid Usage (Implicit)

- VUID-vkCreateComputePipelines-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkCreateComputePipelines-pipelineCache-parameter
  If `pipelineCache` is not VK_NULL_HANDLE, `pipelineCache` must be a valid VkPipelineCache handle

- VUID-vkCreateComputePipelines-pCreateInfos-parameter
  `pCreateInfos` must be a valid pointer to an array of `createInfoCount` valid VkComputePipelineCreateInfo structures

- VUID-vkCreateComputePipelines-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

- VUID-vkCreateComputePipelines-pPipelines-parameter
  `pPipelines` must be a valid pointer to an array of `createInfoCount` VkPipeline handles

- VUID-vkCreateComputePipelines-createInfoCount-arraylength
  `createInfoCount` must be greater than `0`

- VUID-vkCreateComputePipelines-pipelineCache-parent
  If `pipelineCache` is a valid handle, it must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_PIPELINE_COMPILE_REQUIRED_EXT`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

  - `VK_ERROR_INVALID_SHADER_NV`

The `VkComputePipelineCreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkComputePipelineCreateInfo {
        VkStructureType                    sType;
        const void*                        pNext;
        VkPipelineCreateFlags              flags;
        VkPipelineShaderStageCreateInfo    stage;
        VkPipelineLayout                   layout;
        VkPipeline                         basePipelineHandle;
        int32_t                            basePipelineIndex;
    } VkComputePipelineCreateInfo;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `flags` is a bitmask of VkPipelineCreateFlagBits specifying how the pipeline will be generated.

- `stage` is a VkPipelineShaderStageCreateInfo structure describing the compute shader.

- `layout` is the description of binding locations used by both the pipeline and descriptor sets used with the pipeline.

- `basePipelineHandle` is a pipeline to derive from.

- `basePipelineIndex` is an index into the `pCreateInfos` parameter to use as a pipeline to derive from.

The parameters `basePipelineHandle` and `basePipelineIndex` are described in more detail in Pipeline Derivatives.

If the `pNext` chain includes a VkPipelineCreateFlags2CreateInfo structure, VkPipelineCreateFlags2CreateInfo::`flags` from that structure is used instead of `flags` from this structure.

Valid Usage

- VUID-VkComputePipelineCreateInfo-None-09497
  If the `pNext` chain does not include a VkPipelineCreateFlags2CreateInfo structure, `flags` must be a valid combination of VkPipelineCreateFlagBits values

- VUID-VkComputePipelineCreateInfo-flags-07984
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is -1, `basePipelineHandle` must be a valid compute `VkPipeline` handle

- VUID-VkComputePipelineCreateInfo-flags-07985
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineHandle` is VK_NULL_HANDLE, `basePipelineIndex` must be a valid index into the calling command’s `pCreateInfos` parameter

- VUID-VkComputePipelineCreateInfo-flags-07986
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, `basePipelineIndex` must be -1 or `basePipelineHandle` must be VK_NULL_HANDLE

- VUID-VkComputePipelineCreateInfo-layout-07987
  If a push constant block is declared in a shader, a push constant range in `layout` must match the shader stage

- VUID-VkComputePipelineCreateInfo-layout-10069
  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

- VUID-VkComputePipelineCreateInfo-layout-07988
  If a resource variable is declared in a shader, the corresponding descriptor set in `layout` must match the shader stage

- VUID-VkComputePipelineCreateInfo-layout-07990
  If a resource variable is declared in a shader, and the descriptor type is not `VK_DESCRIPTOR_TYPE_MUTABLE_EXT`, the corresponding descriptor set in `layout` must match the descriptor type

- VUID-VkComputePipelineCreateInfo-layout-07991
  If a resource variable is declared in a shader as an array, the corresponding descriptor set in `layout` must match the descriptor count

- VUID-VkComputePipelineCreateInfo-None-10391
  If a resource variables is declared in a shader as an array of descriptors, then the descriptor type of that variable must not be `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK`

- VUID-VkComputePipelineCreateInfo-flags-03365
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR`

- VUID-VkComputePipelineCreateInfo-flags-03366
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR`

- VUID-VkComputePipelineCreateInfo-flags-03367
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR`

- VUID-VkComputePipelineCreateInfo-flags-03368
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR`

- VUID-VkComputePipelineCreateInfo-flags-03369
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR`

- VUID-VkComputePipelineCreateInfo-flags-03370
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR`

- VUID-VkComputePipelineCreateInfo-flags-03576
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR`

- VUID-VkComputePipelineCreateInfo-flags-04945
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV`

- VUID-VkComputePipelineCreateInfo-flags-09007
  If the `VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV`::`deviceGeneratedComputePipelines` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV`

- VUID-VkComputePipelineCreateInfo-flags-09008
  If `flags` includes `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV`, then the `pNext` chain must include a pointer to a valid instance of VkComputePipelineIndirectBufferInfoNV specifying the address where the pipeline’s metadata will be saved

- VUID-VkComputePipelineCreateInfo-flags-11007
  If `flags` includes `VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT`, then the `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT`::`deviceGeneratedCommands` feature must be enabled

- VUID-VkComputePipelineCreateInfo-pipelineCreationCacheControl-02875
  If the `pipelineCreationCacheControl` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` or `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT`

- VUID-VkComputePipelineCreateInfo-stage-00701
  The `stage` member of `stage` must be `VK_SHADER_STAGE_COMPUTE_BIT`

- VUID-VkComputePipelineCreateInfo-stage-00702
  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

- VUID-VkComputePipelineCreateInfo-layout-01687
  The number of resources in `layout` accessible to the compute shader stage must be less than or equal to `VkPhysicalDeviceLimits`::`maxPerStageResources`

- VUID-VkComputePipelineCreateInfo-shaderEnqueue-09177
  If the `shaderEnqueue` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

- VUID-VkComputePipelineCreateInfo-flags-09178
  If `flags` does not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`, the shader specified by `stage` must not declare the `ShaderEnqueueAMDX` capability

- VUID-VkComputePipelineCreateInfo-pipelineStageCreationFeedbackCount-06566
  If VkPipelineCreationFeedbackCreateInfo::`pipelineStageCreationFeedbackCount` is not `0`, it must be `1`

- VUID-VkComputePipelineCreateInfo-flags-07367
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT`

- VUID-VkComputePipelineCreateInfo-flags-07996
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV`

Valid Usage (Implicit)

- VUID-VkComputePipelineCreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO`

- VUID-VkComputePipelineCreateInfo-pNext-pNext
  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 VkComputePipelineIndirectBufferInfoNV, VkPipelineBinaryInfoKHR, VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreateFlags2CreateInfo, VkPipelineCreationFeedbackCreateInfo, VkPipelineRobustnessCreateInfo, or VkSubpassShadingPipelineCreateInfoHUAWEI

- VUID-VkComputePipelineCreateInfo-sType-unique
  The `sType` value of each struct in the `pNext` chain must be unique

- VUID-VkComputePipelineCreateInfo-stage-parameter
  `stage` must be a valid VkPipelineShaderStageCreateInfo structure

- VUID-VkComputePipelineCreateInfo-layout-parameter
  `layout` must be a valid VkPipelineLayout handle

- VUID-VkComputePipelineCreateInfo-commonparent
  Both of `basePipelineHandle`, and `layout` that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The `VkPipelineShaderStageCreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkPipelineShaderStageCreateInfo {
        VkStructureType                     sType;
        const void*                         pNext;
        VkPipelineShaderStageCreateFlags    flags;
        VkShaderStageFlagBits               stage;
        VkShaderModule                      module;
        const char*                         pName;
        const VkSpecializationInfo*         pSpecializationInfo;
    } VkPipelineShaderStageCreateInfo;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `flags` is a bitmask of VkPipelineShaderStageCreateFlagBits specifying how the pipeline shader stage will be generated.

- `stage` is a VkShaderStageFlagBits value specifying a single pipeline stage.

- `module` is optionally a VkShaderModule object containing the shader code for this stage.

- `pName` is a pointer to a null-terminated UTF-8 string specifying the entry point name of the shader for this stage.

- `pSpecializationInfo` is a pointer to a VkSpecializationInfo structure, as described in Specialization Constants, or `NULL`.

If `module` is not VK_NULL_HANDLE, the shader code used by the pipeline is defined by `module`. If `module` is VK_NULL_HANDLE, the shader code is defined by the chained VkShaderModuleCreateInfo if present.

If the `shaderModuleIdentifier` feature is enabled, applications can omit shader code for `stage` and instead provide a module identifier. This is done by including a VkPipelineShaderStageModuleIdentifierCreateInfoEXT struct with `identifierSize` not equal to 0 in the `pNext` chain. A shader stage created in this way is equivalent to one created using a shader module with the same identifier. The identifier allows an implementation to look up a pipeline without consuming a valid SPIR-V module. If a pipeline is not found, pipeline compilation is not possible and the implementation must fail as specified by `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT`.

When an identifier is used in lieu of a shader module, implementations may fail pipeline compilation with `VK_PIPELINE_COMPILE_REQUIRED` for any reason.

Note | The rationale for the relaxed requirement on implementations to return a pipeline with VkPipelineShaderStageModuleIdentifierCreateInfoEXT is that layers or tools may intercept pipeline creation calls and require the full SPIR-V context to operate correctly. ICDs are not expected to fail pipeline compilation if the pipeline exists in a cache somewhere.

Applications can use identifiers when creating pipelines with `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`. When creating such pipelines, `VK_SUCCESS` may be returned, but subsequently fail when referencing the pipeline in a VkPipelineLibraryCreateInfoKHR struct. Applications must allow pipeline compilation to fail during link steps with `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` as it may not be possible to determine if a pipeline can be created from identifiers until the link step.

Valid Usage

- VUID-VkPipelineShaderStageCreateInfo-stage-00704
  If the `geometryShader` feature is not enabled, `stage` must not be `VK_SHADER_STAGE_GEOMETRY_BIT`

- VUID-VkPipelineShaderStageCreateInfo-stage-00705
  If the `tessellationShader` feature is not enabled, `stage` must not be `VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT` or `VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT`

- VUID-VkPipelineShaderStageCreateInfo-stage-02091
  If the `meshShaders` feature is not enabled, `stage` must not be `VK_SHADER_STAGE_MESH_BIT_EXT`

- VUID-VkPipelineShaderStageCreateInfo-stage-02092
  If the `taskShaders` feature is not enabled, `stage` must not be `VK_SHADER_STAGE_TASK_BIT_EXT`

- VUID-VkPipelineShaderStageCreateInfo-clustercullingShader-07813
  If the `clustercullingShader` feature is not enabled, `stage` must not be `VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI`

- VUID-VkPipelineShaderStageCreateInfo-stage-00706
  `stage` must not be `VK_SHADER_STAGE_ALL_GRAPHICS`, or `VK_SHADER_STAGE_ALL`

- VUID-VkPipelineShaderStageCreateInfo-pName-00707
  `pName` must be the name of an `OpEntryPoint` in `module` with an execution model that matches `stage`

- VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708
  If the identified entry point includes any variable in its interface that is declared with the `ClipDistance` `BuiltIn` decoration, that variable must not have an array size greater than `VkPhysicalDeviceLimits`::`maxClipDistances`

- VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709
  If the identified entry point includes any variable in its interface that is declared with the `CullDistance` `BuiltIn` decoration, that variable must not have an array size greater than `VkPhysicalDeviceLimits`::`maxCullDistances`

- VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710
  If the identified entry point includes variables in its interface that are declared with the `ClipDistance` `BuiltIn` decoration and variables in its interface that are declared with the `CullDistance` `BuiltIn` decoration, those variables must not have array sizes which sum to more than `VkPhysicalDeviceLimits`::`maxCombinedClipAndCullDistances`

- VUID-VkPipelineShaderStageCreateInfo-maxSampleMaskWords-00711
  If the identified entry point includes any variable in its interface that is declared with the `SampleMask` `BuiltIn` decoration, that variable must not have an array size greater than `VkPhysicalDeviceLimits`::`maxSampleMaskWords`

- VUID-VkPipelineShaderStageCreateInfo-stage-00713
  If `stage` is `VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT` or `VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT`, and the identified entry point has an `OpExecutionMode` instruction specifying a patch size with `OutputVertices`, the patch size must be greater than `0` and less than or equal to `VkPhysicalDeviceLimits`::`maxTessellationPatchSize`

- VUID-VkPipelineShaderStageCreateInfo-stage-00714
  If `stage` is `VK_SHADER_STAGE_GEOMETRY_BIT`, the identified entry point must have an `OpExecutionMode` instruction specifying a maximum output vertex count that is greater than `0` and less than or equal to `VkPhysicalDeviceLimits`::`maxGeometryOutputVertices`

- VUID-VkPipelineShaderStageCreateInfo-stage-00715
  If `stage` is `VK_SHADER_STAGE_GEOMETRY_BIT`, the identified entry point must have an `OpExecutionMode` instruction specifying an invocation count that is greater than `0` and less than or equal to `VkPhysicalDeviceLimits`::`maxGeometryShaderInvocations`

- VUID-VkPipelineShaderStageCreateInfo-stage-02596
  If `stage` is either `VK_SHADER_STAGE_VERTEX_BIT`, `VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT`, `VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT`, or `VK_SHADER_STAGE_GEOMETRY_BIT`, and the identified entry point writes to `Layer` for any primitive, it must write the same value to `Layer` for all vertices of a given primitive

- VUID-VkPipelineShaderStageCreateInfo-stage-02597
  If `stage` is either `VK_SHADER_STAGE_VERTEX_BIT`, `VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT`, `VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT`, or `VK_SHADER_STAGE_GEOMETRY_BIT`, and the identified entry point writes to `ViewportIndex` for any primitive, it must write the same value to `ViewportIndex` for all vertices of a given primitive

- VUID-VkPipelineShaderStageCreateInfo-stage-06685
  If `stage` is `VK_SHADER_STAGE_FRAGMENT_BIT`, and the identified entry point writes to `FragDepth` in any execution path, all execution paths that are not exclusive to helper invocations must either discard the fragment, or write or initialize the value of `FragDepth`

- VUID-VkPipelineShaderStageCreateInfo-stage-06686
  If `stage` is `VK_SHADER_STAGE_FRAGMENT_BIT`, and the identified entry point writes to `FragStencilRefEXT` in any execution path, all execution paths that are not exclusive to helper invocations must either discard the fragment, or write or initialize the value of `FragStencilRefEXT`

- VUID-VkPipelineShaderStageCreateInfo-flags-02784
  If `flags` has the `VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT` flag set, the `subgroupSizeControl` feature must be enabled

- VUID-VkPipelineShaderStageCreateInfo-flags-02785
  If `flags` has the `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT` flag set, the `computeFullSubgroups` feature must be enabled

- VUID-VkPipelineShaderStageCreateInfo-flags-08988
  If `flags` includes `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT`, `stage` must be one of `VK_SHADER_STAGE_MESH_BIT_EXT`, `VK_SHADER_STAGE_TASK_BIT_EXT`, or `VK_SHADER_STAGE_COMPUTE_BIT`

- VUID-VkPipelineShaderStageCreateInfo-pNext-02754
  If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfo structure is included in the `pNext` chain, `flags` must not have the `VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT` flag set

- VUID-VkPipelineShaderStageCreateInfo-pNext-02755
  If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfo structure is included in the `pNext` chain, the `subgroupSizeControl` feature must be enabled, and `stage` must be a valid bit specified in `requiredSubgroupSizeStages`

- VUID-VkPipelineShaderStageCreateInfo-pNext-02756
  If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfo structure is included in the `pNext` chain and `stage` is `VK_SHADER_STAGE_COMPUTE_BIT`, `VK_SHADER_STAGE_MESH_BIT_EXT`, or `VK_SHADER_STAGE_TASK_BIT_EXT`, the local workgroup size of the shader must be less than or equal to the product of VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::`requiredSubgroupSize` and `maxComputeWorkgroupSubgroups`

- VUID-VkPipelineShaderStageCreateInfo-pNext-02757
  If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfo structure is included in the `pNext` chain, and `flags` has the `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT` flag set, the local workgroup size in the X dimension of the pipeline must be a multiple of VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::`requiredSubgroupSize`

- VUID-VkPipelineShaderStageCreateInfo-flags-02758
  If `flags` has both the `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT` and `VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT` flags set, the local workgroup size in the X dimension of the pipeline must be a multiple of `maxSubgroupSize`

- VUID-VkPipelineShaderStageCreateInfo-flags-02759
  If `flags` has the `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT` flag set and `flags` does not have the `VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT` flag set and no VkPipelineShaderStageRequiredSubgroupSizeCreateInfo structure is included in the `pNext` chain, the local workgroup size in the X dimension of the pipeline must be a multiple of `subgroupSize`

- VUID-VkPipelineShaderStageCreateInfo-module-08987
  If `module` uses the `OpTypeCooperativeMatrixKHR` instruction with a `Scope` equal to `Subgroup`, then the local workgroup size in the X dimension of the pipeline must be a multiple of `subgroupSize`

- VUID-VkPipelineShaderStageCreateInfo-module-10169
  If `module` uses the `OpTypeCooperativeMatrixKHR` instruction with a `Scope` equal to `Workgroup`, then the local workgroup size in the X dimension of the pipeline must be a multiple of `subgroupSize` and the total local workgroup size must be a power of two multiple of `subgroupSize` and must be less than or equal to cooperativeMatrixWorkgroupScopeMaxWorkgroupSize

- VUID-VkPipelineShaderStageCreateInfo-stage-08771
  If a shader module identifier is not specified for this `stage`, `module` must be a valid VkShaderModule , or the `pNext` chain of the parent `Vk*CreateInfo` structure must set VkPipelineBinaryInfoKHR::`binaryCount` to a value greater than `0`, if none of the following features are enabled:

  - `graphicsPipelineLibrary`

  - `maintenance5`

- VUID-VkPipelineShaderStageCreateInfo-stage-06845
  If a shader module identifier is not specified for this `stage`, `module` must be a valid VkShaderModule, or there must be a valid VkShaderModuleCreateInfo structure in the `pNext` chain , or the `pNext` chain of the parent `Vk*CreateInfo` structure must set VkPipelineBinaryInfoKHR::`binaryCount` to a value greater than `0`,

- VUID-VkPipelineShaderStageCreateInfo-stage-06844
  If a shader module identifier is specified for this `stage`, the `pNext` chain must not include a VkShaderModuleCreateInfo structure

- VUID-VkPipelineShaderStageCreateInfo-stage-06848
  If a shader module identifier is specified for this `stage`, `module` must be VK_NULL_HANDLE

- VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-06849
  If a shader module identifier is not specified, the shader code used by the pipeline must be valid as described by the Khronos SPIR-V Specification after applying the specializations provided in `pSpecializationInfo`, if any, and then converting all specialization constants into fixed constants

Valid Usage (Implicit)

- VUID-VkPipelineShaderStageCreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO`

- VUID-VkPipelineShaderStageCreateInfo-pNext-pNext
  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, VkPipelineRobustnessCreateInfo, VkPipelineShaderStageModuleIdentifierCreateInfoEXT, VkPipelineShaderStageNodeCreateInfoAMDX, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo, VkShaderModuleCreateInfo, or VkShaderModuleValidationCacheCreateInfoEXT

- VUID-VkPipelineShaderStageCreateInfo-sType-unique
  The `sType` value of each struct in the `pNext` chain must be unique

- VUID-VkPipelineShaderStageCreateInfo-flags-parameter
  `flags` must be a valid combination of VkPipelineShaderStageCreateFlagBits values

- VUID-VkPipelineShaderStageCreateInfo-stage-parameter
  `stage` must be a valid VkShaderStageFlagBits value

- VUID-VkPipelineShaderStageCreateInfo-module-parameter
  If `module` is not VK_NULL_HANDLE, `module` must be a valid VkShaderModule handle

- VUID-VkPipelineShaderStageCreateInfo-pName-parameter
  `pName` must be a null-terminated UTF-8 string

- VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter
  If `pSpecializationInfo` is not `NULL`, `pSpecializationInfo` must be a valid pointer to a valid VkSpecializationInfo structure

    // Provided by VK_VERSION_1_0
    typedef VkFlags VkPipelineShaderStageCreateFlags;

`VkPipelineShaderStageCreateFlags` is a bitmask type for setting a mask of zero or more VkPipelineShaderStageCreateFlagBits.

Possible values of the `flags` member of VkPipelineShaderStageCreateInfo specifying how a pipeline shader stage is created, are:

    // Provided by VK_VERSION_1_0
    typedef enum VkPipelineShaderStageCreateFlagBits {
      // Provided by VK_VERSION_1_3
        VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0x00000001,
      // Provided by VK_VERSION_1_3
        VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0x00000002,
      // Provided by VK_EXT_subgroup_size_control
        VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT,
      // Provided by VK_EXT_subgroup_size_control
        VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT,
    } VkPipelineShaderStageCreateFlagBits;

- `VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT` specifies that the `SubgroupSize` may vary in the shader stage.

- `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT` specifies that the subgroup sizes must be launched with all invocations active in the task, mesh, or compute stage.

Note | If `VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT` and `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT` are specified and `minSubgroupSize` does not equal `maxSubgroupSize` and no required subgroup size is specified, then the only way to guarantee that the 'X' dimension of the local workgroup size is a multiple of `SubgroupSize` is to make it a multiple of `maxSubgroupSize`. Under these conditions, you are guaranteed full subgroups but not any particular subgroup size.

Bits which can be set by commands and structures, specifying one or more shader stages, are:

    // Provided by VK_VERSION_1_0
    typedef enum VkShaderStageFlagBits {
        VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
        VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
        VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
        VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
        VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
        VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
        VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
        VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000,
      // Provided by VK_EXT_mesh_shader
        VK_SHADER_STAGE_TASK_BIT_EXT = 0x00000040,
      // Provided by VK_EXT_mesh_shader
        VK_SHADER_STAGE_MESH_BIT_EXT = 0x00000080,
      // Provided by VK_HUAWEI_subpass_shading
        VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000,
      // Provided by VK_HUAWEI_cluster_culling_shader
        VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0x00080000,
      // Provided by VK_NV_ray_tracing
        VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
      // Provided by VK_NV_ray_tracing
        VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
      // Provided by VK_NV_ray_tracing
        VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
      // Provided by VK_NV_ray_tracing
        VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR,
      // Provided by VK_NV_ray_tracing
        VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
      // Provided by VK_NV_ray_tracing
        VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
      // Provided by VK_NV_mesh_shader
        VK_SHADER_STAGE_TASK_BIT_NV = VK_SHADER_STAGE_TASK_BIT_EXT,
      // Provided by VK_NV_mesh_shader
        VK_SHADER_STAGE_MESH_BIT_NV = VK_SHADER_STAGE_MESH_BIT_EXT,
    } VkShaderStageFlagBits;

- `VK_SHADER_STAGE_VERTEX_BIT` specifies the vertex stage.

- `VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT` specifies the tessellation control stage.

- `VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT` specifies the tessellation evaluation stage.

- `VK_SHADER_STAGE_GEOMETRY_BIT` specifies the geometry stage.

- `VK_SHADER_STAGE_FRAGMENT_BIT` specifies the fragment stage.

- `VK_SHADER_STAGE_COMPUTE_BIT` specifies the compute stage.

- `VK_SHADER_STAGE_ALL_GRAPHICS` is a combination of bits used as shorthand to specify all graphics stages defined above (excluding the compute stage).

- `VK_SHADER_STAGE_ALL` is a combination of bits used as shorthand to specify all shader stages supported by the device, including all additional stages which are introduced by extensions.

- `VK_SHADER_STAGE_TASK_BIT_EXT` specifies the task stage.

- `VK_SHADER_STAGE_MESH_BIT_EXT` specifies the mesh stage.

- `VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI` specifies the cluster culling stage.

- `VK_SHADER_STAGE_RAYGEN_BIT_KHR` specifies the ray generation stage.

- `VK_SHADER_STAGE_ANY_HIT_BIT_KHR` specifies the any-hit stage.

- `VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR` specifies the closest hit stage.

- `VK_SHADER_STAGE_MISS_BIT_KHR` specifies the miss stage.

- `VK_SHADER_STAGE_INTERSECTION_BIT_KHR` specifies the intersection stage.

- `VK_SHADER_STAGE_CALLABLE_BIT_KHR` specifies the callable stage.

Note | `VK_SHADER_STAGE_ALL_GRAPHICS` only includes the original five graphics stages included in Vulkan 1.0, and not any stages added by extensions. Thus, it may not have the desired effect in all cases.

    // Provided by VK_VERSION_1_0
    typedef VkFlags VkShaderStageFlags;

`VkShaderStageFlags` is a bitmask type for setting a mask of zero or more VkShaderStageFlagBits.

The `VkPipelineShaderStageRequiredSubgroupSizeCreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           requiredSubgroupSize;
    } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;

or the equivalent

    // Provided by VK_EXT_subgroup_size_control
    typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;

or the equiavlent

    // Provided by VK_EXT_shader_object
    typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkShaderRequiredSubgroupSizeCreateInfoEXT;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `requiredSubgroupSize` is an unsigned integer value specifying the required subgroup size for the newly created pipeline shader stage.

If a `VkPipelineShaderStageRequiredSubgroupSizeCreateInfo` structure is included in the `pNext` chain of VkPipelineShaderStageCreateInfo, it specifies that the pipeline shader stage being compiled has a required subgroup size.

If a `VkShaderRequiredSubgroupSizeCreateInfoEXT` structure is included in the `pNext` chain of VkShaderCreateInfoEXT, it specifies that the shader being compiled has a required subgroup size.

Valid Usage

- VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfo-requiredSubgroupSize-02760
  `requiredSubgroupSize` must be a power-of-two integer

- VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfo-requiredSubgroupSize-02761
  `requiredSubgroupSize` must be greater or equal to `minSubgroupSize`

- VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfo-requiredSubgroupSize-02762
  `requiredSubgroupSize` must be less than or equal to `maxSubgroupSize`

Valid Usage (Implicit)

- VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO`

A subpass shading pipeline is a compute pipeline which must be called only in a subpass of a render pass with work dimensions specified by render area size. The subpass shading pipeline shader is a compute shader allowed to access input attachments specified in the calling subpass. To create a subpass shading pipeline, call vkCreateComputePipelines with VkSubpassShadingPipelineCreateInfoHUAWEI in the `pNext` chain of VkComputePipelineCreateInfo.

The `VkSubpassShadingPipelineCreateInfoHUAWEI` structure is defined as:

    // Provided by VK_HUAWEI_subpass_shading
    typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI {
        VkStructureType    sType;
        void*              pNext;
        VkRenderPass       renderPass;
        uint32_t           subpass;
    } VkSubpassShadingPipelineCreateInfoHUAWEI;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `renderPass` is a handle to a render pass object describing the environment in which the pipeline will be used. The pipeline must only be used with a render pass instance compatible with the one provided. See Render Pass Compatibility for more information.

- `subpass` is the index of the subpass in the render pass where this pipeline will be used.

Valid Usage

- VUID-VkSubpassShadingPipelineCreateInfoHUAWEI-subpass-04946
  `subpass` must be created with `VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI` bind point

Valid Usage (Implicit)

- VUID-VkSubpassShadingPipelineCreateInfoHUAWEI-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI`

- VUID-VkSubpassShadingPipelineCreateInfoHUAWEI-renderPass-parameter
  `renderPass` must be a valid VkRenderPass handle

A subpass shading pipeline’s workgroup size is a 2D vector with number of power-of-two in width and height. The maximum number of width and height is implementation-dependent, and may vary for different formats and sample counts of attachments in a render pass.

To query the maximum workgroup size, call:

    // Provided by VK_HUAWEI_subpass_shading
    VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
        VkDevice                                    device,
        VkRenderPass                                renderpass,
        VkExtent2D*                                 pMaxWorkgroupSize);

- `device` is a handle to a local device object that was used to create the given render pass.

- `renderPass` is a handle to a render pass object describing the environment in which the pipeline will be used. The pipeline must only be used with a render pass instance compatible with the one provided. See Render Pass Compatibility for more information.

- `pMaxWorkgroupSize` is a pointer to a VkExtent2D structure.

Valid Usage (Implicit)

- VUID-vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI-renderpass-parameter
  `renderpass` must be a valid VkRenderPass handle

- VUID-vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI-pMaxWorkgroupSize-parameter
  `pMaxWorkgroupSize` must be a valid pointer to VkExtent2D structures

- VUID-vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI-renderpass-parent
  `renderpass` must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

  - `VK_ERROR_SURFACE_LOST_KHR`

The `VkPipelineRobustnessCreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_4
    typedef struct VkPipelineRobustnessCreateInfo {
        VkStructureType                       sType;
        const void*                           pNext;
        VkPipelineRobustnessBufferBehavior    storageBuffers;
        VkPipelineRobustnessBufferBehavior    uniformBuffers;
        VkPipelineRobustnessBufferBehavior    vertexInputs;
        VkPipelineRobustnessImageBehavior     images;
    } VkPipelineRobustnessCreateInfo;

or the equivalent

    // Provided by VK_EXT_pipeline_robustness
    typedef VkPipelineRobustnessCreateInfo VkPipelineRobustnessCreateInfoEXT;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `storageBuffers` sets the behavior of out of bounds accesses made to resources bound as:

  - `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER`

  - `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER`

  - `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`

- `uniformBuffers` describes the behavior of out of bounds accesses made to resources bound as:

  - `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER`

  - `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER`

  - `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC`

  - `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK`

- `vertexInputs` describes the behavior of out of bounds accesses made to vertex input attributes

- `images` describes the behavior of out of bounds accesses made to resources bound as:

  - `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE`

  - `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE`

Resources bound as `VK_DESCRIPTOR_TYPE_MUTABLE_EXT` will have the robustness behavior that covers its active descriptor type.

The scope of the effect of `VkPipelineRobustnessCreateInfo` depends on which structure’s `pNext` chain it is included in.

- `VkGraphicsPipelineCreateInfo`, `VkRayTracingPipelineCreateInfoKHR`, `VkComputePipelineCreateInfo`:
  The robustness behavior described by `VkPipelineRobustnessCreateInfo` applies to all accesses through this pipeline

- `VkPipelineShaderStageCreateInfo`:
  The robustness behavior described by `VkPipelineRobustnessCreateInfo` applies to all accesses emanating from the shader code of this shader stage

If `VkPipelineRobustnessCreateInfo` is specified for both a pipeline and a pipeline stage, the `VkPipelineRobustnessCreateInfo` specified for the pipeline stage will take precedence.

When `VkPipelineRobustnessCreateInfo` is specified for a pipeline, it only affects the subset of the pipeline that is specified by the create info, as opposed to subsets linked from pipeline libraries. For VkGraphicsPipelineCreateInfo, that subset is specified by VkGraphicsPipelineLibraryCreateInfoEXT::`flags`. For VkRayTracingPipelineCreateInfoKHR, that subset is specified by the specific stages in VkRayTracingPipelineCreateInfoKHR::`pStages`.

Valid Usage

- VUID-VkPipelineRobustnessCreateInfo-pipelineRobustness-06926
  If the `pipelineRobustness` feature is not enabled, `storageBuffers` must be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT`

- VUID-VkPipelineRobustnessCreateInfo-pipelineRobustness-06927
  If the `pipelineRobustness` feature is not enabled, `uniformBuffers` must be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT`

- VUID-VkPipelineRobustnessCreateInfo-pipelineRobustness-06928
  If the `pipelineRobustness` feature is not enabled, `vertexInputs` must be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT`

- VUID-VkPipelineRobustnessCreateInfo-pipelineRobustness-06929
  If the `pipelineRobustness` feature is not enabled, `images` must be `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT`

- VUID-VkPipelineRobustnessCreateInfo-robustImageAccess-06930
  If the `robustImageAccess` feature is not supported, `images` must not be `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS`

- VUID-VkPipelineRobustnessCreateInfo-robustBufferAccess2-06931
  If the `robustBufferAccess2` feature is not supported, `storageBuffers` must not be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2`

- VUID-VkPipelineRobustnessCreateInfo-robustBufferAccess2-06932
  If the `robustBufferAccess2` feature is not supported, `uniformBuffers` must not be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2`

- VUID-VkPipelineRobustnessCreateInfo-robustBufferAccess2-06933
  If the `robustBufferAccess2` feature is not supported, `vertexInputs` must not be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2`

- VUID-VkPipelineRobustnessCreateInfo-robustImageAccess2-06934
  If the `robustImageAccess2` feature is not supported, `images` must not be `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2`

Valid Usage (Implicit)

- VUID-VkPipelineRobustnessCreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO`

- VUID-VkPipelineRobustnessCreateInfo-storageBuffers-parameter
  `storageBuffers` must be a valid VkPipelineRobustnessBufferBehavior value

- VUID-VkPipelineRobustnessCreateInfo-uniformBuffers-parameter
  `uniformBuffers` must be a valid VkPipelineRobustnessBufferBehavior value

- VUID-VkPipelineRobustnessCreateInfo-vertexInputs-parameter
  `vertexInputs` must be a valid VkPipelineRobustnessBufferBehavior value

- VUID-VkPipelineRobustnessCreateInfo-images-parameter
  `images` must be a valid VkPipelineRobustnessImageBehavior value

Possible values of the `storageBuffers`, `uniformBuffers`, and `vertexInputs` members of VkPipelineRobustnessCreateInfo are:

    // Provided by VK_VERSION_1_4
    typedef enum VkPipelineRobustnessBufferBehavior {
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT = 0,
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED = 1,
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS = 2,
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 = 3,
      // Provided by VK_EXT_pipeline_robustness
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT,
      // Provided by VK_EXT_pipeline_robustness
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED,
      // Provided by VK_EXT_pipeline_robustness
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS,
      // Provided by VK_EXT_pipeline_robustness
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2,
    } VkPipelineRobustnessBufferBehavior;

or the equivalent

    // Provided by VK_EXT_pipeline_robustness
    typedef VkPipelineRobustnessBufferBehavior VkPipelineRobustnessBufferBehaviorEXT;

- `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT` specifies that this pipeline stage follows the behavior of robustness features that are enabled that created this pipeline

- `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED` specifies that buffer accesses by this pipeline stage to the relevant resource types must not be out of bounds

- `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS` specifies that out of bounds accesses by this pipeline stage to the relevant resource types behave as if the `robustBufferAccess` feature is enabled

- `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2` specifies that out of bounds accesses by this pipeline stage to the relevant resource types behave as if the `robustBufferAccess2` feature is enabled

Possible values of the `images` member of VkPipelineRobustnessCreateInfo are:

    // Provided by VK_VERSION_1_4
    typedef enum VkPipelineRobustnessImageBehavior {
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT = 0,
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED = 1,
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS = 2,
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2 = 3,
      // Provided by VK_EXT_pipeline_robustness
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT,
      // Provided by VK_EXT_pipeline_robustness
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED,
      // Provided by VK_EXT_pipeline_robustness
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS,
      // Provided by VK_EXT_pipeline_robustness
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2,
    } VkPipelineRobustnessImageBehavior;

or the equivalent

    // Provided by VK_EXT_pipeline_robustness
    typedef VkPipelineRobustnessImageBehavior VkPipelineRobustnessImageBehaviorEXT;

- `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT` specifies that this pipeline stage follows the behavior of robustness features that are enabled on the device that created this pipeline

- `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED` specifies that image accesses by this pipeline stage to the relevant resource types must not be out of bounds

- `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS` specifies that out of bounds accesses by this pipeline stage to images behave as if the `robustImageAccess` feature is enabled

- `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2` specifies that out of bounds accesses by this pipeline stage to images behave as if the `robustImageAccess2` feature is enabled

An identifier can be provided instead of shader code in an attempt to compile pipelines without providing complete SPIR-V to the implementation.

The `VkPipelineShaderStageModuleIdentifierCreateInfoEXT` structure is defined as:

    // Provided by VK_EXT_shader_module_identifier
    typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT {
        VkStructureType    sType;
        const void*        pNext;
        uint32_t           identifierSize;
        const uint8_t*     pIdentifier;
    } VkPipelineShaderStageModuleIdentifierCreateInfoEXT;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `identifierSize` is the size, in bytes, of the buffer pointed to by `pIdentifier`.

- `pIdentifier` is a pointer to a buffer of opaque data specifying an identifier.

Any identifier can be used. If the pipeline being created with identifier requires compilation to complete the pipeline creation call, pipeline compilation must fail as defined by `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT`.

`pIdentifier` and `identifierSize` can be obtained from an VkShaderModuleIdentifierEXT queried earlier.

Valid Usage

- VUID-VkPipelineShaderStageModuleIdentifierCreateInfoEXT-pNext-06850
  If this structure is included in a `pNext` chain and `identifierSize` is not equal to 0, the `shaderModuleIdentifier` feature must be enabled

- VUID-VkPipelineShaderStageModuleIdentifierCreateInfoEXT-pNext-06851
  If this struct is included in a `pNext` chain of VkPipelineShaderStageCreateInfo and `identifierSize` is not equal to 0, the pipeline must be created with the `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` flag set

- VUID-VkPipelineShaderStageModuleIdentifierCreateInfoEXT-identifierSize-06852
  `identifierSize` must be less-or-equal to `VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT`

Valid Usage (Implicit)

- VUID-VkPipelineShaderStageModuleIdentifierCreateInfoEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT`

- VUID-VkPipelineShaderStageModuleIdentifierCreateInfoEXT-pIdentifier-parameter
  If `identifierSize` is not `0`, `pIdentifier` must be a valid pointer to an array of `identifierSize` `uint8_t` values

If a compute pipeline is going to be used in Device-Generated Commands by specifying its pipeline token with VkBindPipelineIndirectCommandNV, then that pipeline’s associated metadata must be saved at a specified buffer device address for later use in indirect command generation. The buffer device address must be specified at the time of compute pipeline creation with VkComputePipelineIndirectBufferInfoNV structure in the `pNext` chain of VkComputePipelineCreateInfo.

The `VkComputePipelineIndirectBufferInfoNV` structure is defined as:

    // Provided by VK_NV_device_generated_commands_compute
    typedef struct VkComputePipelineIndirectBufferInfoNV {
        VkStructureType    sType;
        const void*        pNext;
        VkDeviceAddress    deviceAddress;
        VkDeviceSize       size;
        VkDeviceAddress    pipelineDeviceAddressCaptureReplay;
    } VkComputePipelineIndirectBufferInfoNV;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `deviceAddress` is the address where the pipeline’s metadata will be stored.

- `size` is the size of pipeline’s metadata that was queried using vkGetPipelineIndirectMemoryRequirementsNV.

- `pipelineDeviceAddressCaptureReplay` is the device address where pipeline’s metadata was originally saved and can now be used to re-populate `deviceAddress` for replay.

If `pipelineDeviceAddressCaptureReplay` is zero, no specific address is requested. If `pipelineDeviceAddressCaptureReplay` is not zero, then it must be an address retrieved from an identically created pipeline on the same implementation. The pipeline metadata must also be placed on an identically created buffer and at the same offset using the vkCmdUpdatePipelineIndirectBufferNV command.

Valid Usage

- VUID-VkComputePipelineIndirectBufferInfoNV-deviceGeneratedComputePipelines-09009
  The `VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV`::`deviceGeneratedComputePipelines` feature must be enabled

- VUID-VkComputePipelineIndirectBufferInfoNV-flags-09010
  The pipeline creation flags in VkComputePipelineCreateInfo::`flags` must include `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV`

- VUID-VkComputePipelineIndirectBufferInfoNV-deviceAddress-09011
  `deviceAddress` must be aligned to the VkMemoryRequirements2::`alignment`, as returned by vkGetPipelineIndirectMemoryRequirementsNV

- VUID-VkComputePipelineIndirectBufferInfoNV-deviceAddress-09012
  `deviceAddress` must have been allocated from a buffer that was created with usage `VK_BUFFER_USAGE_TRANSFER_DST_BIT` and `VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT`

- VUID-VkComputePipelineIndirectBufferInfoNV-size-09013
  `size` must be greater than or equal to the VkMemoryRequirements2::`size`, as returned by vkGetPipelineIndirectMemoryRequirementsNV

- VUID-VkComputePipelineIndirectBufferInfoNV-pipelineDeviceAddressCaptureReplay-09014
  If `pipelineDeviceAddressCaptureReplay` is non-zero then the `VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV`::`deviceGeneratedComputeCaptureReplay` feature must be enabled

- VUID-VkComputePipelineIndirectBufferInfoNV-pipelineDeviceAddressCaptureReplay-09015
  If `pipelineDeviceAddressCaptureReplay` is non-zero then that address must have been allocated with flag `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT` set

- VUID-VkComputePipelineIndirectBufferInfoNV-pipelineDeviceAddressCaptureReplay-09016
  If `pipelineDeviceAddressCaptureReplay` is non-zero, the `pipeline` must have been recreated for replay

- VUID-VkComputePipelineIndirectBufferInfoNV-pipelineDeviceAddressCaptureReplay-09017
  `pipelineDeviceAddressCaptureReplay` must satisfy the `alignment` and `size` requirements similar to `deviceAddress`

Valid Usage (Implicit)

- VUID-VkComputePipelineIndirectBufferInfoNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV`

To save a compute pipeline’s metadata at a device address call:

    // Provided by VK_NV_device_generated_commands_compute
    void vkCmdUpdatePipelineIndirectBufferNV(
        VkCommandBuffer                             commandBuffer,
        VkPipelineBindPoint                         pipelineBindPoint,
        VkPipeline                                  pipeline);

- `commandBuffer` is the command buffer into which the command will be recorded.

- `pipelineBindPoint` is a VkPipelineBindPoint value specifying the type of pipeline whose metadata will be saved.

- `pipeline` is the pipeline whose metadata will be saved.

`vkCmdUpdatePipelineIndirectBufferNV` is only allowed outside of a render pass. This command is treated as a “transfer” operation for the purposes of synchronization barriers. The writes to the address must be synchronized using stages `VK_PIPELINE_STAGE_2_COPY_BIT` and `VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV` and with access masks `VK_ACCESS_MEMORY_WRITE_BIT` and `VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV` respectively before using the results in preprocessing.

Valid Usage

- VUID-vkCmdUpdatePipelineIndirectBufferNV-pipelineBindPoint-09018
  `pipelineBindPoint` must be `VK_PIPELINE_BIND_POINT_COMPUTE`

- VUID-vkCmdUpdatePipelineIndirectBufferNV-pipeline-09019
  `pipeline` must have been created with `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV` flag set

- VUID-vkCmdUpdatePipelineIndirectBufferNV-pipeline-09020
  `pipeline` must have been created with VkComputePipelineIndirectBufferInfoNV structure specifying a valid address where its metadata will be saved

- VUID-vkCmdUpdatePipelineIndirectBufferNV-deviceGeneratedComputePipelines-09021
  The `VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV`::`deviceGeneratedComputePipelines` feature must be enabled

Valid Usage (Implicit)

- VUID-vkCmdUpdatePipelineIndirectBufferNV-commandBuffer-parameter
  `commandBuffer` must be a valid VkCommandBuffer handle

- VUID-vkCmdUpdatePipelineIndirectBufferNV-pipelineBindPoint-parameter
  `pipelineBindPoint` must be a valid VkPipelineBindPoint value

- VUID-vkCmdUpdatePipelineIndirectBufferNV-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

- VUID-vkCmdUpdatePipelineIndirectBufferNV-commandBuffer-recording
  `commandBuffer` must be in the recording state

- VUID-vkCmdUpdatePipelineIndirectBufferNV-commandBuffer-cmdpool
  The `VkCommandPool` that `commandBuffer` was allocated from must support transfer, graphics, or compute operations

- VUID-vkCmdUpdatePipelineIndirectBufferNV-renderpass
  This command must only be called outside of a render pass instance

- VUID-vkCmdUpdatePipelineIndirectBufferNV-videocoding
  This command must only be called outside of a video coding scope

- VUID-vkCmdUpdatePipelineIndirectBufferNV-commonparent
  Both of `commandBuffer`, and `pipeline` must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

- Host access to `commandBuffer` must be externally synchronized

- Host access to the `VkCommandPool` that `commandBuffer` was allocated from must be externally synchronized

Command Properties

Command Buffer Levels | Render Pass Scope | Video Coding Scope | Supported Queue Types | Command Type
--- | --- | --- | --- | ---
Primary Secondary | Outside | Outside | Transfer Graphics Compute | Action

### 10.3. Graphics Pipelines

Graphics pipelines consist of multiple shader stages, multiple fixed-function pipeline stages, and a pipeline layout.

To create graphics pipelines, call:

    // Provided by VK_VERSION_1_0
    VkResult vkCreateGraphicsPipelines(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        uint32_t                                    createInfoCount,
        const VkGraphicsPipelineCreateInfo*         pCreateInfos,
        const VkAllocationCallbacks*                pAllocator,
        VkPipeline*                                 pPipelines);

- `device` is the logical device that creates the graphics pipelines.

- `pipelineCache` is either VK_NULL_HANDLE, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command.

- `createInfoCount` is the length of the `pCreateInfos` and `pPipelines` arrays.

- `pCreateInfos` is a pointer to an array of VkGraphicsPipelineCreateInfo structures.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

- `pPipelines` is a pointer to an array of VkPipeline handles in which the resulting graphics pipeline objects are returned.

The VkGraphicsPipelineCreateInfo structure includes an array of VkPipelineShaderStageCreateInfo structures for each of the desired active shader stages, as well as creation information for all relevant fixed-function stages, and a pipeline layout.

Pipelines are created and returned as described for Multiple Pipeline Creation.

Valid Usage

- VUID-vkCreateGraphicsPipelines-device-09662
  `device` must support at least one queue family with the `VK_QUEUE_GRAPHICS_BIT` capability

- VUID-vkCreateGraphicsPipelines-flags-00720
  If the `flags` member of any element of `pCreateInfos` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and the `basePipelineIndex` member of that same element is not `-1`, `basePipelineIndex` must be less than the index into `pCreateInfos` that corresponds to that element

- VUID-vkCreateGraphicsPipelines-flags-00721
  If the `flags` member of any element of `pCreateInfos` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, the base pipeline must have been created with the `VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT` flag set

- VUID-vkCreateGraphicsPipelines-pipelineCache-02876
  If `pipelineCache` was created with `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT`, host access to `pipelineCache` must be externally synchronized

- VUID-vkCreateGraphicsPipelines-pNext-09616
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `pipelineCache` must be VK_NULL_HANDLE

- VUID-vkCreateGraphicsPipelines-pNext-09617
  If a VkPipelineCreateFlags2CreateInfoKHR structure with the `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` flag set is included in the `pNext` chain of any element of `pCreateInfos`, `pipelineCache` must be VK_NULL_HANDLE

- VUID-vkCreateGraphicsPipelines-binaryCount-09620
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT` must not be set in the `flags` of that element

- VUID-vkCreateGraphicsPipelines-binaryCount-09621
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT` must not be set in the `flags` of that element

- VUID-vkCreateGraphicsPipelines-binaryCount-09622
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT` must not be set in the `flags` of that element

Note | An implicit cache may be provided by the implementation or a layer. For this reason, it is still valid to set `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` on `flags` for any element of `pCreateInfos` while passing VK_NULL_HANDLE for `pipelineCache`.

Valid Usage (Implicit)

- VUID-vkCreateGraphicsPipelines-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkCreateGraphicsPipelines-pipelineCache-parameter
  If `pipelineCache` is not VK_NULL_HANDLE, `pipelineCache` must be a valid VkPipelineCache handle

- VUID-vkCreateGraphicsPipelines-pCreateInfos-parameter
  `pCreateInfos` must be a valid pointer to an array of `createInfoCount` valid VkGraphicsPipelineCreateInfo structures

- VUID-vkCreateGraphicsPipelines-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

- VUID-vkCreateGraphicsPipelines-pPipelines-parameter
  `pPipelines` must be a valid pointer to an array of `createInfoCount` VkPipeline handles

- VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength
  `createInfoCount` must be greater than `0`

- VUID-vkCreateGraphicsPipelines-pipelineCache-parent
  If `pipelineCache` is a valid handle, it must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_PIPELINE_COMPILE_REQUIRED_EXT`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

  - `VK_ERROR_INVALID_SHADER_NV`

The `VkGraphicsPipelineCreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkGraphicsPipelineCreateInfo {
        VkStructureType                                  sType;
        const void*                                      pNext;
        VkPipelineCreateFlags                            flags;
        uint32_t                                         stageCount;
        const VkPipelineShaderStageCreateInfo*           pStages;
        const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
        const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
        const VkPipelineTessellationStateCreateInfo*     pTessellationState;
        const VkPipelineViewportStateCreateInfo*         pViewportState;
        const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
        const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
        const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
        const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
        const VkPipelineDynamicStateCreateInfo*          pDynamicState;
        VkPipelineLayout                                 layout;
        VkRenderPass                                     renderPass;
        uint32_t                                         subpass;
        VkPipeline                                       basePipelineHandle;
        int32_t                                          basePipelineIndex;
    } VkGraphicsPipelineCreateInfo;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `flags` is a bitmask of VkPipelineCreateFlagBits specifying how the pipeline will be generated.

- `stageCount` is the number of entries in the `pStages` array.

- `pStages` is a pointer to an array of `stageCount` VkPipelineShaderStageCreateInfo structures describing the set of the shader stages to be included in the graphics pipeline.

- `pVertexInputState` is a pointer to a VkPipelineVertexInputStateCreateInfo structure. It is ignored if the pipeline includes a mesh shader stage. It can be `NULL` if the pipeline is created with the `VK_DYNAMIC_STATE_VERTEX_INPUT_EXT` dynamic state set.

- `pInputAssemblyState` is a pointer to a VkPipelineInputAssemblyStateCreateInfo structure which determines input assembly behavior for vertex shading, as described in Drawing Commands. If the `VK_EXT_extended_dynamic_state3` extension is enabled, it can be `NULL` if the pipeline is created with both `VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE`, and `VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY` dynamic states set and `dynamicPrimitiveTopologyUnrestricted` is `VK_TRUE`. It is ignored if the pipeline includes a mesh shader stage.

- `pTessellationState` is a pointer to a VkPipelineTessellationStateCreateInfo structure defining tessellation state used by tessellation shaders. It can be `NULL` if the pipeline is created with the `VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT` dynamic state set.

- `pViewportState` is a pointer to a VkPipelineViewportStateCreateInfo structure defining viewport state used when rasterization is enabled. If the `VK_EXT_extended_dynamic_state3` extension is enabled, it can be `NULL` if the pipeline is created with both `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT`, and `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT` dynamic states set.

- `pRasterizationState` is a pointer to a VkPipelineRasterizationStateCreateInfo structure defining rasterization state. If the `VK_EXT_extended_dynamic_state3` extension is enabled, it can be `NULL` if the pipeline is created with all of `VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT`, `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE`, `VK_DYNAMIC_STATE_POLYGON_MODE_EXT`, `VK_DYNAMIC_STATE_CULL_MODE`, `VK_DYNAMIC_STATE_FRONT_FACE`, `VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE`, `VK_DYNAMIC_STATE_DEPTH_BIAS`, and `VK_DYNAMIC_STATE_LINE_WIDTH` dynamic states set.

- `pMultisampleState` is a pointer to a VkPipelineMultisampleStateCreateInfo structure defining multisample state used when rasterization is enabled. If the `VK_EXT_extended_dynamic_state3` extension is enabled, it can be `NULL` if the pipeline is created with all of `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT`, `VK_DYNAMIC_STATE_SAMPLE_MASK_EXT`, and `VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT` dynamic states set, and either the alphaToOne feature is not enabled or `VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT` is set, in which case VkPipelineMultisampleStateCreateInfo::`sampleShadingEnable` is assumed to be `VK_FALSE`.

- `pDepthStencilState` is a pointer to a VkPipelineDepthStencilStateCreateInfo structure defining depth/stencil state used when rasterization is enabled for depth or stencil attachments accessed during rendering. If the `VK_EXT_extended_dynamic_state3` extension is enabled, it can be `NULL` if the pipeline is created with all of `VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE`, `VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE`, `VK_DYNAMIC_STATE_DEPTH_COMPARE_OP`, `VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE`, `VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE`, `VK_DYNAMIC_STATE_STENCIL_OP`, and `VK_DYNAMIC_STATE_DEPTH_BOUNDS` dynamic states set.

- `pColorBlendState` is a pointer to a VkPipelineColorBlendStateCreateInfo structure defining color blend state used when rasterization is enabled for any color attachments accessed during rendering. If the `VK_EXT_extended_dynamic_state3` extension is enabled, it can be `NULL` if the pipeline is created with all of `VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT`, `VK_DYNAMIC_STATE_LOGIC_OP_EXT`, `VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT`, `VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT`, `VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT`, and `VK_DYNAMIC_STATE_BLEND_CONSTANTS` dynamic states set.

- `pDynamicState` is a pointer to a VkPipelineDynamicStateCreateInfo structure defining which properties of the pipeline state object are dynamic and can be changed independently of the pipeline state. This can be `NULL`, which means no state in the pipeline is considered dynamic.

- `layout` is the description of binding locations used by both the pipeline and descriptor sets used with the pipeline.

- `renderPass` is a handle to a render pass object describing the environment in which the pipeline will be used. The pipeline must only be used with a render pass instance compatible with the one provided. See Render Pass Compatibility for more information.

- `subpass` is the index of the subpass in the render pass where this pipeline will be used.

- `basePipelineHandle` is a pipeline to derive from.

- `basePipelineIndex` is an index into the `pCreateInfos` parameter to use as a pipeline to derive from.

The parameters `basePipelineHandle` and `basePipelineIndex` are described in more detail in Pipeline Derivatives.

If any shader stage fails to compile, the compile log will be reported back to the application, and `VK_ERROR_INVALID_SHADER_NV` will be generated.

Note | With `VK_EXT_extended_dynamic_state3`, it is possible that many of the `VkGraphicsPipelineCreateInfo` members above can be `NULL` because all their state is dynamic and therefore ignored. This is optional so the application can still use a valid pointer if it needs to set the `pNext` or `flags` fields to specify state for other extensions.

The state required for a graphics pipeline is divided into vertex input state, pre-rasterization shader state, fragment shader state, and fragment output state.

Vertex Input State

Vertex input state is defined by:

- VkPipelineVertexInputStateCreateInfo

- VkPipelineInputAssemblyStateCreateInfo

If this pipeline specifies pre-rasterization state either directly or by including it as a pipeline library and its `pStages` includes a vertex shader, this state must be specified to create a complete graphics pipeline.

If a pipeline includes `VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT` in VkGraphicsPipelineLibraryCreateInfoEXT::`flags` either explicitly or as a default, and either the conditions requiring this state for a complete graphics pipeline are met or this pipeline does not specify pre-rasterization state in any way, that pipeline must specify this state directly.

Pre-Rasterization Shader State

Pre-rasterization shader state is defined by:

- VkPipelineShaderStageCreateInfo entries for:

  - Vertex shaders

  - Tessellation control shaders

  - Tessellation evaluation shaders

  - Geometry shaders

  - Task shaders

  - Mesh shaders

- Within the VkPipelineLayout, all descriptor sets with pre-rasterization shader bindings if `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT` was specified.

  - If `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT` was not specified, the full pipeline layout must be specified.

- VkPipelineViewportStateCreateInfo

- VkPipelineRasterizationStateCreateInfo

- VkPipelineTessellationStateCreateInfo

- VkRenderPass and `subpass` parameter

- The `viewMask` parameter of VkPipelineRenderingCreateInfo (formats are ignored)

- VkPipelineDiscardRectangleStateCreateInfoEXT

- VkPipelineFragmentShadingRateStateCreateInfoKHR

This state must be specified to create a complete graphics pipeline.

If either the `pNext` chain includes a VkGraphicsPipelineLibraryCreateInfoEXT structure with `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` included in `flags`, or it is not specified and would default to include that value, this state must be specified in the pipeline.

Fragment Shader State

Fragment shader state is defined by:

- A VkPipelineShaderStageCreateInfo entry for the fragment shader

- Within the VkPipelineLayout, all descriptor sets with fragment shader bindings if `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT` was specified.

  - If `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT` was not specified, the full pipeline layout must be specified.

- VkPipelineMultisampleStateCreateInfo if sample shading is enabled or `renderpass` is not VK_NULL_HANDLE

- VkPipelineDepthStencilStateCreateInfo

- VkRenderPass and `subpass` parameter

- The `viewMask` parameter of VkPipelineRenderingCreateInfo (formats are ignored)

- VkPipelineFragmentShadingRateStateCreateInfoKHR

- VkPipelineFragmentShadingRateEnumStateCreateInfoNV

- VkPipelineRepresentativeFragmentTestStateCreateInfoNV

- Inclusion/omission of the `VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR` flag

- Inclusion/omission of the `VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT` flag

- VkRenderingInputAttachmentIndexInfo

If a pipeline specifies pre-rasterization state either directly or by including it as a pipeline library and `rasterizerDiscardEnable` is `VK_FALSE` or `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE` is used, this state must be specified to create a complete graphics pipeline.

If a pipeline includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT` in VkGraphicsPipelineLibraryCreateInfoEXT::`flags` either explicitly or as a default, and either the conditions requiring this state for a complete graphics pipeline are met or this pipeline does not specify pre-rasterization state in any way, that pipeline must specify this state directly.

Fragment Output State

Fragment output state is defined by:

- VkPipelineColorBlendStateCreateInfo

- VkRenderPass and `subpass` parameter

- VkPipelineMultisampleStateCreateInfo

- VkPipelineRenderingCreateInfo

- VkAttachmentSampleCountInfoAMD

- VkAttachmentSampleCountInfoNV

- VkExternalFormatANDROID

- Inclusion/omission of the `VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT` and `VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT` flags

- Inclusion/omission of the `VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT` flag

- VkRenderingAttachmentLocationInfo

If a pipeline specifies pre-rasterization state either directly or by including it as a pipeline library and `rasterizerDiscardEnable` is `VK_FALSE` or `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE` is used, this state must be specified to create a complete graphics pipeline.

If a pipeline includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT` in VkGraphicsPipelineLibraryCreateInfoEXT::`flags` either explicitly or as a default, and either the conditions requiring this state for a complete graphics pipeline are met or this pipeline does not specify pre-rasterization state in any way, that pipeline must specify this state directly.

Dynamic State

Dynamic state values set via `pDynamicState` must be ignored if the state they correspond to is not otherwise statically set by one of the state subsets used to create the pipeline. Additionally, setting dynamic state values must not modify whether state in a linked library is static or dynamic; this is set and unchangeable when the library is created. For example, if a pipeline only included pre-rasterization shader state, then any dynamic state value corresponding to depth or stencil testing has no effect. Any linked library that has dynamic state enabled that same dynamic state must also be enabled in all the other linked libraries to which that dynamic state applies.

Complete Graphics Pipelines

A complete graphics pipeline always includes pre-rasterization shader state, with other subsets included depending on that state as specified in the above sections.

Graphics Pipeline Library Layouts

If different subsets are linked together with pipeline layouts created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, the final effective pipeline layout is effectively the union of the linked pipeline layouts. When binding descriptor sets for this pipeline, the pipeline layout used must be compatible with this union. This pipeline layout can be overridden when linking with `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT` by providing a VkPipelineLayout that is compatible with this union other than `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, or when linking without `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT` by providing a VkPipelineLayout that is fully compatible with this union.

If the `pNext` chain includes a VkPipelineCreateFlags2CreateInfo structure, VkPipelineCreateFlags2CreateInfo::`flags` from that structure is used instead of `flags` from this structure.

Valid Usage

- VUID-VkGraphicsPipelineCreateInfo-None-09497
  If the `pNext` chain does not include a VkPipelineCreateFlags2CreateInfo structure, `flags` must be a valid combination of VkPipelineCreateFlagBits values

- VUID-VkGraphicsPipelineCreateInfo-flags-07984
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is -1, `basePipelineHandle` must be a valid graphics `VkPipeline` handle

- VUID-VkGraphicsPipelineCreateInfo-flags-07985
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineHandle` is VK_NULL_HANDLE, `basePipelineIndex` must be a valid index into the calling command’s `pCreateInfos` parameter

- VUID-VkGraphicsPipelineCreateInfo-flags-07986
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, `basePipelineIndex` must be -1 or `basePipelineHandle` must be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-layout-07987
  If a push constant block is declared in a shader, a push constant range in `layout` must match the shader stage

- VUID-VkGraphicsPipelineCreateInfo-layout-10069
  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

- VUID-VkGraphicsPipelineCreateInfo-layout-07988
  If a resource variable is declared in a shader, the corresponding descriptor set in `layout` must match the shader stage

- VUID-VkGraphicsPipelineCreateInfo-layout-07990
  If a resource variable is declared in a shader, and the descriptor type is not `VK_DESCRIPTOR_TYPE_MUTABLE_EXT`, the corresponding descriptor set in `layout` must match the descriptor type

- VUID-VkGraphicsPipelineCreateInfo-layout-07991
  If a resource variable is declared in a shader as an array, the corresponding descriptor set in `layout` must match the descriptor count

- VUID-VkGraphicsPipelineCreateInfo-None-10391
  If a resource variables is declared in a shader as an array of descriptors, then the descriptor type of that variable must not be `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK`

- VUID-VkGraphicsPipelineCreateInfo-stage-02096
  If the pipeline requires pre-rasterization shader state the `stage` member of one element of `pStages` must be `VK_SHADER_STAGE_VERTEX_BIT` or `VK_SHADER_STAGE_MESH_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pStages-02095
  If the pipeline requires pre-rasterization shader state the geometric shader stages provided in `pStages` must be either from the mesh shading pipeline (`stage` is `VK_SHADER_STAGE_TASK_BIT_EXT` or `VK_SHADER_STAGE_MESH_BIT_EXT`) or from the primitive shading pipeline (`stage` is `VK_SHADER_STAGE_VERTEX_BIT`, `VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT`, `VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT`, or `VK_SHADER_STAGE_GEOMETRY_BIT`)

- VUID-VkGraphicsPipelineCreateInfo-pStages-09631
  If the pipeline requires pre-rasterization shader state and `pStages` contains both `VK_SHADER_STAGE_TASK_BIT_EXT` and `VK_SHADER_STAGE_MESH_BIT_EXT`, then the mesh shader’s entry point must not declare a variable with a `DrawIndex` `BuiltIn` decoration

- VUID-VkGraphicsPipelineCreateInfo-TaskNV-07063
  The shader stages for `VK_SHADER_STAGE_TASK_BIT_EXT` or `VK_SHADER_STAGE_MESH_BIT_EXT` must use either the `TaskNV` and `MeshNV` `Execution` `Model` or the `TaskEXT` and `MeshEXT` `Execution` `Model`, but must not use both

- VUID-VkGraphicsPipelineCreateInfo-pStages-00729
  If the pipeline requires pre-rasterization shader state and `pStages` includes a tessellation control shader stage, it must include a tessellation evaluation shader stage

- VUID-VkGraphicsPipelineCreateInfo-pStages-00730
  If the pipeline requires pre-rasterization shader state and `pStages` includes a tessellation evaluation shader stage, it must include a tessellation control shader stage

- VUID-VkGraphicsPipelineCreateInfo-pStages-09022
  If the pipeline requires pre-rasterization shader state and `pStages` includes a tessellation control shader stage, and the `VK_EXT_extended_dynamic_state3` extension is not enabled or the `VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT` dynamic state is not set, `pTessellationState` must be a valid pointer to a valid VkPipelineTessellationStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pTessellationState-09023
  If `pTessellationState` is not `NULL` it must be a pointer to a valid VkPipelineTessellationStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pStages-00732
  If the pipeline requires pre-rasterization shader state and `pStages` includes tessellation shader stages, the shader code of at least one stage must contain an `OpExecutionMode` instruction specifying the type of subdivision in the pipeline

- VUID-VkGraphicsPipelineCreateInfo-pStages-00733
  If the pipeline requires pre-rasterization shader state and `pStages` includes tessellation shader stages, and the shader code of both stages contain an `OpExecutionMode` instruction specifying the type of subdivision in the pipeline, they must both specify the same subdivision mode

- VUID-VkGraphicsPipelineCreateInfo-pStages-00734
  If the pipeline requires pre-rasterization shader state and `pStages` includes tessellation shader stages, the shader code of at least one stage must contain an `OpExecutionMode` instruction specifying the output patch size in the pipeline

- VUID-VkGraphicsPipelineCreateInfo-pStages-00735
  If the pipeline requires pre-rasterization shader state and `pStages` includes tessellation shader stages, and the shader code of both contain an `OpExecutionMode` instruction specifying the out patch size in the pipeline, they must both specify the same patch size

- VUID-VkGraphicsPipelineCreateInfo-pStages-08888
  If the pipeline is being created with pre-rasterization shader state and vertex input state and `pStages` includes tessellation shader stages, and either `VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY` dynamic state is not enabled or `dynamicPrimitiveTopologyUnrestricted` is `VK_FALSE`, the `topology` member of `pInputAssembly` must be `VK_PRIMITIVE_TOPOLOGY_PATCH_LIST`

- VUID-VkGraphicsPipelineCreateInfo-topology-08889
  If the pipeline is being created with pre-rasterization shader state and vertex input state and the `topology` member of `pInputAssembly` is `VK_PRIMITIVE_TOPOLOGY_PATCH_LIST`, and either `VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY` dynamic state is not enabled or `dynamicPrimitiveTopologyUnrestricted` is `VK_FALSE`, then `pStages` must include tessellation shader stages

- VUID-VkGraphicsPipelineCreateInfo-TessellationEvaluation-07723
  If the pipeline is being created with a `TessellationEvaluation` `Execution` `Model`, no `Geometry` `Execution` `Model`, uses the `PointMode` `Execution` `Mode`, and the `shaderTessellationAndGeometryPointSize` feature is enabled, a `PointSize` decorated variable must be written to if the `maintenance5` feature is not enabled

- VUID-VkGraphicsPipelineCreateInfo-topology-08773
  If the pipeline is being created with a `Vertex` `Execution` `Model` and no `TessellationEvaluation` or `Geometry` `Execution` `Model`, and the `topology` member of `pInputAssembly` is `VK_PRIMITIVE_TOPOLOGY_POINT_LIST`, and either `VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY` dynamic state is not enabled or `dynamicPrimitiveTopologyUnrestricted` is `VK_FALSE`, a `PointSize` decorated variable must be written to if the `maintenance5` feature is not enabled

- VUID-VkGraphicsPipelineCreateInfo-maintenance5-08775
  If the `maintenance5` feature is enabled and a `PointSize` decorated variable is written to, all execution paths must write to a `PointSize` decorated variable

- VUID-VkGraphicsPipelineCreateInfo-TessellationEvaluation-07724
  If the pipeline is being created with a `TessellationEvaluation` `Execution` `Model`, no `Geometry` `Execution` `Model`, uses the `PointMode` `Execution` `Mode`, and the `shaderTessellationAndGeometryPointSize` feature is not enabled, a `PointSize` decorated variable must not be written to

- VUID-VkGraphicsPipelineCreateInfo-shaderTessellationAndGeometryPointSize-08776
  If the pipeline is being created with a `Geometry` `Execution` `Model`, uses the `OutputPoints` `Execution` `Mode`, and the `shaderTessellationAndGeometryPointSize` feature is enabled, a `PointSize` decorated variable must be written to for every vertex emitted if the `maintenance5` feature is not enabled

- VUID-VkGraphicsPipelineCreateInfo-Geometry-07726
  If the pipeline is being created with a `Geometry` `Execution` `Model`, uses the `OutputPoints` `Execution` `Mode`, and the `shaderTessellationAndGeometryPointSize` feature is not enabled, a `PointSize` decorated variable must not be written to

- VUID-VkGraphicsPipelineCreateInfo-pStages-00738
  If the pipeline requires pre-rasterization shader state and `pStages` includes a geometry shader stage, and does not include any tessellation shader stages, its shader code must contain an `OpExecutionMode` instruction specifying an input primitive type that is compatible with the primitive topology specified in `pInputAssembly`

- VUID-VkGraphicsPipelineCreateInfo-pStages-00739
  If the pipeline requires pre-rasterization shader state and `pStages` includes a geometry shader stage, and also includes tessellation shader stages, its shader code must contain an `OpExecutionMode` instruction specifying an input primitive type that is compatible with the primitive topology that is output by the tessellation stages

- VUID-VkGraphicsPipelineCreateInfo-pStages-00740
  If the pipeline requires pre-rasterization shader state and fragment shader state, it includes both a fragment shader and a geometry shader, and the fragment shader code reads from an input variable that is decorated with `PrimitiveId`, then the geometry shader code must write to a matching output variable, decorated with `PrimitiveId`, in all execution paths

- VUID-VkGraphicsPipelineCreateInfo-PrimitiveId-06264
  If the pipeline requires pre-rasterization shader state, it includes a mesh shader and the fragment shader code reads from an input variable that is decorated with `PrimitiveId`, then the mesh shader code must write to a matching output variable, decorated with `PrimitiveId`, in all execution paths

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06038
  If `renderPass` is not VK_NULL_HANDLE and the pipeline is being created with fragment shader state the fragment shader must not read from any input attachment that is defined as `VK_ATTACHMENT_UNUSED` in `subpass`

- VUID-VkGraphicsPipelineCreateInfo-pStages-00742
  If the pipeline requires pre-rasterization shader state and multiple pre-rasterization shader stages are included in `pStages`, the shader code for the entry points identified by those `pStages` and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter

- VUID-VkGraphicsPipelineCreateInfo-None-04889
  If the pipeline requires pre-rasterization shader state and fragment shader state, the fragment shader and last pre-rasterization shader stage and any relevant state must adhere to the pipeline linking rules described in the Shader Interfaces chapter

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06041
  If `renderPass` is not VK_NULL_HANDLE, and the pipeline is being created with fragment output interface state, then for each color attachment in the subpass, if the potential format features of the format of the corresponding attachment description do not contain `VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`, then the `blendEnable` member of the corresponding element of the `pAttachments` member of `pColorBlendState` must be `VK_FALSE`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-07609
  If `renderPass` is not VK_NULL_HANDLE, the pipeline is being created with fragment output interface state, the `pColorBlendState` pointer is not `NULL`, the `attachmentCount` member of `pColorBlendState` is not ignored, and the subpass uses color attachments, the `attachmentCount` member of `pColorBlendState` must be equal to the `colorAttachmentCount` used to create `subpass`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04130
  If the pipeline requires pre-rasterization shader state, and `pViewportState->pViewports` is not dynamic, then `pViewportState->pViewports` must be a valid pointer to an array of `pViewportState->viewportCount` valid `VkViewport` structures

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04131
  If the pipeline requires pre-rasterization shader state, and `pViewportState->pScissors` is not dynamic, then `pViewportState->pScissors` must be a valid pointer to an array of `pViewportState->scissorCount` `VkRect2D` structures

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749
  If the pipeline requires pre-rasterization shader state, and the `wideLines` feature is not enabled, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_LINE_WIDTH`, the `lineWidth` member of `pRasterizationState` must be `1.0`

- VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-09024
  If the pipeline requires pre-rasterization shader state, and the `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE` dynamic state is enabled or the `rasterizerDiscardEnable` member of `pRasterizationState` is `VK_FALSE`, and related dynamic state is not set, `pViewportState` must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pViewportState-09025
  If `pViewportState` is not `NULL` it must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pMultisampleState-09026
  If the pipeline requires fragment output interface state, and the `VK_EXT_extended_dynamic_state3` extension is not enabled or any of the `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT`, `VK_DYNAMIC_STATE_SAMPLE_MASK_EXT`, or `VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT` dynamic states is not set, or the alphaToOne feature is enabled and `VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT` is not set, `pMultisampleState` must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pMultisampleState-09027
  If `pMultisampleState` is not `NULL` it must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-alphaToCoverageEnable-08891
  If the pipeline is being created with fragment shader state, the VkPipelineMultisampleStateCreateInfo::`alphaToCoverageEnable` is not ignored and is `VK_TRUE`, then the Fragment Output Interface must contain a variable for the alpha `Component` word in `Location` 0 at `Index` 0

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09028
  If `renderPass` is not VK_NULL_HANDLE, the pipeline is being created with fragment shader state, and `subpass` uses a depth/stencil attachment, and related dynamic state is not set, `pDepthStencilState` must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pDepthStencilState-09029
  If `pDepthStencilState` is not `NULL` it must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09030
  If `renderPass` is not VK_NULL_HANDLE, the pipeline is being created with fragment output interface state, and `subpass` uses color attachments, and related dynamic state is not set, `pColorBlendState` must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754
  If the pipeline requires pre-rasterization shader state, the `depthBiasClamp` feature is not enabled, no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_DEPTH_BIAS`, and the `depthBiasEnable` member of `pRasterizationState` is `VK_TRUE`, the `depthBiasClamp` member of `pRasterizationState` must be `0.0`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-02510
  If the pipeline requires fragment shader state, the `VK_EXT_depth_range_unrestricted` extension is not enabled and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_DEPTH_BOUNDS`, and the `depthBoundsTestEnable` member of `pDepthStencilState` is `VK_TRUE`, the `minDepthBounds` and `maxDepthBounds` members of `pDepthStencilState` must be between `0.0` and `1.0`, inclusive

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07610
  If the pipeline requires fragment shader state or fragment output interface state, and `rasterizationSamples` and `sampleLocationsInfo` are not dynamic, and VkPipelineSampleLocationsStateCreateInfoEXT::`sampleLocationsEnable` included in the `pNext` chain of `pMultisampleState` is `VK_TRUE`, `sampleLocationsInfo.sampleLocationGridSize.width` must evenly divide VkMultisamplePropertiesEXT::`sampleLocationGridSize.width` as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a `samples` parameter equaling `rasterizationSamples`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07611
  If the pipeline requires fragment shader state or fragment output interface state, and `rasterizationSamples` and `sampleLocationsInfo` are not dynamic, and VkPipelineSampleLocationsStateCreateInfoEXT::`sampleLocationsEnable` the included in the `pNext` chain of `pMultisampleState` is `VK_TRUE` or `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT` is used, `sampleLocationsInfo.sampleLocationGridSize.height` must evenly divide VkMultisamplePropertiesEXT::`sampleLocationGridSize.height` as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a `samples` parameter equaling `rasterizationSamples`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07612
  If the pipeline requires fragment shader state or fragment output interface state, and `rasterizationSamples` and `sampleLocationsInfo` are not dynamic, and VkPipelineSampleLocationsStateCreateInfoEXT::`sampleLocationsEnable` included in the `pNext` chain of `pMultisampleState` is `VK_TRUE` or `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT` is used, `sampleLocationsInfo.sampleLocationsPerPixel` must equal `rasterizationSamples`

- VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524
  If the pipeline requires fragment shader state, and the `sampleLocationsEnable` member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the `pNext` chain of `pMultisampleState` is `VK_TRUE`, the fragment shader code must not statically use the extended instruction `InterpolateAtSample`

- VUID-VkGraphicsPipelineCreateInfo-multisampledRenderToSingleSampled-06853
  If the pipeline requires fragment output interface state, and none of the `VK_AMD_mixed_attachment_samples` extension, the `VK_NV_framebuffer_mixed_samples` extension, or the `multisampledRenderToSingleSampled` feature are enabled, `rasterizationSamples` is not dynamic, and if `subpass` uses color and/or depth/stencil attachments, then the `rasterizationSamples` member of `pMultisampleState` must be the same as the sample count for those subpass attachments

- VUID-VkGraphicsPipelineCreateInfo-subpass-01505
  If the pipeline requires fragment output interface state, and the `VK_AMD_mixed_attachment_samples` extension is enabled, `rasterizationSamples` is not dynamic, and if `subpass` uses color and/or depth/stencil attachments, then the `rasterizationSamples` member of `pMultisampleState` must equal the maximum of the sample counts of those subpass attachments

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06854
  If `renderPass` is not VK_NULL_HANDLE, the `VK_EXT_multisampled_render_to_single_sampled` extension is enabled, `rasterizationSamples` is not dynamic, and `subpass` has a VkMultisampledRenderToSingleSampledInfoEXT structure included in the VkSubpassDescription2::`pNext` chain with `multisampledRenderToSingleSampledEnable` equal to `VK_TRUE`, then the `rasterizationSamples` member of `pMultisampleState` must be equal to VkMultisampledRenderToSingleSampledInfoEXT::`rasterizationSamples`

- VUID-VkGraphicsPipelineCreateInfo-subpass-01411
  If the pipeline requires fragment output interface state, the `VK_NV_framebuffer_mixed_samples` extension is enabled, `rasterizationSamples` is not dynamic, and if `subpass` has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled, then the `rasterizationSamples` member of `pMultisampleState` must be the same as the sample count of the depth/stencil attachment

- VUID-VkGraphicsPipelineCreateInfo-subpass-01412
  If the pipeline requires fragment output interface state, the `VK_NV_framebuffer_mixed_samples` extension is enabled, `rasterizationSamples` is not dynamic, and if `subpass` has any color attachments, then the `rasterizationSamples` member of `pMultisampleState` must be greater than or equal to the sample count for those subpass attachments

- VUID-VkGraphicsPipelineCreateInfo-coverageReductionMode-02722
  If the pipeline requires fragment output interface state, the `VK_NV_coverage_reduction_mode` extension is enabled, and `rasterizationSamples` is not dynamic, the coverage reduction mode specified by VkPipelineCoverageReductionStateCreateInfoNV::`coverageReductionMode`, the `rasterizationSamples` member of `pMultisampleState` and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV`

- VUID-VkGraphicsPipelineCreateInfo-subpass-00758
  If the pipeline requires fragment output interface state, `rasterizationSamples` is not dynamic, and `subpass` does not use any color and/or depth/stencil attachments, then the `rasterizationSamples` member of `pMultisampleState` must follow the rules for a zero-attachment subpass

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06046
  If `renderPass` is not VK_NULL_HANDLE, `subpass` must be a valid subpass within `renderPass`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06047
  If `renderPass` is not VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, `subpass` viewMask is not `0`, and `multiviewTessellationShader` is not enabled, then `pStages` must not include tessellation shaders

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06048
  If `renderPass` is not VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, `subpass` viewMask is not `0`, and `multiviewGeometryShader` is not enabled, then `pStages` must not include a geometry shader

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06050
  If `renderPass` is not VK_NULL_HANDLE and the pipeline is being created with pre-rasterization shader state, and `subpass` viewMask is not `0`, then all of the shaders in the pipeline must not include variables decorated with the `Layer` built-in decoration in their interfaces

- VUID-VkGraphicsPipelineCreateInfo-renderPass-07064
  If `renderPass` is not VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, `subpass` viewMask is not `0`, and `multiviewMeshShader` is not enabled, then `pStages` must not include a mesh shader

- VUID-VkGraphicsPipelineCreateInfo-flags-00764
  `flags` must not contain the `VK_PIPELINE_CREATE_DISPATCH_BASE` flag

- VUID-VkGraphicsPipelineCreateInfo-pStages-01565
  If the pipeline requires fragment shader state and an input attachment was referenced by an `aspectMask` at `renderPass` creation time, the fragment shader must only read from the aspects that were specified for that input attachment

- VUID-VkGraphicsPipelineCreateInfo-layout-01688
  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`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715
  If the pipeline requires pre-rasterization shader state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV`, and the `viewportWScalingEnable` member of a VkPipelineViewportWScalingStateCreateInfoNV structure, included in the `pNext` chain of `pViewportState`, is `VK_TRUE`, the `pViewportWScalings` member of the VkPipelineViewportWScalingStateCreateInfoNV must be a pointer to an array of VkPipelineViewportWScalingStateCreateInfoNV::`viewportCount` valid VkViewportWScalingNV structures

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04056
  If the pipeline requires pre-rasterization shader state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV`, and if `pViewportState->pNext` chain includes a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure, and if its `exclusiveScissorCount` member is not `0`, then its `pExclusiveScissors` member must be a valid pointer to an array of `exclusiveScissorCount` VkRect2D structures

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07854
  If `VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV` is included in the `pDynamicStates` array then the implementation must support at least `specVersion` `2` of the `VK_NV_scissor_exclusive` extension

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04057
  If the pipeline requires pre-rasterization shader state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV`, and if `pViewportState->pNext` chain includes a VkPipelineViewportShadingRateImageStateCreateInfoNV structure, then its `pShadingRatePalettes` member must be a valid pointer to an array of `viewportCount` valid VkShadingRatePaletteNV structures

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04058
  If the pipeline requires pre-rasterization shader state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT`, and if `pNext` chain includes a VkPipelineDiscardRectangleStateCreateInfoEXT structure, and if its `discardRectangleCount` member is not `0`, then its `pDiscardRectangles` member must be a valid pointer to an array of `discardRectangleCount` VkRect2D structures

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07855
  If `VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT` is included in the `pDynamicStates` array then the implementation must support at least `specVersion` `2` of the `VK_EXT_discard_rectangles` extension

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07856
  If `VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT` is included in the `pDynamicStates` array then the implementation must support at least `specVersion` `2` of the `VK_EXT_discard_rectangles` extension

- VUID-VkGraphicsPipelineCreateInfo-pStages-02097
  If the pipeline requires vertex input state, and `pVertexInputState` is not dynamic, then `pVertexInputState` must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-Input-07904
  If `vertexAttributeRobustness` is not enabled and the pipeline is being created with vertex input state and `pVertexInputState` is not dynamic, then all variables with the `Input` storage class decorated with `Location` in the `Vertex` `Execution` `Model` `OpEntryPoint` must contain a location in VkVertexInputAttributeDescription::`location`

- VUID-VkGraphicsPipelineCreateInfo-Input-08733
  If the pipeline requires vertex input state and `pVertexInputState` is not dynamic, then the numeric type associated with all `Input` variables of the corresponding `Location` in the `Vertex` `Execution` `Model` `OpEntryPoint` must be the same as VkVertexInputAttributeDescription::`format`

- VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-08929
  If the pipeline is being created with vertex input state and `pVertexInputState` is not dynamic, and VkVertexInputAttributeDescription::`format` has a 64-bit component, then the scalar width associated with all `Input` variables of the corresponding `Location` in the `Vertex` `Execution` `Model` `OpEntryPoint` must be 64-bit

- VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-08930
  If the pipeline is being created with vertex input state and `pVertexInputState` is not dynamic, and the scalar width associated with a `Location` decorated `Input` variable in the `Vertex` `Execution` `Model` `OpEntryPoint` is 64-bit, then the corresponding VkVertexInputAttributeDescription::`format` must have a 64-bit component

- VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-09198
  If the pipeline is being created with vertex input state and `pVertexInputState` is not dynamic, and VkVertexInputAttributeDescription::`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

- VUID-VkGraphicsPipelineCreateInfo-dynamicPrimitiveTopologyUnrestricted-09031
  If the pipeline requires vertex input state, and related dynamic state is not set, `pInputAssemblyState` must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-09032
  If `pInputAssemblyState` is not `NULL` it must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pStages-02317
  If the pipeline requires pre-rasterization shader state, the `Xfb` execution mode can be specified by no more than one shader stage in `pStages`

- VUID-VkGraphicsPipelineCreateInfo-pStages-02318
  If the pipeline requires pre-rasterization shader state, and any shader stage in `pStages` specifies `Xfb` execution mode it must be the last pre-rasterization shader stage

- VUID-VkGraphicsPipelineCreateInfo-rasterizationStream-02319
  If the pipeline requires pre-rasterization shader state, and a VkPipelineRasterizationStateStreamCreateInfoEXT::`rasterizationStream` value other than zero is specified, all variables in the output interface of the entry point being compiled decorated with `Position`, `PointSize`, `ClipDistance`, or `CullDistance` must be decorated with identical `Stream` values that match the `rasterizationStream`

- VUID-VkGraphicsPipelineCreateInfo-rasterizationStream-02320
  If the pipeline requires pre-rasterization shader state, and VkPipelineRasterizationStateStreamCreateInfoEXT::`rasterizationStream` is zero, or not specified, all variables in the output interface of the entry point being compiled decorated with `Position`, `PointSize`, `ClipDistance`, or `CullDistance` must be decorated with a `Stream` value of zero, or must not specify the `Stream` decoration

- VUID-VkGraphicsPipelineCreateInfo-geometryStreams-02321
  If the pipeline requires pre-rasterization shader state, and the last pre-rasterization shader stage is a geometry shader, and that geometry shader uses the `GeometryStreams` capability, then `VkPhysicalDeviceTransformFeedbackFeaturesEXT`::`geometryStreams` feature must be enabled

- VUID-VkGraphicsPipelineCreateInfo-None-02322
  If the pipeline requires pre-rasterization shader state, and there are any mesh shader stages in the pipeline there must not be any shader stage in the pipeline with a `Xfb` execution mode

- VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766
  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`

- VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767
  If the pipeline requires pre-rasterization shader state, the `stippledLineEnable` member of VkPipelineRasterizationLineStateCreateInfo is `VK_TRUE`, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_LINE_STIPPLE`, then the `lineStippleFactor` member of VkPipelineRasterizationLineStateCreateInfo must be in the range [1,256]

- VUID-VkGraphicsPipelineCreateInfo-shaderMeshEnqueue-10187
  If the `shaderMeshEnqueue` feature is not enabled, shaders specified by `pStages` must not declare the `ShaderEnqueueAMDX` capability

- VUID-VkGraphicsPipelineCreateInfo-flags-10188
  If `flags` does not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`, shaders specified by `pStages` must not declare the `ShaderEnqueueAMDX` capability

- VUID-VkGraphicsPipelineCreateInfo-pStages-10189
  If any shader stages in `pStages` declare the `ShaderEnqueueAMDX` capability, `VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX` and `VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR` must be included in `flags`

- VUID-VkGraphicsPipelineCreateInfo-flags-10190
  If `VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX` is included in `flags`, and the pipeline requires pre-rasterization shader state, there must not be a task or vertex shader specified in `pStages`

- VUID-VkGraphicsPipelineCreateInfo-flags-10191
  If `VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX` is included in `flags`, all elements of VkPipelineLibraryCreateInfoKHR::`pLibraries` must have been created with `VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX`

- VUID-VkGraphicsPipelineCreateInfo-flags-03372
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-03373
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-03374
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-03375
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-03376
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-03377
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-03577
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-04947
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-03378
  If the `extendedDynamicState` feature is not enabled, and the minimum value of VkApplicationInfo::`apiVersion` used to create the VkInstance and `apiVersion` supported by the physical device is less than Version 1.3 there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_CULL_MODE`, `VK_DYNAMIC_STATE_FRONT_FACE`, `VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY`, `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT`, `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT`, `VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE`, `VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE`, `VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE`, `VK_DYNAMIC_STATE_DEPTH_COMPARE_OP`, `VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE`, `VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE`, or `VK_DYNAMIC_STATE_STENCIL_OP`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-03379
  If the pipeline requires pre-rasterization shader state, and `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT` is included in the `pDynamicStates` array then `viewportCount` must be zero

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-03380
  If the pipeline requires pre-rasterization shader state, and `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT` is included in the `pDynamicStates` array then `scissorCount` must be zero

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04132
  If the pipeline requires pre-rasterization shader state, and `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT` is included in the `pDynamicStates` array then `VK_DYNAMIC_STATE_VIEWPORT` must not be present

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04133
  If the pipeline requires pre-rasterization shader state, and `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT` is included in the `pDynamicStates` array then `VK_DYNAMIC_STATE_SCISSOR` must not be present

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07065
  If the pipeline requires pre-rasterization shader state, and includes a mesh shader, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY`, or `VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04868
  If the `extendedDynamicState2` feature is not enabled, and the minimum value of VkApplicationInfo::`apiVersion` used to create the VkInstance and `apiVersion` supported by the physical device is less than Version 1.3 there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE`, `VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE`, or `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04869
  If the `extendedDynamicState2LogicOp` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_LOGIC_OP_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04870
  If the `extendedDynamicState2PatchControlPoints` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07066
  If the pipeline requires pre-rasterization shader state, and includes a mesh shader, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE`, or `VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT`

- VUID-VkGraphicsPipelineCreateInfo-flags-02877
  If `flags` includes `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV`, then the `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV`::`deviceGeneratedCommands` feature must be enabled

- VUID-VkGraphicsPipelineCreateInfo-flags-02966
  If the pipeline requires pre-rasterization shader state and `flags` includes `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV`, then all stages must not specify `Xfb` execution mode

- VUID-VkGraphicsPipelineCreateInfo-libraryCount-06648
  If the pipeline is not created with a complete set of state, or VkPipelineLibraryCreateInfoKHR::`libraryCount` is not `0`, VkGraphicsPipelineShaderGroupsCreateInfoNV::`groupCount` and VkGraphicsPipelineShaderGroupsCreateInfoNV::`pipelineCount` must be `0`

- VUID-VkGraphicsPipelineCreateInfo-libraryCount-06649
  If the pipeline is created with a complete set of state, and VkPipelineLibraryCreateInfoKHR::`libraryCount` is `0`, and the `pNext` chain includes an instance of VkGraphicsPipelineShaderGroupsCreateInfoNV, VkGraphicsPipelineShaderGroupsCreateInfoNV::`groupCount` must be greater than `0`

- VUID-VkGraphicsPipelineCreateInfo-flags-11000
  If `flags` includes `VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT`, then the `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT`::`deviceGeneratedCommands` feature must be enabled

- VUID-VkGraphicsPipelineCreateInfo-flags-11001
  If the pipeline requires pre-rasterization shader state and `flags` includes `VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT`, then all stages must not specify `Xfb` execution mode

- VUID-VkGraphicsPipelineCreateInfo-pipelineCreationCacheControl-02878
  If the `pipelineCreationCacheControl` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` or `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT`

- VUID-VkGraphicsPipelineCreateInfo-pipelineProtectedAccess-07368
  If the `pipelineProtectedAccess` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT` or `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT`

- VUID-VkGraphicsPipelineCreateInfo-flags-07369
  `flags` must not include both `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT` and `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04494
  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`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04495
  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.height` must be greater than or equal to `1`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04496
  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 a power-of-two value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04497
  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.height` must be a power-of-two value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04498
  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 less than or equal to `4`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04499
  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.height` must be less than or equal to `4`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04500
  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`, and the `pipelineFragmentShadingRate` feature is not enabled, VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.width` and VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.height` must both be equal to `1`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-06567
  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::`combinerOps`[0] must be a valid VkFragmentShadingRateCombinerOpKHR value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-06568
  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::`combinerOps`[1] must be a valid VkFragmentShadingRateCombinerOpKHR value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04501
  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`, and the `primitiveFragmentShadingRate` feature is not enabled, VkPipelineFragmentShadingRateStateCreateInfoKHR::`combinerOps`[0] must be `VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04502
  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`, and the `attachmentFragmentShadingRate` feature is not enabled, VkPipelineFragmentShadingRateStateCreateInfoKHR::`combinerOps`[1] must be `VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR`

- VUID-VkGraphicsPipelineCreateInfo-primitiveFragmentShadingRateWithMultipleViewports-04503
  If the pipeline requires pre-rasterization shader state and the `primitiveFragmentShadingRateWithMultipleViewports` limit is not supported, `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT` is not included in `pDynamicState->pDynamicStates`, and VkPipelineViewportStateCreateInfo::`viewportCount` is greater than `1`, entry points specified in `pStages` must not write to the `PrimitiveShadingRateKHR` built-in

- VUID-VkGraphicsPipelineCreateInfo-primitiveFragmentShadingRateWithMultipleViewports-04504
  If the pipeline requires pre-rasterization shader state and the `primitiveFragmentShadingRateWithMultipleViewports` limit is not supported, and entry points specified in `pStages` write to the `ViewportIndex` built-in, they must not also write to the `PrimitiveShadingRateKHR` built-in

- VUID-VkGraphicsPipelineCreateInfo-primitiveFragmentShadingRateWithMultipleViewports-04505
  If the pipeline requires pre-rasterization shader state and the `primitiveFragmentShadingRateWithMultipleViewports` limit is not supported, and entry points specified in `pStages` write to the `ViewportMaskNV` built-in, they must not also write to the `PrimitiveShadingRateKHR` built-in

- VUID-VkGraphicsPipelineCreateInfo-fragmentShadingRateNonTrivialCombinerOps-04506
  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`

- VUID-VkGraphicsPipelineCreateInfo-None-06569
  If the pipeline requires fragment shader state and `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`shadingRateType` must be a valid VkFragmentShadingRateTypeNV value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-06570
  If the pipeline requires fragment shader state and `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`shadingRate` must be a valid VkFragmentShadingRateNV value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-06571
  If the pipeline requires fragment shader state and `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`combinerOps`[0] must be a valid VkFragmentShadingRateCombinerOpKHR value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-06572
  If the pipeline requires fragment shader state and `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`combinerOps`[1] must be a valid VkFragmentShadingRateCombinerOpKHR value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04569
  If the pipeline requires fragment shader state and `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` is not included in `pDynamicState->pDynamicStates`, and the `fragmentShadingRateEnums` feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`shadingRateType` must be equal to `VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04570
  If the pipeline requires fragment shader state and `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` is not included in `pDynamicState->pDynamicStates`, and the `pipelineFragmentShadingRate` feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`shadingRate` must be equal to `VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04571
  If the pipeline requires fragment shader state and `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` is not included in `pDynamicState->pDynamicStates`, and the `primitiveFragmentShadingRate` feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`combinerOps`[0] must be `VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04572
  If the pipeline requires fragment shader state and `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` is not included in `pDynamicState->pDynamicStates`, and the `attachmentFragmentShadingRate` feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`combinerOps`[1] must be `VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR`

- VUID-VkGraphicsPipelineCreateInfo-fragmentShadingRateNonTrivialCombinerOps-04573
  If the pipeline requires fragment shader state, and the `fragmentShadingRateNonTrivialCombinerOps` limit is not supported and `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` is not included in `pDynamicState->pDynamicStates`, elements of VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`combinerOps` must be `VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR` or `VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR`

- VUID-VkGraphicsPipelineCreateInfo-None-04574
  If the pipeline requires fragment shader state, and the `supersampleFragmentShadingRates` feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`shadingRate` must not be equal to `VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV`, `VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV`, `VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV`, or `VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV`

- VUID-VkGraphicsPipelineCreateInfo-None-04575
  If the pipeline requires fragment shader state, and the `noInvocationFragmentShadingRates` feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::`shadingRate` must not be equal to `VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-03578
  All elements of the `pDynamicStates` member of `pDynamicState` must not be `VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04807
  If the pipeline requires pre-rasterization shader state and the `vertexInputDynamicState` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_VERTEX_INPUT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07067
  If the pipeline requires pre-rasterization shader state, and includes a mesh shader, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_VERTEX_INPUT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04800
  If the `colorWriteEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-rasterizationSamples-04899
  If the pipeline requires fragment shader state, and the `VK_QCOM_render_pass_shader_resolve` extension is enabled, `rasterizationSamples` is not dynamic, and if subpass has any input attachments, and if the subpass description contains `VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM`, then the sample count of the input attachments must equal `rasterizationSamples`

- VUID-VkGraphicsPipelineCreateInfo-sampleShadingEnable-04900
  If the pipeline requires fragment shader state, and the `VK_QCOM_render_pass_shader_resolve` extension is enabled, and if the subpass description contains `VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM`, then `sampleShadingEnable` must be false

- VUID-VkGraphicsPipelineCreateInfo-flags-04901
  If `flags` includes `VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM`, then the subpass must be the last subpass in a subpass dependency chain

- VUID-VkGraphicsPipelineCreateInfo-flags-04902
  If `flags` includes `VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM`, and if `pResolveAttachments` is not `NULL`, then each resolve attachment must be `VK_ATTACHMENT_UNUSED`

- VUID-VkGraphicsPipelineCreateInfo-dynamicRendering-06576
  If the `dynamicRendering` feature is not enabled and the pipeline requires pre-rasterization shader state, fragment shader state, or fragment output interface state, `renderPass` must not be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-multiview-06577
  If the `multiview` feature is not enabled, the pipeline requires pre-rasterization shader state, fragment shader state, or fragment output interface state, and `renderPass` is VK_NULL_HANDLE, VkPipelineRenderingCreateInfo::`viewMask` must be `0`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06578
  If the pipeline requires pre-rasterization shader state, fragment shader state, or fragment output interface state, and `renderPass` is VK_NULL_HANDLE, the index of the most significant bit in VkPipelineRenderingCreateInfo::`viewMask` must be less than `maxMultiviewViewCount`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06579
  If the pipeline requires fragment output interface state, and `renderPass` is VK_NULL_HANDLE, and VkPipelineRenderingCreateInfo::`colorAttachmentCount` is not 0, VkPipelineRenderingCreateInfo::`pColorAttachmentFormats` must be a valid pointer to an array of `colorAttachmentCount` valid VkFormat values

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06580
  If the pipeline requires fragment output interface state, and `renderPass` is VK_NULL_HANDLE, each element of VkPipelineRenderingCreateInfo::`pColorAttachmentFormats` must be a valid VkFormat value

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06582
  If the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and any element of VkPipelineRenderingCreateInfo::`pColorAttachmentFormats` is not `VK_FORMAT_UNDEFINED`, that format must be a format with potential format features that include `VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT` or `VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06583
  If the pipeline requires fragment output interface state, and `renderPass` is VK_NULL_HANDLE, VkPipelineRenderingCreateInfo::`depthAttachmentFormat` must be a valid VkFormat value

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06584
  If the pipeline requires fragment output interface state, and `renderPass` is VK_NULL_HANDLE, VkPipelineRenderingCreateInfo::`stencilAttachmentFormat` must be a valid VkFormat value

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06585
  If the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkPipelineRenderingCreateInfo::`depthAttachmentFormat` is not `VK_FORMAT_UNDEFINED`, it must be a format with potential format features that include `VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06586
  If the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkPipelineRenderingCreateInfo::`stencilAttachmentFormat` is not `VK_FORMAT_UNDEFINED`, it must be a format with potential format features that include `VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06587
  If the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkPipelineRenderingCreateInfo::`depthAttachmentFormat` is not `VK_FORMAT_UNDEFINED`, it must be a format that includes a depth component

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06588
  If the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkPipelineRenderingCreateInfo::`stencilAttachmentFormat` is not `VK_FORMAT_UNDEFINED`, it must be a format that includes a stencil component

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06589
  If the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, VkPipelineRenderingCreateInfo::`depthAttachmentFormat` is not `VK_FORMAT_UNDEFINED`, and VkPipelineRenderingCreateInfo::`stencilAttachmentFormat` is not `VK_FORMAT_UNDEFINED`, `depthAttachmentFormat` must equal `stencilAttachmentFormat`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09033
  If `renderPass` is VK_NULL_HANDLE, the pipeline is being created with fragment shader state and fragment output interface state, and either of VkPipelineRenderingCreateInfo::`depthAttachmentFormat` or VkPipelineRenderingCreateInfo::`stencilAttachmentFormat` are not `VK_FORMAT_UNDEFINED`, and the `VK_EXT_extended_dynamic_state3` extension is not enabled or any of the `VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE`, `VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE`, `VK_DYNAMIC_STATE_DEPTH_COMPARE_OP`, `VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE`, `VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE`, `VK_DYNAMIC_STATE_STENCIL_OP`, or `VK_DYNAMIC_STATE_DEPTH_BOUNDS` dynamic states are not set, `pDepthStencilState` must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pDepthStencilState-09034
  If `pDepthStencilState` is not `NULL` it must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09035
  If `renderPass` is VK_NULL_HANDLE and the pipeline is being created with fragment shader state but not fragment output interface state, and the `VK_EXT_extended_dynamic_state3` extension is not enabled, or any of the `VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE`, `VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE`, `VK_DYNAMIC_STATE_DEPTH_COMPARE_OP`, `VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE`, `VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE`, `VK_DYNAMIC_STATE_STENCIL_OP`, or `VK_DYNAMIC_STATE_DEPTH_BOUNDS` dynamic states are not set, `pDepthStencilState` must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pDepthStencilState-09036
  If `pDepthStencilState` is not `NULL` it must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09037
  If `renderPass` is VK_NULL_HANDLE, the pipeline is being created with fragment output interface state, and any element of VkPipelineRenderingCreateInfo::`pColorAttachmentFormats` is not `VK_FORMAT_UNDEFINED`, and the `VK_EXT_extended_dynamic_state3` extension is not enabled, or any of the `VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT`, `VK_DYNAMIC_STATE_LOGIC_OP_EXT`, `VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT`, `VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT`, `VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT`, or `VK_DYNAMIC_STATE_BLEND_CONSTANTS` dynamic states are not set, `pColorBlendState` must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pColorBlendState-09038
  If `pColorBlendState` is not `NULL` it must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06055
  If `renderPass` is VK_NULL_HANDLE, `pColorBlendState` is not dynamic, and the pipeline is being created with fragment output interface state, `pColorBlendState->attachmentCount` must be equal to VkPipelineRenderingCreateInfo::`colorAttachmentCount`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06057
  If `renderPass` is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, VkPipelineRenderingCreateInfo::`viewMask` is not `0`, and the `multiviewTessellationShader` feature is not enabled, then `pStages` must not include tessellation shaders

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06058
  If `renderPass` is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, VkPipelineRenderingCreateInfo::`viewMask` is not `0`, and the `multiviewGeometryShader` feature is not enabled, then `pStages` must not include a geometry shader

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06059
  If `renderPass` is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, and VkPipelineRenderingCreateInfo::`viewMask` is not `0`, all of the shaders in the pipeline must not include variables decorated with the `Layer` built-in decoration in their interfaces

- VUID-VkGraphicsPipelineCreateInfo-renderPass-07720
  If `renderPass` is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, and VkPipelineRenderingCreateInfo::`viewMask` is not `0`, and `multiviewMeshShader` is not enabled, then `pStages` must not include a mesh shader

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06061
  If the `dynamicRenderingLocalRead` feature is not enabled, the pipeline requires fragment shader state, and `renderPass` is VK_NULL_HANDLE, fragment shaders in `pStages` must not include the `InputAttachment` capability

- VUID-VkGraphicsPipelineCreateInfo-renderPass-08710
  If the pipeline requires fragment shader state and `renderPass` is not VK_NULL_HANDLE, fragment shaders in `pStages` must not include any of the `TileImageColorReadAccessEXT`, `TileImageDepthReadAccessEXT`, or `TileImageStencilReadAccessEXT` capabilities

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06062
  If the pipeline requires fragment output interface state and `renderPass` is VK_NULL_HANDLE, for each color attachment format defined by the `pColorAttachmentFormats` member of VkPipelineRenderingCreateInfo, if its potential format features do not contain `VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT`, then the `blendEnable` member of the corresponding element of the `pAttachments` member of `pColorBlendState` must be `VK_FALSE`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06063
  If the pipeline requires fragment output interface state and `renderPass` is VK_NULL_HANDLE, if the `pNext` chain includes VkAttachmentSampleCountInfoAMD or `VkAttachmentSampleCountInfoNV`, the `colorAttachmentCount` member of that structure must be equal to the value of VkPipelineRenderingCreateInfo::`colorAttachmentCount`

- VUID-VkGraphicsPipelineCreateInfo-flags-06591
  If `pStages` includes a fragment shader stage, and the fragment shader declares the `EarlyFragmentTests` execution mode, the `flags` member of VkPipelineDepthStencilStateCreateInfo must not include `VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT` or `VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-flags-06482
  If the `dynamicRenderingLocalRead` feature is not enabled, the pipeline requires fragment output interface state, and the `flags` member of VkPipelineColorBlendStateCreateInfo includes `VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT`, `renderPass` must not be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-None-09526
  If the `dynamicRenderingLocalRead` feature is not enabled, the pipeline requires fragment output interface state, and the `flags` member of VkPipelineDepthStencilStateCreateInfo includes `VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT` or `VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT`, `renderPass` must not be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-pColorAttachmentSamples-06592
  If the fragment output interface state, elements of the `pColorAttachmentSamples` member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV must be valid VkSampleCountFlagBits values

- VUID-VkGraphicsPipelineCreateInfo-depthStencilAttachmentSamples-06593
  If the fragment output interface state and the `depthStencilAttachmentSamples` member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV is not 0, it must be a valid VkSampleCountFlagBits value

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09527
  If the pipeline requires fragment output interface state, `renderPass` is not VK_NULL_HANDLE, and the `flags` member of VkPipelineColorBlendStateCreateInfo includes `VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT` `subpass` must have been created with `VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09528
  If the pipeline requires fragment shader state, `renderPass` is not VK_NULL_HANDLE, and the `flags` member of VkPipelineDepthStencilStateCreateInfo includes `VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT`, `subpass` must have been created with `VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09529
  If the pipeline requires fragment shader state, `renderPass` is not VK_NULL_HANDLE, and the `flags` member of VkPipelineDepthStencilStateCreateInfo includes `VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT`, `subpass` must have been created with `VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pipelineStageCreationFeedbackCount-06594
  If VkPipelineCreationFeedbackCreateInfo::`pipelineStageCreationFeedbackCount` is not `0`, it must be equal to `stageCount`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06595
  If `renderPass` is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state or fragment shader state, and VkMultiviewPerViewAttributesInfoNVX::`perViewAttributesPositionXOnly` is `VK_TRUE` then VkMultiviewPerViewAttributesInfoNVX::`perViewAttributes` must also be `VK_TRUE`

- VUID-VkGraphicsPipelineCreateInfo-flags-06596
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other flag, the value of VkMultiviewPerViewAttributesInfoNVX::`perViewAttributes` specified in both this pipeline and the library must be equal

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06597
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, the value of VkMultiviewPerViewAttributesInfoNVX::`perViewAttributes` specified in both libraries must be equal

- VUID-VkGraphicsPipelineCreateInfo-flags-06598
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other flag, the value of VkMultiviewPerViewAttributesInfoNVX::`perViewAttributesPositionXOnly` specified in both this pipeline and the library must be equal

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06599
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, the value of VkMultiviewPerViewAttributesInfoNVX::`perViewAttributesPositionXOnly` specified in both libraries must be equal

- VUID-VkGraphicsPipelineCreateInfo-pStages-06600
  If the pipeline requires pre-rasterization shader state or fragment shader state, `pStages` must be a valid pointer to an array of `stageCount` valid VkPipelineShaderStageCreateInfo structures

- VUID-VkGraphicsPipelineCreateInfo-stageCount-09587
  If the pipeline does not require pre-rasterization shader state or fragment shader state, `stageCount` must be zero

- VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-06601
  If the pipeline requires pre-rasterization shader state, and related dynamic state is not set, `pRasterizationState` must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-09039
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, and related dynamic state is not set, then `pMultisampleState` must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-09040
  If `pRasterizationState` is not `NULL` it must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-layout-06602
  If the pipeline requires fragment shader state or pre-rasterization shader state, `layout` must be a valid VkPipelineLayout handle

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06603
  If the pipeline requires pre-rasterization shader state, fragment shader state, or fragment output state, and `renderPass` is not VK_NULL_HANDLE, `renderPass` must be a valid VkRenderPass handle

- VUID-VkGraphicsPipelineCreateInfo-stageCount-09530
  If the pipeline requires pre-rasterization shader state, `stageCount` must be greater than `0`

- VUID-VkGraphicsPipelineCreateInfo-graphicsPipelineLibrary-06606
  If the `graphicsPipelineLibrary` feature is not enabled, and if the `shaderMeshEnqueue` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-06608
  If the `shaderMeshEnqueue` feature is not enabled, and the pipeline is being created with all possible state subsets, `flags` must not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-06609
  If `flags` includes `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT`, pipeline libraries included via VkPipelineLibraryCreateInfoKHR must have been created with `VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-flags-09245
  If `flags` includes `VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT`, `flags` must also include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-flags-06610
  If `flags` includes `VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT`, pipeline libraries included via VkPipelineLibraryCreateInfoKHR must have been created with `VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06611
  Any pipeline libraries included via VkPipelineLibraryCreateInfoKHR::`pLibraries` must not include any state subset already defined by this structure or defined by any other pipeline library in VkPipelineLibraryCreateInfoKHR::`pLibraries`

- VUID-VkGraphicsPipelineCreateInfo-flags-06612
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other flag, and `layout` was not created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, then the `layout` used by this pipeline and the library must be identically defined

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06613
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and the `layout` specified by either library was not created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, then the `layout` used by each library must be identically defined

- VUID-VkGraphicsPipelineCreateInfo-flags-06614
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other subset, and `layout` was created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, then the `layout` used by the library must also have been created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06615
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and the `layout` specified by either library was created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, then the `layout` used by both libraries must have been created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-flags-06616
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other subset, and `layout` was created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, elements of the `pSetLayouts` array which `layout` was created with that are not VK_NULL_HANDLE must be identically defined to the element at the same index of `pSetLayouts` used to create the library’s `layout`

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06617
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and the `layout` specified by either library was created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, elements of the `pSetLayouts` array which either `layout` was created with that are not VK_NULL_HANDLE must be identically defined to the element at the same index of `pSetLayouts` used to create the other library’s `layout`

- VUID-VkGraphicsPipelineCreateInfo-flags-06618
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other flag, any descriptor set layout N specified by `layout` in both this pipeline and the library which include bindings accessed by shader stages in each must be identically defined

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06619
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, any descriptor set layout N specified by `layout` in both libraries which include bindings accessed by shader stages in each must be identically defined

- VUID-VkGraphicsPipelineCreateInfo-flags-06620
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other flag, push constants specified in `layout` in both this pipeline and the library which are available to shader stages in each must be identically defined

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06621
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, push constants specified in `layout` in both this pipeline and the library which are available to shader stages in each must be identically defined

- VUID-VkGraphicsPipelineCreateInfo-flags-06679
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other subset, any element of the `pSetLayouts` array when `layout` was created and the corresponding element of the `pSetLayouts` array used to create the library’s `layout` must not both be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06681
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and any element of the `pSetLayouts` array used to create each library’s `layout` was VK_NULL_HANDLE, then the corresponding element of the `pSetLayouts` array used to create the other library’s `layout` must not be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-flags-06756
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other subset, and any element of the `pSetLayouts` array which `layout` was created with was VK_NULL_HANDLE, then the corresponding element of the `pSetLayouts` array used to create the library’s `layout` must not have shader bindings for shaders in the other subset

- VUID-VkGraphicsPipelineCreateInfo-flags-06757
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other subset, and any element of the `pSetLayouts` array used to create the library’s `layout` was VK_NULL_HANDLE, then the corresponding element of the `pSetLayouts` array used to create this pipeline’s `layout` must not have shader bindings for shaders in the other subset

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06758
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and any element of the `pSetLayouts` array used to create each library’s `layout` was VK_NULL_HANDLE, then the corresponding element of the `pSetLayouts` array used to create the other library’s `layout` must not have shader bindings for shaders in the other subset

- VUID-VkGraphicsPipelineCreateInfo-flags-06682
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes both `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, `layout` must have been created with no elements of the `pSetLayouts` array set to VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-flags-06683
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and `pRasterizationState->rasterizerDiscardEnable` is `VK_TRUE`, `layout` must have been created with no elements of the `pSetLayouts` array set to VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-flags-06684
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes at least one of and no more than two of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes one of the other flags, the value of `subpass` must be equal to that used to create the library

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06623
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes at least one of and no more than two of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, and another element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes one of the other flags, the value of `subpass` used to create each library must be identical

- VUID-VkGraphicsPipelineCreateInfo-renderpass-06624
  If `renderpass` is not VK_NULL_HANDLE, VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes at least one of and no more than two of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes one of the other flags, `renderPass` must be compatible with that used to create the library

- VUID-VkGraphicsPipelineCreateInfo-renderpass-06625
  If `renderpass` is VK_NULL_HANDLE, VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes at least one of and no more than two of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes one of the other flags, the value of `renderPass` used to create that library must also be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-flags-06626
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes at least one of and no more than two of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes one of the other flags, and `renderPass` is VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfo::`viewMask` used by this pipeline and that specified by the library must be identical

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06627
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes at least one of and no more than two of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, another element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes one of the other flags, and `renderPass` was VK_NULL_HANDLE for both libraries, the value of VkPipelineRenderingCreateInfo::`viewMask` set by each library must be identical

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06628
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes at least one of and no more than two of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, and another element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes one of the other flags, the `renderPass` objects used to create each library must be compatible or all equal to VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-renderpass-06631
  If `renderPass` is not VK_NULL_HANDLE, the pipeline requires fragment shader state, and the `VK_EXT_extended_dynamic_state3` extension is not enabled or any of the `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT`, `VK_DYNAMIC_STATE_SAMPLE_MASK_EXT`, or `VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT` dynamic states is not set, or the alphaToOne feature is enabled and `VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT` is not set, then `pMultisampleState` must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-Input-06632
  If the pipeline requires fragment shader state with a fragment shader that either enables sample shading or decorates any variable in the `Input` storage class with `Sample`, and the `VK_EXT_extended_dynamic_state3` extension is not enabled or any of the `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT`, `VK_DYNAMIC_STATE_SAMPLE_MASK_EXT`, or `VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT` dynamic states is not set, or the alphaToOne feature is enabled and `VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT` is not set, then `pMultisampleState` must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-flags-06633
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT` with a `pMultisampleState` that was not `NULL`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` was created with `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, `pMultisampleState` must be identically defined to that used to create the library

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06634
  If an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` was created with `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT` with a `pMultisampleState` that was not `NULL`, and if VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, `pMultisampleState` must be identically defined to that used to create the library

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06635
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` was created with `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT` with a `pMultisampleState` that was not `NULL`, and if a different element of VkPipelineLibraryCreateInfoKHR::`pLibraries` was created with `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, the `pMultisampleState` used to create each library must be identically defined

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06636
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` was created with `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT` and a value of `pMultisampleState->sampleShadingEnable` equal `VK_TRUE`, and if a different element of VkPipelineLibraryCreateInfoKHR::`pLibraries` was created with `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, the `pMultisampleState` used to create each library must be identically defined

- VUID-VkGraphicsPipelineCreateInfo-flags-06637
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, `pMultisampleState->sampleShadingEnable` is `VK_TRUE`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` was created with `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, `pMultisampleState` must be identically defined to that used to create the library

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-09567
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` was created with `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT` and a value of `pMultisampleState->sampleShadingEnable` equal `VK_TRUE`, and if VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, `pMultisampleState` must be identically defined to that used to create the library

- VUID-VkGraphicsPipelineCreateInfo-flags-06638
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes only one of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes the other flag, values specified in VkPipelineFragmentShadingRateStateCreateInfoKHR for both this pipeline and that library must be identical

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06639
  If one element of VkPipelineLibraryCreateInfoKHR::`pLibraries` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` and another element includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, values specified in VkPipelineFragmentShadingRateStateCreateInfoKHR for both this pipeline and that library must be identical

- VUID-VkGraphicsPipelineCreateInfo-flags-06640
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, `pStages` must be a valid pointer to an array of `stageCount` valid VkPipelineShaderStageCreateInfo structures

- VUID-VkGraphicsPipelineCreateInfo-flags-06642
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, `layout` must be a valid VkPipelineLayout handle

- VUID-VkGraphicsPipelineCreateInfo-flags-06643
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, and `renderPass` is not VK_NULL_HANDLE, `renderPass` must be a valid VkRenderPass handle

- VUID-VkGraphicsPipelineCreateInfo-flags-06644
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` or `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, `stageCount` must be greater than `0`

- VUID-VkGraphicsPipelineCreateInfo-flags-06645
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` is non-zero, if `flags` includes `VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR`, any libraries must have also been created with `VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06646
  If VkPipelineLibraryCreateInfoKHR::`pLibraries` includes more than one library, and any library was created with `VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR`, all libraries must have also been created with `VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06647
  If VkPipelineLibraryCreateInfoKHR::`pLibraries` includes at least one library, VkGraphicsPipelineLibraryCreateInfoEXT::`flags` is non-zero, and any library was created with `VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR`, `flags` must include `VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-None-07826
  If the pipeline includes a complete set of state, and there are no libraries included in VkPipelineLibraryCreateInfoKHR::`pLibraries`, then VkPipelineLayout must be a valid pipeline layout

- VUID-VkGraphicsPipelineCreateInfo-layout-07827
  If the pipeline includes a complete set of state specified entirely by libraries, and each library was created with a VkPipelineLayout created without `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, then `layout` must be compatible with the layouts in those libraries

- VUID-VkGraphicsPipelineCreateInfo-flags-06729
  If `flags` includes `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT`, the pipeline includes a complete set of state specified entirely by libraries, and each library was created with a VkPipelineLayout created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, then `layout` must be compatible with the union of the libraries' pipeline layouts other than the inclusion/exclusion of `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-flags-06730
  If `flags` does not include `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT`, the pipeline includes a complete set of state specified entirely by libraries, and each library was created with a VkPipelineLayout created with `VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT`, then `layout` must be compatible with the union of the libraries' pipeline layouts

- VUID-VkGraphicsPipelineCreateInfo-conservativePointAndLineRasterization-08892
  If `conservativePointAndLineRasterization` is not supported; the pipeline is being created with vertex input state and pre-rasterization shader state; the pipeline does not include a geometry shader; and the value of VkPipelineInputAssemblyStateCreateInfo::`topology` is `VK_PRIMITIVE_TOPOLOGY_POINT_LIST`, `VK_PRIMITIVE_TOPOLOGY_LINE_LIST`, or `VK_PRIMITIVE_TOPOLOGY_LINE_STRIP`, and either `VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY` dynamic state is not enabled or `dynamicPrimitiveTopologyUnrestricted` is `VK_FALSE`, then VkPipelineRasterizationConservativeStateCreateInfoEXT::`conservativeRasterizationMode` must be `VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT`

- VUID-VkGraphicsPipelineCreateInfo-conservativePointAndLineRasterization-06760
  If `conservativePointAndLineRasterization` is not supported, the pipeline requires pre-rasterization shader state, and the pipeline includes a geometry shader with either the `OutputPoints` or `OutputLineStrip` execution modes, VkPipelineRasterizationConservativeStateCreateInfoEXT::`conservativeRasterizationMode` must be `VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT`

- VUID-VkGraphicsPipelineCreateInfo-conservativePointAndLineRasterization-06761
  If `conservativePointAndLineRasterization` is not supported, the pipeline requires pre-rasterization shader state, and the pipeline includes a mesh shader with either the `OutputPoints` or `OutputLinesNV` execution modes, VkPipelineRasterizationConservativeStateCreateInfoEXT::`conservativeRasterizationMode` must be `VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pStages-06894
  If the pipeline requires pre-rasterization shader state but not fragment shader state, elements of `pStages` must not have `stage` set to `VK_SHADER_STAGE_FRAGMENT_BIT`

- VUID-VkGraphicsPipelineCreateInfo-pStages-06895
  If the pipeline requires fragment shader state but not pre-rasterization shader state, elements of `pStages` must not have `stage` set to a shader stage which participates in pre-rasterization

- VUID-VkGraphicsPipelineCreateInfo-pStages-06896
  If the pipeline requires pre-rasterization shader state, all elements of `pStages` must have a `stage` set to a shader stage which participates in fragment shader state or pre-rasterization shader state

- VUID-VkGraphicsPipelineCreateInfo-stage-06897
  If the pipeline requires fragment shader state and/or pre-rasterization shader state, any value of `stage` must not be set in more than one element of `pStages`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3TessellationDomainOrigin-07370
  If the `extendedDynamicState3TessellationDomainOrigin` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3DepthClampEnable-07371
  If the `extendedDynamicState3DepthClampEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3PolygonMode-07372
  If the `extendedDynamicState3PolygonMode` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_POLYGON_MODE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3RasterizationSamples-07373
  If the `extendedDynamicState3RasterizationSamples` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3SampleMask-07374
  If the `extendedDynamicState3SampleMask` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_SAMPLE_MASK_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3AlphaToCoverageEnable-07375
  If the `extendedDynamicState3AlphaToCoverageEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3AlphaToOneEnable-07376
  If the `extendedDynamicState3AlphaToOneEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3LogicOpEnable-07377
  If the `extendedDynamicState3LogicOpEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ColorBlendEnable-07378
  If the `extendedDynamicState3ColorBlendEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ColorBlendEquation-07379
  If the `extendedDynamicState3ColorBlendEquation` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ColorWriteMask-07380
  If the `extendedDynamicState3ColorWriteMask` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3RasterizationStream-07381
  If the `extendedDynamicState3RasterizationStream` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ConservativeRasterizationMode-07382
  If the `extendedDynamicState3ConservativeRasterizationMode` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ExtraPrimitiveOverestimationSize-07383
  If the `extendedDynamicState3ExtraPrimitiveOverestimationSize` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-09639
  If the pipeline requires pre-rasterization shader state, `pDynamicState` includes `VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT`, and `pDynamicState` does not include `VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT`, `pRasterizationState` must include a VkPipelineRasterizationConservativeStateCreateInfoEXT in its `pNext` chain

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3DepthClipEnable-07384
  If the `extendedDynamicState3DepthClipEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3SampleLocationsEnable-07385
  If the `extendedDynamicState3SampleLocationsEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ColorBlendAdvanced-07386
  If the `extendedDynamicState3ColorBlendAdvanced` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ProvokingVertexMode-07387
  If the `extendedDynamicState3ProvokingVertexMode` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3LineRasterizationMode-07388
  If the `extendedDynamicState3LineRasterizationMode` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3LineStippleEnable-07389
  If the `extendedDynamicState3LineStippleEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3DepthClipNegativeOneToOne-07390
  If the `extendedDynamicState3DepthClipNegativeOneToOne` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ViewportWScalingEnable-07391
  If the `extendedDynamicState3ViewportWScalingEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ViewportSwizzle-07392
  If the `extendedDynamicState3ViewportSwizzle` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3CoverageToColorEnable-07393
  If the `extendedDynamicState3CoverageToColorEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3CoverageToColorLocation-07394
  If the `extendedDynamicState3CoverageToColorLocation` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3CoverageModulationMode-07395
  If the `extendedDynamicState3CoverageModulationMode` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3CoverageModulationTableEnable-07396
  If the `extendedDynamicState3CoverageModulationTableEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3CoverageModulationTable-07397
  If the `extendedDynamicState3CoverageModulationTable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3CoverageReductionMode-07398
  If the `extendedDynamicState3CoverageReductionMode` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3RepresentativeFragmentTestEnable-07399
  If the `extendedDynamicState3RepresentativeFragmentTestEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV`

- VUID-VkGraphicsPipelineCreateInfo-extendedDynamicState3ShadingRateImageEnable-07400
  If the `extendedDynamicState3ShadingRateImageEnable` feature is not enabled, there must be no element of the `pDynamicStates` member of `pDynamicState` set to `VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV`

- VUID-VkGraphicsPipelineCreateInfo-flags-07401
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-flags-07997
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07730
  If the pipeline requires pre-rasterization shader state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_VIEWPORT` or `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT`, and if the `multiviewPerViewViewports` feature is enabled, then the index of the most significant bit in each element of VkRenderPassMultiviewCreateInfo::`pViewMasks` must be less than `pViewportState->viewportCount`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07731
  If the pipeline requires pre-rasterization shader state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_SCISSOR` or `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT`, and if the `multiviewPerViewViewports` feature is enabled, then the index of the most significant bit in each element of VkRenderPassMultiviewCreateInfo::`pViewMasks` must be less than `pViewportState->scissorCount`

- VUID-VkGraphicsPipelineCreateInfo-pStages-08711
  If `pStages` includes a fragment shader stage, `VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE` is not set in VkPipelineDynamicStateCreateInfo::`pDynamicStates`, and the fragment shader declares the `EarlyFragmentTests` execution mode and uses `OpDepthAttachmentReadEXT`, the `depthWriteEnable` member of VkPipelineDepthStencilStateCreateInfo must be `VK_FALSE`

- VUID-VkGraphicsPipelineCreateInfo-pStages-08712
  If `pStages` includes a fragment shader stage, `VK_DYNAMIC_STATE_STENCIL_WRITE_MASK` is not set in VkPipelineDynamicStateCreateInfo::`pDynamicStates`, and the fragment shader declares the `EarlyFragmentTests` execution mode and uses `OpStencilAttachmentReadEXT`, the value of VkStencilOpState::`writeMask` for both `front` and `back` in VkPipelineDepthStencilStateCreateInfo must be `0`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-08744
  If `renderPass` is VK_NULL_HANDLE, the pipeline requires fragment output state or fragment shader state, the pipeline enables sample shading, `rasterizationSamples` is not dynamic, and the `pNext` chain includes a VkPipelineRenderingCreateInfo structure, `rasterizationSamples` must be a valid VkSampleCountFlagBits value that is set in `imageCreateSampleCounts` (as defined in Image Creation Limits) for every element of `depthAttachmentFormat`, `stencilAttachmentFormat` and the `pColorAttachmentFormats` array which is not `VK_FORMAT_UNDEFINED`

- VUID-VkGraphicsPipelineCreateInfo-flags-08897
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT`, pre-rasterization shader state is specified either in a library or by the inclusion of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, and that state includes a vertex shader stage in `pStages`, the pipeline must define vertex input state

- VUID-VkGraphicsPipelineCreateInfo-flags-08898
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT`, and pre-rasterization shader state is not specified, the pipeline must define vertex input state

- VUID-VkGraphicsPipelineCreateInfo-flags-08899
  If `flags` does not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`, pre-rasterization shader state is specified either in a library or by the inclusion of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, and that state includes a vertex shader stage in `pStages`, the pipeline must either define vertex input state or include that state in a linked pipeline library

- VUID-VkGraphicsPipelineCreateInfo-flags-08900
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` the pipeline must define pre-rasterization shader state

- VUID-VkGraphicsPipelineCreateInfo-flags-08901
  If `flags` does not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`, the pipeline must either define pre-rasterization shader state or include that state in a linked pipeline library

- VUID-VkGraphicsPipelineCreateInfo-flags-08903
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, pre-rasterization shader state is specified either in a library or by the inclusion of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, and that state either includes `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE` or has `pRasterizationState->rasterizerDiscardEnable` set to `VK_FALSE`, the pipeline must define fragment shader state

- VUID-VkGraphicsPipelineCreateInfo-flags-08904
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and pre-rasterization shader state is not specified, the pipeline must define fragment shader state

- VUID-VkGraphicsPipelineCreateInfo-flags-08906
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, pre-rasterization shader state is specified either in a library or by the inclusion of `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT`, and that state either includes `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE` or has `pRasterizationState->rasterizerDiscardEnable` set to `VK_FALSE`, the pipeline must define fragment output interface state

- VUID-VkGraphicsPipelineCreateInfo-flags-08907
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, and pre-rasterization shader state is not specified, the pipeline must define fragment output interface state

- VUID-VkGraphicsPipelineCreateInfo-flags-08909
  If `flags` does not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`, pre-rasterization shader state is specified either in a library or by the inclusion of `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, and that state either includes `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE` or has `pRasterizationState->rasterizerDiscardEnable` set to `VK_FALSE`, the pipeline must define fragment output interface state and fragment shader state or include those states in linked pipeline libraries

- VUID-VkGraphicsPipelineCreateInfo-None-09043
  If `pDynamicState->pDynamicStates` does not include `VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT`, and the format of any color attachment is `VK_FORMAT_E5B9G9R9_UFLOAT_PACK32`, the `colorWriteMask` member of the corresponding element of `pColorBlendState->pAttachments` must either include all of `VK_COLOR_COMPONENT_R_BIT`, `VK_COLOR_COMPONENT_G_BIT`, and `VK_COLOR_COMPONENT_B_BIT`, or none of them

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09301
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkExternalFormatANDROID::`externalFormat` is not `0`, VkPipelineRenderingCreateInfo::`viewMask` must be `0`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09304
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, VkExternalFormatANDROID::`externalFormat` is not `0`, and `rasterizationSamples` is not dynamic, VkPipelineMultisampleStateCreateInfo::`rasterizationSamples` must be `1`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09305
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkExternalFormatANDROID::`externalFormat` is not `0`, and `blendEnable` is not dynamic, the `blendEnable` member of each element of `pColorBlendState->pAttachments` must be `VK_FALSE`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09306
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkExternalFormatANDROID::`externalFormat` is not `0`, and `pDynamicState->pDynamicStates` does not include `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`width` must be `1`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09307
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkExternalFormatANDROID::`externalFormat` is not `0`, and `pDynamicState->pDynamicStates` does not include `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`height` must be `1`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09308
  If the `externalFormatResolve` feature is enabled, the pipeline requires pre-rasterization shader state and fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkExternalFormatANDROID::`externalFormat` is not `0`, the last pre-rasterization shader stage must not statically use a variable with the `PrimitiveShadingRateKHR` built-in

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09309
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkExternalFormatANDROID::`externalFormat` is not `0`, VkPipelineRenderingCreateInfo::`colorAttachmentCount` must be `1`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09310
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment shader state and fragment output interface state, `renderPass` is VK_NULL_HANDLE, and VkExternalFormatANDROID::`externalFormat` is not `0`, the fragment shader must not declare the `DepthReplacing` or `StencilRefReplacingEXT` execution modes

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09313
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is not VK_NULL_HANDLE, `subpass` includes an external format resolve attachment, and `rasterizationSamples` is not dynamic, VkPipelineMultisampleStateCreateInfo::`rasterizationSamples` must be `VK_SAMPLE_COUNT_1_BIT`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09314
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is not VK_NULL_HANDLE, `subpass` includes an external format resolve attachment, and `blendEnable` is not dynamic, the `blendEnable` member of each element of `pColorBlendState->pAttachments` must be `VK_FALSE`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09315
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is not VK_NULL_HANDLE, `subpass` includes an external format resolve attachment, and `pDynamicState->pDynamicStates` does not include `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`width` must be `1`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09316
  If the `externalFormatResolve` feature is enabled, the pipeline requires fragment output interface state, `renderPass` is not VK_NULL_HANDLE, `subpass` includes an external format resolve attachment, and `pDynamicState->pDynamicStates` does not include `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`height` must be `1`

- VUID-VkGraphicsPipelineCreateInfo-externalFormatResolve-09317
  If the `externalFormatResolve` feature is enabled, the pipeline requires pre-rasterization shader state and fragment output interface state, `renderPass` is not VK_NULL_HANDLE, and `subpass` includes an external format resolve attachment, the last pre-rasterization shader stage must not statically use a variable with the `PrimitiveShadingRateKHR` built-in

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09531
  If the pipeline is being created with fragment shader state and fragment output state, the value of `renderPass` is VK_NULL_HANDLE, and VkRenderingInputAttachmentIndexInfo is included, VkRenderingInputAttachmentIndexInfo::`colorAttachmentCount` must be equal to VkPipelineRenderingCreateInfo::`colorAttachmentCount`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09652
  If the pipeline is being created with fragment shader state and fragment output state, the value of `renderPass` is VK_NULL_HANDLE, and VkRenderingInputAttachmentIndexInfo is not included, the fragment shader must not contain any input attachments with a `InputAttachmentIndex` greater than or equal to VkPipelineRenderingCreateInfo::`colorAttachmentCount`

- VUID-VkGraphicsPipelineCreateInfo-renderPass-09532
  If the pipeline is being created with fragment output state, and the value of `renderPass` is VK_NULL_HANDLE, VkRenderingAttachmentLocationInfo::`colorAttachmentCount` must be equal to VkPipelineRenderingCreateInfo::`colorAttachmentCount`

Valid Usage (Implicit)

- VUID-VkGraphicsPipelineCreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO`

- VUID-VkGraphicsPipelineCreateInfo-pNext-pNext
  Each `pNext` member of any structure (including this one) in the `pNext` chain must be either `NULL` or a pointer to a valid instance of VkAttachmentSampleCountInfoAMD, VkExternalFormatANDROID, VkGraphicsPipelineLibraryCreateInfoEXT, VkGraphicsPipelineShaderGroupsCreateInfoNV, VkMultiviewPerViewAttributesInfoNVX, VkPipelineBinaryInfoKHR, VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreateFlags2CreateInfo, VkPipelineCreationFeedbackCreateInfo, VkPipelineDiscardRectangleStateCreateInfoEXT, VkPipelineFragmentShadingRateEnumStateCreateInfoNV, VkPipelineFragmentShadingRateStateCreateInfoKHR, VkPipelineLibraryCreateInfoKHR, VkPipelineRenderingCreateInfo, VkPipelineRepresentativeFragmentTestStateCreateInfoNV, VkPipelineRobustnessCreateInfo, VkRenderingAttachmentLocationInfo, or VkRenderingInputAttachmentIndexInfo

- VUID-VkGraphicsPipelineCreateInfo-sType-unique
  The `sType` value of each struct in the `pNext` chain must be unique

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter
  If `pDynamicState` is not `NULL`, `pDynamicState` must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-commonparent
  Each of `basePipelineHandle`, `layout`, and `renderPass` that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The `VkPipelineRenderingCreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPipelineRenderingCreateInfo {
        VkStructureType    sType;
        const void*        pNext;
        uint32_t           viewMask;
        uint32_t           colorAttachmentCount;
        const VkFormat*    pColorAttachmentFormats;
        VkFormat           depthAttachmentFormat;
        VkFormat           stencilAttachmentFormat;
    } VkPipelineRenderingCreateInfo;

or the equivalent

    // Provided by VK_KHR_dynamic_rendering
    typedef VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `viewMask` is the viewMask used for rendering.

- `colorAttachmentCount` is the number of entries in `pColorAttachmentFormats`

- `pColorAttachmentFormats` is a pointer to an array of VkFormat values defining the format of color attachments used in this pipeline.

- `depthAttachmentFormat` is a VkFormat value defining the format of the depth attachment used in this pipeline.

- `stencilAttachmentFormat` is a VkFormat value defining the format of the stencil attachment used in this pipeline.

When a pipeline is created without a VkRenderPass, if the `pNext` chain of VkGraphicsPipelineCreateInfo includes this structure, it specifies the view mask and format of attachments used for rendering. If this structure is not specified, and the pipeline does not include a VkRenderPass, `viewMask` and `colorAttachmentCount` are `0`, and `depthAttachmentFormat` and `stencilAttachmentFormat` are `VK_FORMAT_UNDEFINED`. If a graphics pipeline is created with a valid VkRenderPass, parameters of this structure are ignored.

If `depthAttachmentFormat`, `stencilAttachmentFormat`, or any element of `pColorAttachmentFormats` is `VK_FORMAT_UNDEFINED`, it indicates that the corresponding attachment is unused within the render pass. Valid formats indicate that an attachment can be used - but it is still valid to set the attachment to `NULL` when beginning rendering.

If the render pass is going to be used with an external format resolve attachment, a VkExternalFormatANDROID structure must also be included in the `pNext` chain of VkGraphicsPipelineCreateInfo, defining the external format of the resolve attachment that will be used.

Valid Usage

- VUID-VkPipelineRenderingCreateInfo-colorAttachmentCount-09533
  `colorAttachmentCount` must be less than or equal to `maxColorAttachments`

Valid Usage (Implicit)

- VUID-VkPipelineRenderingCreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO`

The `VkPipelineCreateFlags2CreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_4
    typedef struct VkPipelineCreateFlags2CreateInfo {
        VkStructureType           sType;
        const void*               pNext;
        VkPipelineCreateFlags2    flags;
    } VkPipelineCreateFlags2CreateInfo;

or the equivalent

    // Provided by VK_KHR_maintenance5
    typedef VkPipelineCreateFlags2CreateInfo VkPipelineCreateFlags2CreateInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `flags` is a bitmask of VkPipelineCreateFlagBits2 specifying how a pipeline will be generated.

If this structure is included in the `pNext` chain of a pipeline creation structure, `flags` is used instead of the corresponding `flags` value passed in that creation structure, allowing additional creation flags to be specified.

Valid Usage (Implicit)

- VUID-VkPipelineCreateFlags2CreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO`

- VUID-VkPipelineCreateFlags2CreateInfo-flags-parameter
  `flags` must be a valid combination of VkPipelineCreateFlagBits2 values

- VUID-VkPipelineCreateFlags2CreateInfo-flags-requiredbitmask
  `flags` must not be `0`

Bits which can be set in VkPipelineCreateFlags2CreateInfo::`flags`, specifying how a pipeline is created, are:

    // Provided by VK_VERSION_1_4
    // Flag bits for VkPipelineCreateFlagBits2
    typedef VkFlags64 VkPipelineCreateFlagBits2;
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT = 0x00000001ULL;
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT = 0x00000002ULL;
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT = 0x00000004ULL;
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008ULL;
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT = 0x00000010ULL;
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100ULL;
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200ULL;
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT = 0x08000000ULL;
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT = 0x40000000ULL;
    #ifdef VK_ENABLE_BETA_EXTENSIONS
    // Provided by VK_AMDX_shader_enqueue with VK_KHR_maintenance5 or VK_VERSION_1_4
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX = 0x100000000ULL;
    #endif
    // Provided by VK_EXT_legacy_dithering with (VK_KHR_dynamic_rendering or VK_VERSION_1_3) and (VK_KHR_maintenance5 or VK_VERSION_1_4)
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL;
    // Provided by VK_KHR_maintenance5
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL;
    // Provided by VK_KHR_maintenance5
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL;
    // Provided by VK_KHR_maintenance5
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL;
    // Provided by VK_KHR_maintenance5
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL;
    // Provided by VK_KHR_maintenance5
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL;
    // Provided by VK_KHR_maintenance5 with VK_NV_ray_tracing
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_pipeline_executable_properties
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR = 0x00000040ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_pipeline_executable_properties
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080ULL;
    // Provided by VK_KHR_maintenance5 with VK_VERSION_1_3 or VK_EXT_pipeline_creation_cache_control
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR = 0x00000100ULL;
    // Provided by VK_KHR_maintenance5 with VK_VERSION_1_3 or VK_EXT_pipeline_creation_cache_control
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR = 0x00000200ULL;
    // Provided by VK_KHR_maintenance5 with VK_EXT_graphics_pipeline_library
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400ULL;
    // Provided by VK_KHR_maintenance5 with VK_EXT_graphics_pipeline_library
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_pipeline_library
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR = 0x00000800ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_ray_tracing_pipeline
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_ray_tracing_pipeline
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_ray_tracing_pipeline
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_ray_tracing_pipeline
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_ray_tracing_pipeline
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_ray_tracing_pipeline
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000ULL;
    // Provided by VK_KHR_maintenance5 with VK_KHR_ray_tracing_pipeline
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000ULL;
    // Provided by VK_KHR_maintenance5 with VK_NV_device_generated_commands
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV = 0x00040000ULL;
    // Provided by VK_KHR_maintenance5 with VK_NV_ray_tracing_motion_blur
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000ULL;
    // Provided by VK_KHR_maintenance5 with (VK_KHR_dynamic_rendering or VK_VERSION_1_3) and VK_KHR_fragment_shading_rate
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000ULL;
    // Provided by VK_KHR_maintenance5 with (VK_KHR_dynamic_rendering or VK_VERSION_1_3) and VK_EXT_fragment_density_map
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ULL;
    // Provided by VK_KHR_maintenance5 with VK_EXT_opacity_micromap
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL;
    // Provided by VK_KHR_maintenance5 with VK_EXT_attachment_feedback_loop_layout
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ULL;
    // Provided by VK_KHR_maintenance5 with VK_EXT_attachment_feedback_loop_layout
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ULL;
    // Provided by VK_KHR_maintenance5 with VK_VERSION_1_4 or VK_EXT_pipeline_protected_access
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000ULL;
    // Provided by VK_KHR_maintenance5 with VK_VERSION_1_4 or VK_EXT_pipeline_protected_access
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL;
    // Provided by VK_KHR_maintenance5 with VK_NV_displacement_micromap
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL;
    // Provided by VK_KHR_maintenance5 with VK_EXT_descriptor_buffer
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL;
    // Provided by VK_KHR_pipeline_binary
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL;
    // Provided by VK_EXT_device_generated_commands
    static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL;

or the equivalent

    // Provided by VK_KHR_maintenance5
    typedef VkPipelineCreateFlagBits2 VkPipelineCreateFlagBits2KHR;

- `VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT` specifies that the created pipeline will not be optimized. Using this flag may reduce the time taken to create the pipeline.

- `VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT` specifies that the pipeline to be created is allowed to be the parent of a pipeline that will be created in a subsequent pipeline creation call.

- `VK_PIPELINE_CREATE_2_DERIVATIVE_BIT` specifies that the pipeline to be created will be a child of a previously created parent pipeline.

- `VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT` specifies that any shader input variables decorated as `ViewIndex` will be assigned values as if they were decorated as `DeviceIndex`.

- `VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT` specifies that a compute pipeline can be used with vkCmdDispatchBase with a non-zero base workgroup.

- `VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV` specifies that a pipeline is created with all shaders in the deferred state. Before using the pipeline the application must call vkCompileDeferredNV exactly once on each shader in the pipeline before using the pipeline.

- `VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR` specifies that the shader compiler should capture statistics for the pipeline executables produced by the compile process which can later be retrieved by calling vkGetPipelineExecutableStatisticsKHR. Enabling this flag must not affect the final compiled pipeline but may disable pipeline caching or otherwise affect pipeline creation time.

- `VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR` specifies that the shader compiler should capture the internal representations of pipeline executables produced by the compile process which can later be retrieved by calling vkGetPipelineExecutableInternalRepresentationsKHR. Enabling this flag must not affect the final compiled pipeline but may disable pipeline caching or otherwise affect pipeline creation time. When capturing IR from pipelines created with pipeline libraries, there is no guarantee that IR from libraries can be retrieved from the linked pipeline. Applications should retrieve IR from each library, and any linked pipelines, separately.

- `VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR` specifies that the pipeline cannot be used directly, and instead defines a pipeline library that can be combined with other pipelines using the VkPipelineLibraryCreateInfoKHR structure. This is available in ray tracing and graphics pipelines.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR` specifies that an any-hit shader will always be present when an any-hit shader would be executed. A NULL any-hit shader is an any-hit shader which is effectively `VK_SHADER_UNUSED_KHR`, such as from a shader group consisting entirely of zeros.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR` specifies that a closest hit shader will always be present when a closest hit shader would be executed. A NULL closest hit shader is a closest hit shader which is effectively `VK_SHADER_UNUSED_KHR`, such as from a shader group consisting entirely of zeros.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR` specifies that a miss shader will always be present when a miss shader would be executed. A NULL miss shader is a miss shader which is effectively `VK_SHADER_UNUSED_KHR`, such as from a shader group consisting entirely of zeros.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR` specifies that an intersection shader will always be present when an intersection shader would be executed. A NULL intersection shader is an intersection shader which is effectively `VK_SHADER_UNUSED_KHR`, such as from a shader group consisting entirely of zeros.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR` specifies that triangle primitives will be skipped during traversal using pipeline trace ray instructions.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR` specifies that AABB primitives will be skipped during traversal using pipeline trace ray instructions.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR` specifies that the shader group handles can be saved and reused on a subsequent run (e.g. for trace capture and replay).

- `VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV` specifies that the pipeline can be used in combination with Device-Generated Commands.

- `VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT` specifies that the pipeline can be used in a `VkIndirectExecutionSetEXT`.

- `VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` specifies that pipeline creation will fail if a compile is required for creation of a valid VkPipeline object; `VK_PIPELINE_COMPILE_REQUIRED` will be returned by pipeline creation, and the VkPipeline will be VK_NULL_HANDLE.

- When creating multiple pipelines, `VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT` specifies that control will be returned to the application if any individual pipeline returns a result which is not `VK_SUCCESS` rather than continuing to create additional pipelines.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV` specifies that the pipeline is allowed to use `OpTraceRayMotionNV`.

- `VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR` specifies that the pipeline will be used with a fragment shading rate attachment.

- `VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT` specifies that the pipeline will be used with a fragment density map attachment.

- `VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT` specifies that pipeline libraries being linked into this library should have link time optimizations applied. If this bit is omitted, implementations should instead perform linking as rapidly as possible.

- `VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT` specifies that pipeline libraries should retain any information necessary to later perform an optimal link with `VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT`.

- `VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT` specifies that a pipeline will be used with descriptor buffers, rather than descriptor sets.

- `VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT` specifies that the pipeline may be used with an attachment feedback loop including color attachments.

- `VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT` specifies that the pipeline may be used with an attachment feedback loop including depth-stencil attachments.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT` specifies that the ray tracing pipeline can be used with acceleration structures which reference an opacity micromap array.

- `VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV` specifies that the ray tracing pipeline can be used with acceleration structures which reference a displacement micromap array.

- `VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT` specifies that the pipeline must not be bound to a protected command buffer.

- `VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT` specifies that the pipeline must not be bound to an unprotected command buffer.

- `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` specifies that `VkPipelineBinaryKHR` objects can be created from the pipeline. If `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` is used, implementations should not store pipeline data to an internal cache, if such a cache exists as stated by `pipelineBinaryInternalCache`. If `pipelineBinaryPrefersInternalCache` is `VK_TRUE`, applications should not use `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR`.

- `VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT` specifies that the pipeline will be used in a render pass that is begun with `VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT`.

- `VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX` specifies that the pipeline will be used in an execution graph

It is valid to set both `VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT` and `VK_PIPELINE_CREATE_2_DERIVATIVE_BIT`. This allows a pipeline to be both a parent and possibly a child in a pipeline hierarchy. See Pipeline Derivatives for more information.

When an implementation is looking up a pipeline in a pipeline cache, if that pipeline is being created using linked libraries, implementations should always return an equivalent pipeline created with `VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT` if available, whether or not that bit was specified.

Note | Using `VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT` (or not) when linking pipeline libraries is intended as a performance tradeoff between host and device. If the bit is omitted, linking should be faster and produce a pipeline more rapidly, but performance of the pipeline on the target device may be reduced. If the bit is included, linking may be slower but should produce a pipeline with device performance comparable to a monolithically created pipeline. Using both options can allow latency-sensitive applications to generate a suboptimal but usable pipeline quickly, and then perform an optimal link in the background, substituting the result for the suboptimally linked pipeline as soon as it is available.

    // Provided by VK_VERSION_1_4
    typedef VkFlags64 VkPipelineCreateFlags2;

or the equivalent

    // Provided by VK_KHR_maintenance5
    typedef VkPipelineCreateFlags2 VkPipelineCreateFlags2KHR;

`VkPipelineCreateFlags2` is a bitmask type for setting a mask of zero or more VkPipelineCreateFlagBits2.

Bits which can be set in

- VkGraphicsPipelineCreateInfo::`flags`

- VkComputePipelineCreateInfo::`flags`

- VkRayTracingPipelineCreateInfoKHR::`flags`

- VkRayTracingPipelineCreateInfoNV::`flags`

specify how a pipeline is created, and are:

    // Provided by VK_VERSION_1_0
    typedef enum VkPipelineCreateFlagBits {
        VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
        VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
        VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
      // Provided by VK_VERSION_1_1
        VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
      // Provided by VK_VERSION_1_1
        VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,
      // Provided by VK_VERSION_1_3
        VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100,
      // Provided by VK_VERSION_1_3
        VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200,
      // Provided by VK_VERSION_1_4
        VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT = 0x08000000,
      // Provided by VK_VERSION_1_4
        VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT = 0x40000000,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000,
      // Provided by VK_NV_ray_tracing
        VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
      // Provided by VK_EXT_fragment_density_map with VK_VERSION_1_3 or VK_KHR_dynamic_rendering
        VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000,
      // Provided by VK_KHR_fragment_shading_rate with VK_VERSION_1_3 or VK_KHR_dynamic_rendering
        VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000,
      // Provided by VK_KHR_pipeline_executable_properties
        VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
      // Provided by VK_KHR_pipeline_executable_properties
        VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
      // Provided by VK_NV_device_generated_commands
        VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000,
      // Provided by VK_KHR_pipeline_library
        VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800,
      // Provided by VK_EXT_descriptor_buffer
        VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000,
      // Provided by VK_EXT_graphics_pipeline_library
        VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000,
      // Provided by VK_EXT_graphics_pipeline_library
        VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400,
      // Provided by VK_NV_ray_tracing_motion_blur
        VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000,
      // Provided by VK_EXT_attachment_feedback_loop_layout
        VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000,
      // Provided by VK_EXT_attachment_feedback_loop_layout
        VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000,
      // Provided by VK_EXT_opacity_micromap
        VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000,
    #ifdef VK_ENABLE_BETA_EXTENSIONS
      // Provided by VK_NV_displacement_micromap
        VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000,
    #endif
      // Provided by VK_VERSION_1_1
        VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
      // Provided by VK_KHR_device_group
        VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
      // Provided by VK_KHR_device_group
        VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
      // Provided by VK_EXT_fragment_density_map with VK_VERSION_1_3 or VK_KHR_dynamic_rendering
      // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT is a deprecated alias
        VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT,
      // Provided by VK_KHR_fragment_shading_rate with VK_VERSION_1_3 or VK_KHR_dynamic_rendering
      // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR is a deprecated alias
        VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
      // Provided by VK_EXT_pipeline_creation_cache_control
        VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT,
      // Provided by VK_EXT_pipeline_creation_cache_control
        VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT,
      // Provided by VK_EXT_pipeline_protected_access
        VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT,
      // Provided by VK_EXT_pipeline_protected_access
        VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT,
    } VkPipelineCreateFlagBits;

- `VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT` specifies that the created pipeline will not be optimized. Using this flag may reduce the time taken to create the pipeline.

- `VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT` specifies that the pipeline to be created is allowed to be the parent of a pipeline that will be created in a subsequent pipeline creation call.

- `VK_PIPELINE_CREATE_DERIVATIVE_BIT` specifies that the pipeline to be created will be a child of a previously created parent pipeline.

- `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT` specifies that any shader input variables decorated as `ViewIndex` will be assigned values as if they were decorated as `DeviceIndex`.

- `VK_PIPELINE_CREATE_DISPATCH_BASE` specifies that a compute pipeline can be used with vkCmdDispatchBase with a non-zero base workgroup.

- `VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV` specifies that a pipeline is created with all shaders in the deferred state. Before using the pipeline the application must call vkCompileDeferredNV exactly once on each shader in the pipeline before using the pipeline.

- `VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR` specifies that the shader compiler should capture statistics for the pipeline executables produced by the compile process which can later be retrieved by calling vkGetPipelineExecutableStatisticsKHR. Enabling this flag must not affect the final compiled pipeline but may disable pipeline caching or otherwise affect pipeline creation time.

- `VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR` specifies that the shader compiler should capture the internal representations of pipeline executables produced by the compile process which can later be retrieved by calling vkGetPipelineExecutableInternalRepresentationsKHR. Enabling this flag must not affect the final compiled pipeline but may disable pipeline caching or otherwise affect pipeline creation time. When capturing IR from pipelines created with pipeline libraries, there is no guarantee that IR from libraries can be retrieved from the linked pipeline. Applications should retrieve IR from each library, and any linked pipelines, separately.

- `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` specifies that the pipeline cannot be used directly, and instead defines a pipeline library that can be combined with other pipelines using the VkPipelineLibraryCreateInfoKHR structure. This is available in ray tracing and graphics pipelines.

- `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR` specifies that an any-hit shader will always be present when an any-hit shader would be executed. A NULL any-hit shader is an any-hit shader which is effectively `VK_SHADER_UNUSED_KHR`, such as from a shader group consisting entirely of zeros.

- `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR` specifies that a closest hit shader will always be present when a closest hit shader would be executed. A NULL closest hit shader is a closest hit shader which is effectively `VK_SHADER_UNUSED_KHR`, such as from a shader group consisting entirely of zeros.

- `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR` specifies that a miss shader will always be present when a miss shader would be executed. A NULL miss shader is a miss shader which is effectively `VK_SHADER_UNUSED_KHR`, such as from a shader group consisting entirely of zeros.

- `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR` specifies that an intersection shader will always be present when an intersection shader would be executed. A NULL intersection shader is an intersection shader which is effectively `VK_SHADER_UNUSED_KHR`, such as from a shader group consisting entirely of zeros.

- `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR` specifies that triangle primitives will be skipped during traversal using pipeline trace ray instructions.

- `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR` specifies that AABB primitives will be skipped during traversal using pipeline trace ray instructions.

- `VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR` specifies that the shader group handles can be saved and reused on a subsequent run (e.g. for trace capture and replay).

- `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV` specifies that the pipeline can be used in combination with Device-Generated Commands.

- `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` specifies that pipeline creation will fail if a compile is required for creation of a valid VkPipeline object; `VK_PIPELINE_COMPILE_REQUIRED` will be returned by pipeline creation, and the VkPipeline will be VK_NULL_HANDLE.

- When creating multiple pipelines, `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT` specifies that control will be returned to the application if any individual pipeline returns a result which is not `VK_SUCCESS` rather than continuing to create additional pipelines.

- `VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV` specifies that the pipeline is allowed to use `OpTraceRayMotionNV`.

- `VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR` specifies that the pipeline will be used with a fragment shading rate attachment and dynamic rendering.

- `VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT` specifies that the pipeline will be used with a fragment density map attachment and dynamic rendering.

- `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT` specifies that pipeline libraries being linked into this library should have link time optimizations applied. If this bit is omitted, implementations should instead perform linking as rapidly as possible.

- `VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT` specifies that pipeline libraries should retain any information necessary to later perform an optimal link with `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT`.

- `VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT` specifies that a pipeline will be used with descriptor buffers, rather than descriptor sets.

- `VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT` specifies that the pipeline may be used with an attachment feedback loop including color attachments. It is ignored if `VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT` is set in `pDynamicStates`.

- `VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT` specifies that the pipeline may be used with an attachment feedback loop including depth-stencil attachments. It is ignored if `VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT` is set in `pDynamicStates`.

- `VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT` specifies that the ray tracing pipeline can be used with acceleration structures which reference an opacity micromap array.

- `VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV` specifies that the ray tracing pipeline can be used with acceleration structures which reference a displacement micromap array.

- `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT` specifies that the pipeline must not be bound to a protected command buffer.

- `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT` specifies that the pipeline must not be bound to an unprotected command buffer.

It is valid to set both `VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT` and `VK_PIPELINE_CREATE_DERIVATIVE_BIT`. This allows a pipeline to be both a parent and possibly a child in a pipeline hierarchy. See Pipeline Derivatives for more information.

When an implementation is looking up a pipeline in a pipeline cache, if that pipeline is being created using linked libraries, implementations should always return an equivalent pipeline created with `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT` if available, whether or not that bit was specified.

Note | Using `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT` (or not) when linking pipeline libraries is intended as a performance tradeoff between host and device. If the bit is omitted, linking should be faster and produce a pipeline more rapidly, but performance of the pipeline on the target device may be reduced. If the bit is included, linking may be slower but should produce a pipeline with device performance comparable to a monolithically created pipeline. Using both options can allow latency-sensitive applications to generate a suboptimal but usable pipeline quickly, and then perform an optimal link in the background, substituting the result for the suboptimally linked pipeline as soon as it is available.

    // Provided by VK_VERSION_1_0
    typedef VkFlags VkPipelineCreateFlags;

`VkPipelineCreateFlags` is a bitmask type for setting a mask of zero or more VkPipelineCreateFlagBits.

The `VkPipelineBinaryInfoKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_binary
    typedef struct VkPipelineBinaryInfoKHR {
        VkStructureType               sType;
        const void*                   pNext;
        uint32_t                      binaryCount;
        const VkPipelineBinaryKHR*    pPipelineBinaries;
    } VkPipelineBinaryInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `binaryCount` is the number of elements in the `pPipelineBinaries` array.

- `pPipelineBinaries` is a pointer to an array of VkPipelineBinaryKHR handles.

If a `VkPipelineBinaryInfoKHR` structure with a `binaryCount` greater than 0 is included in the `pNext` chain of any `Vk*PipelineCreateInfo` structure when creating a pipeline, implementations must use the data in `pPipelineBinaries` instead of recalculating it. Any shader module identifiers or shader modules declared in VkPipelineShaderStageCreateInfo instances are ignored.

If this structure is not included in the `pNext` chain, it is equivalent to specifying this structure with a `binaryCount` of `0`.

Valid Usage

- VUID-VkPipelineBinaryInfoKHR-binaryCount-09603
  `binaryCount` and the order of the elements in `pPipelineBinaries` must exactly match that returned by vkCreatePipelineBinariesKHR for the matching `Vk*PipelineCreateInfo` structure and its `pNext` chain, ignoring the presence of the `VkPipelineBinaryInfoKHR` structure, the presence of the `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` flag, and absence of any shader module identifiers or shader modules, for the same global pipeline key, from either:

  - VkPipelineBinaryCreateInfoKHR::`pPipelineCreateInfo`, or

  - VkPipelineBinaryCreateInfoKHR::`pipeline`

Valid Usage (Implicit)

- VUID-VkPipelineBinaryInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR`

- VUID-VkPipelineBinaryInfoKHR-pPipelineBinaries-parameter
  If `binaryCount` is not `0`, `pPipelineBinaries` must be a valid pointer to an array of `binaryCount` valid VkPipelineBinaryKHR handles

The `VkGraphicsPipelineLibraryCreateInfoEXT` structure is defined as:

    // Provided by VK_EXT_graphics_pipeline_library
    typedef struct VkGraphicsPipelineLibraryCreateInfoEXT {
        VkStructureType                      sType;
        const void*                          pNext;
        VkGraphicsPipelineLibraryFlagsEXT    flags;
    } VkGraphicsPipelineLibraryCreateInfoEXT;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `flags` is a bitmask of VkGraphicsPipelineLibraryFlagBitsEXT specifying the subsets of the graphics pipeline that are being compiled.

If a `VkGraphicsPipelineLibraryCreateInfoEXT` structure is included in the `pNext` chain of VkGraphicsPipelineCreateInfo, it specifies the subsets of the graphics pipeline being created, excluding any subsets from linked pipeline libraries. If the pipeline is created with pipeline libraries, state from those libraries is aggregated with said subset.

If this structure is omitted, and either VkGraphicsPipelineCreateInfo::`flags` includes `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` or the VkGraphicsPipelineCreateInfo::`pNext` chain includes a VkPipelineLibraryCreateInfoKHR structure with a `libraryCount` greater than `0`, it is as if `flags` is `0`. Otherwise if this structure is omitted, it is as if `flags` includes all possible subsets of the graphics pipeline (i.e. a complete graphics pipeline).

Valid Usage (Implicit)

- VUID-VkGraphicsPipelineLibraryCreateInfoEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT`

- VUID-VkGraphicsPipelineLibraryCreateInfoEXT-flags-parameter
  `flags` must be a valid combination of VkGraphicsPipelineLibraryFlagBitsEXT values

- VUID-VkGraphicsPipelineLibraryCreateInfoEXT-flags-requiredbitmask
  `flags` must not be `0`

    // Provided by VK_EXT_graphics_pipeline_library
    typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT;

`VkGraphicsPipelineLibraryFlagsEXT` is a bitmask type for setting a mask of zero or more VkGraphicsPipelineLibraryFlagBitsEXT.

Possible values of the `flags` member of VkGraphicsPipelineLibraryCreateInfoEXT, specifying the subsets of a graphics pipeline to compile are:

    // Provided by VK_EXT_graphics_pipeline_library
    typedef enum VkGraphicsPipelineLibraryFlagBitsEXT {
        VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0x00000001,
        VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 0x00000002,
        VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 0x00000004,
        VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 0x00000008,
    } VkGraphicsPipelineLibraryFlagBitsEXT;

- `VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT` specifies that a pipeline will include vertex input interface state.

- `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT` specifies that a pipeline will include pre-rasterization shader state.

- `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT` specifies that a pipeline will include fragment shader state.

- `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT` specifies that a pipeline will include fragment output interface state.

The `VkPipelineDynamicStateCreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkPipelineDynamicStateCreateInfo {
        VkStructureType                      sType;
        const void*                          pNext;
        VkPipelineDynamicStateCreateFlags    flags;
        uint32_t                             dynamicStateCount;
        const VkDynamicState*                pDynamicStates;
    } VkPipelineDynamicStateCreateInfo;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `flags` is reserved for future use.

- `dynamicStateCount` is the number of elements in the `pDynamicStates` array.

- `pDynamicStates` is a pointer to an array of VkDynamicState values specifying which pieces of pipeline state will use the values from dynamic state commands rather than from pipeline state creation information.

Valid Usage

- VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442
  Each element of `pDynamicStates` must be unique

Valid Usage (Implicit)

- VUID-VkPipelineDynamicStateCreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO`

- VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask
  `flags` must be `0`

- VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter
  If `dynamicStateCount` is not `0`, `pDynamicStates` must be a valid pointer to an array of `dynamicStateCount` valid VkDynamicState values

    // Provided by VK_VERSION_1_0
    typedef VkFlags VkPipelineDynamicStateCreateFlags;

`VkPipelineDynamicStateCreateFlags` is a bitmask type for setting a mask, but is currently reserved for future use.

The source of different pieces of dynamic state is specified by the VkPipelineDynamicStateCreateInfo::`pDynamicStates` property of the currently active pipeline, each of whose elements must be one of the values:

    // Provided by VK_VERSION_1_0
    typedef enum VkDynamicState {
        VK_DYNAMIC_STATE_VIEWPORT = 0,
        VK_DYNAMIC_STATE_SCISSOR = 1,
        VK_DYNAMIC_STATE_LINE_WIDTH = 2,
        VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
        VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
        VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
        VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
        VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
        VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_CULL_MODE = 1000267000,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_FRONT_FACE = 1000267001,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_STENCIL_OP = 1000267011,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002,
      // Provided by VK_VERSION_1_3
        VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004,
      // Provided by VK_VERSION_1_4
        VK_DYNAMIC_STATE_LINE_STIPPLE = 1000259000,
      // Provided by VK_NV_clip_space_w_scaling
        VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
      // Provided by VK_EXT_discard_rectangles
        VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
      // Provided by VK_EXT_discard_rectangles
        VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001,
      // Provided by VK_EXT_discard_rectangles
        VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002,
      // Provided by VK_EXT_sample_locations
        VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000,
      // Provided by VK_NV_shading_rate_image
        VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
      // Provided by VK_NV_shading_rate_image
        VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
      // Provided by VK_NV_scissor_exclusive
        VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000,
      // Provided by VK_NV_scissor_exclusive
        VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
      // Provided by VK_KHR_fragment_shading_rate
        VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
      // Provided by VK_EXT_vertex_input_dynamic_state
        VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000,
      // Provided by VK_EXT_extended_dynamic_state2
        VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000,
      // Provided by VK_EXT_extended_dynamic_state2
        VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,
      // Provided by VK_EXT_color_write_enable
        VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_KHR_maintenance2 or VK_VERSION_1_1
        VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_EXT_transform_feedback
        VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013,
      // Provided by VK_EXT_conservative_rasterization with VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014,
      // Provided by VK_EXT_conservative_rasterization with VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015,
      // Provided by VK_EXT_depth_clip_enable with VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_EXT_sample_locations
        VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017,
      // Provided by VK_EXT_blend_operation_advanced with VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_EXT_provoking_vertex
        VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_EXT_line_rasterization
        VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_EXT_line_rasterization
        VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021,
      // Provided by VK_EXT_depth_clip_control with VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_clip_space_w_scaling
        VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_viewport_swizzle
        VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_fragment_coverage_to_color
        VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_fragment_coverage_to_color
        VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_framebuffer_mixed_samples
        VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_framebuffer_mixed_samples
        VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_framebuffer_mixed_samples
        VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_shading_rate_image
        VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_representative_fragment_test
        VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031,
      // Provided by VK_EXT_extended_dynamic_state3 with VK_NV_coverage_reduction_mode
        VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032,
      // Provided by VK_EXT_attachment_feedback_loop_dynamic_state
        VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000,
      // Provided by VK_EXT_depth_clamp_control
        VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT = 1000582000,
      // Provided by VK_EXT_line_rasterization
        VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE,
      // Provided by VK_EXT_extended_dynamic_state
        VK_DYNAMIC_STATE_STENCIL_OP_EXT = VK_DYNAMIC_STATE_STENCIL_OP,
      // Provided by VK_EXT_extended_dynamic_state2
        VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE,
      // Provided by VK_EXT_extended_dynamic_state2
        VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE,
      // Provided by VK_EXT_extended_dynamic_state2
        VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE,
      // Provided by VK_KHR_line_rasterization
        VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = VK_DYNAMIC_STATE_LINE_STIPPLE,
    } VkDynamicState;

- `VK_DYNAMIC_STATE_VIEWPORT` specifies that the `pViewports` state in VkPipelineViewportStateCreateInfo will be ignored and must be set dynamically with vkCmdSetViewport before any drawing commands. The number of viewports used by a pipeline is still specified by the `viewportCount` member of VkPipelineViewportStateCreateInfo.

- `VK_DYNAMIC_STATE_SCISSOR` specifies that the `pScissors` state in VkPipelineViewportStateCreateInfo will be ignored and must be set dynamically with vkCmdSetScissor before any drawing commands. The number of scissor rectangles used by a pipeline is still specified by the `scissorCount` member of VkPipelineViewportStateCreateInfo.

- `VK_DYNAMIC_STATE_LINE_WIDTH` specifies that the `lineWidth` state in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetLineWidth before any drawing commands that generate line primitives for the rasterizer.

- `VK_DYNAMIC_STATE_DEPTH_BIAS` specifies that any instance of VkDepthBiasRepresentationInfoEXT included in the `pNext` chain of VkPipelineRasterizationStateCreateInfo as well as the `depthBiasConstantFactor`, `depthBiasClamp` and `depthBiasSlopeFactor` states in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthBias or vkCmdSetDepthBias2EXT before any draws are performed with depth bias enabled.

- `VK_DYNAMIC_STATE_BLEND_CONSTANTS` specifies that the `blendConstants` state in VkPipelineColorBlendStateCreateInfo will be ignored and must be set dynamically with vkCmdSetBlendConstants before any draws are performed with a pipeline state with `VkPipelineColorBlendAttachmentState` member `blendEnable` set to `VK_TRUE` and any of the blend functions using a constant blend color.

- `VK_DYNAMIC_STATE_DEPTH_BOUNDS` specifies that the `minDepthBounds` and `maxDepthBounds` states of VkPipelineDepthStencilStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthBounds before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member `depthBoundsTestEnable` set to `VK_TRUE`.

- `VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK` specifies that the `compareMask` state in VkPipelineDepthStencilStateCreateInfo for both `front` and `back` will be ignored and must be set dynamically with vkCmdSetStencilCompareMask before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member `stencilTestEnable` set to `VK_TRUE`

- `VK_DYNAMIC_STATE_STENCIL_WRITE_MASK` specifies that the `writeMask` state in VkPipelineDepthStencilStateCreateInfo for both `front` and `back` will be ignored and must be set dynamically with vkCmdSetStencilWriteMask before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member `stencilTestEnable` set to `VK_TRUE`

- `VK_DYNAMIC_STATE_STENCIL_REFERENCE` specifies that the `reference` state in VkPipelineDepthStencilStateCreateInfo for both `front` and `back` will be ignored and must be set dynamically with vkCmdSetStencilReference before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member `stencilTestEnable` set to `VK_TRUE`

- `VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV` specifies that the `pViewportWScalings` state in VkPipelineViewportWScalingStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetViewportWScalingNV before any draws are performed with a pipeline state with VkPipelineViewportWScalingStateCreateInfoNV member `viewportScalingEnable` set to `VK_TRUE`

- `VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT` specifies that the `pDiscardRectangles` state in VkPipelineDiscardRectangleStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetDiscardRectangleEXT before any draw or clear commands.

- `VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT` specifies that the presence of the VkPipelineDiscardRectangleStateCreateInfoEXT structure in the VkGraphicsPipelineCreateInfo chain with a `discardRectangleCount` greater than zero does not implicitly enable discard rectangles and they must be enabled dynamically with vkCmdSetDiscardRectangleEnableEXT before any draw commands. This is available on implementations that support at least `specVersion` `2` of the `VK_EXT_discard_rectangles` extension.

- `VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT` specifies that the `discardRectangleMode` state in VkPipelineDiscardRectangleStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetDiscardRectangleModeEXT before any draw commands. This is available on implementations that support at least `specVersion` `2` of the `VK_EXT_discard_rectangles` extension.

- `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT` specifies that the `sampleLocationsInfo` state in VkPipelineSampleLocationsStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetSampleLocationsEXT before any draw or clear commands. Enabling custom sample locations is still indicated by the `sampleLocationsEnable` member of VkPipelineSampleLocationsStateCreateInfoEXT.

- `VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV` specifies that the `pExclusiveScissors` state in VkPipelineViewportExclusiveScissorStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetExclusiveScissorNV before any drawing commands.

- `VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV` specifies that the exclusive scissors must be explicitly enabled with vkCmdSetExclusiveScissorEnableNV and the `exclusiveScissorCount` value in VkPipelineViewportExclusiveScissorStateCreateInfoNV will not implicitly enable them. This is available on implementations that support at least `specVersion` `2` of the `VK_NV_scissor_exclusive` extension.

- `VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV` specifies that the `pShadingRatePalettes` state in VkPipelineViewportShadingRateImageStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetViewportShadingRatePaletteNV before any drawing commands.

- `VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV` specifies that the coarse sample order state in VkPipelineViewportCoarseSampleOrderStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetCoarseSampleOrderNV before any drawing commands.

- `VK_DYNAMIC_STATE_LINE_STIPPLE` specifies that the `lineStippleFactor` and `lineStipplePattern` state in VkPipelineRasterizationLineStateCreateInfo will be ignored and must be set dynamically with vkCmdSetLineStipple before any draws are performed with a pipeline state with VkPipelineRasterizationLineStateCreateInfo member `stippledLineEnable` set to `VK_TRUE`.

- `VK_DYNAMIC_STATE_CULL_MODE` specifies that the `cullMode` state in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetCullMode before any drawing commands.

- `VK_DYNAMIC_STATE_FRONT_FACE` specifies that the `frontFace` state in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetFrontFace before any drawing commands.

- `VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY` specifies that the `topology` state in VkPipelineInputAssemblyStateCreateInfo only specifies the topology class, and the specific topology order and adjacency must be set dynamically with vkCmdSetPrimitiveTopology before any drawing commands.

- `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT` specifies that the `viewportCount` and `pViewports` state in VkPipelineViewportStateCreateInfo will be ignored and must be set dynamically with vkCmdSetViewportWithCount before any draw call.

- `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT` specifies that the `scissorCount` and `pScissors` state in VkPipelineViewportStateCreateInfo will be ignored and must be set dynamically with vkCmdSetScissorWithCount before any draw call.

- `VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE` specifies that the `stride` state in VkVertexInputBindingDescription will be ignored and must be set dynamically with vkCmdBindVertexBuffers2 before any draw call.

- `VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE` specifies that the `depthTestEnable` state in VkPipelineDepthStencilStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthTestEnable before any draw call.

- `VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE` specifies that the `depthWriteEnable` state in VkPipelineDepthStencilStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthWriteEnable before any draw call.

- `VK_DYNAMIC_STATE_DEPTH_COMPARE_OP` specifies that the `depthCompareOp` state in VkPipelineDepthStencilStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthCompareOp before any draw call.

- `VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE` specifies that the `depthBoundsTestEnable` state in VkPipelineDepthStencilStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthBoundsTestEnable before any draw call.

- `VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE` specifies that the `stencilTestEnable` state in VkPipelineDepthStencilStateCreateInfo will be ignored and must be set dynamically with vkCmdSetStencilTestEnable before any draw call.

- `VK_DYNAMIC_STATE_STENCIL_OP` specifies that the `failOp`, `passOp`, `depthFailOp`, and `compareOp` states in `VkPipelineDepthStencilStateCreateInfo` for both `front` and `back` will be ignored and must be set dynamically with vkCmdSetStencilOp before any draws are performed with a pipeline state with `VkPipelineDepthStencilStateCreateInfo` member `stencilTestEnable` set to `VK_TRUE`

- `VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT` specifies that the `patchControlPoints` state in VkPipelineTessellationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetPatchControlPointsEXT before any drawing commands.

- `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE` specifies that the `rasterizerDiscardEnable` state in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetRasterizerDiscardEnable before any drawing commands.

- `VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE` specifies that the `depthBiasEnable` state in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthBiasEnable before any drawing commands.

- `VK_DYNAMIC_STATE_LOGIC_OP_EXT` specifies that the `logicOp` state in VkPipelineColorBlendStateCreateInfo will be ignored and must be set dynamically with vkCmdSetLogicOpEXT before any drawing commands.

- `VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE` specifies that the `primitiveRestartEnable` state in VkPipelineInputAssemblyStateCreateInfo will be ignored and must be set dynamically with vkCmdSetPrimitiveRestartEnable before any drawing commands.

- `VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR` specifies that state in VkPipelineFragmentShadingRateStateCreateInfoKHR and VkPipelineFragmentShadingRateEnumStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetFragmentShadingRateKHR or vkCmdSetFragmentShadingRateEnumNV before any drawing commands.

- `VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR` specifies that the default stack size computation for the pipeline will be ignored and must be set dynamically with vkCmdSetRayTracingPipelineStackSizeKHR before any ray tracing calls are performed.

- `VK_DYNAMIC_STATE_VERTEX_INPUT_EXT` specifies that the `pVertexInputState` state will be ignored and must be set dynamically with vkCmdSetVertexInputEXT before any drawing commands

- `VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT` specifies that the `pColorWriteEnables` state in VkPipelineColorWriteCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetColorWriteEnableEXT before any draw call.

- `VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT` specifies that the `domainOrigin` state in VkPipelineTessellationDomainOriginStateCreateInfo will be ignored and must be set dynamically with vkCmdSetTessellationDomainOriginEXT before any draw call.

- `VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT` specifies that the `depthClampEnable` state in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthClampEnableEXT before any draw call.

- `VK_DYNAMIC_STATE_POLYGON_MODE_EXT` specifies that the `polygonMode` state in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetPolygonModeEXT before any draw call.

- `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT` specifies that the `rasterizationSamples` state in VkPipelineMultisampleStateCreateInfo will be ignored and must be set dynamically with vkCmdSetRasterizationSamplesEXT before any draw call.

- `VK_DYNAMIC_STATE_SAMPLE_MASK_EXT` specifies that the `pSampleMask` state in VkPipelineMultisampleStateCreateInfo will be ignored and must be set dynamically with vkCmdSetSampleMaskEXT before any draw call.

- `VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT` specifies that the `alphaToCoverageEnable` state in VkPipelineMultisampleStateCreateInfo will be ignored and must be set dynamically with vkCmdSetAlphaToCoverageEnableEXT before any draw call.

- `VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT` specifies that the `alphaToOneEnable` state in VkPipelineMultisampleStateCreateInfo will be ignored and must be set dynamically with vkCmdSetAlphaToOneEnableEXT before any draw call.

- `VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT` specifies that the `logicOpEnable` state in VkPipelineColorBlendStateCreateInfo will be ignored and must be set dynamically with vkCmdSetLogicOpEnableEXT before any draw call.

- `VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT` specifies that the `blendEnable` state in VkPipelineColorBlendAttachmentState will be ignored and must be set dynamically with vkCmdSetColorBlendEnableEXT before any draw call.

- `VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT` specifies that the `srcColorBlendFactor`, `dstColorBlendFactor`, `colorBlendOp`, `srcAlphaBlendFactor`, `dstAlphaBlendFactor`, and `alphaBlendOp` states in VkPipelineColorBlendAttachmentState will be ignored and must be set dynamically with vkCmdSetColorBlendEquationEXT before any draw call.

- `VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT` specifies that the `colorWriteMask` state in VkPipelineColorBlendAttachmentState will be ignored and must be set dynamically with vkCmdSetColorWriteMaskEXT before any draw call.

- `VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT` specifies that the `rasterizationStream` state in VkPipelineRasterizationStateStreamCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetRasterizationStreamEXT before any draw call.

- `VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT` specifies that the `conservativeRasterizationMode` state in VkPipelineRasterizationConservativeStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetConservativeRasterizationModeEXT before any draw call.

- `VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT` specifies that the `extraPrimitiveOverestimationSize` state in VkPipelineRasterizationConservativeStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetExtraPrimitiveOverestimationSizeEXT before any draw call.

- `VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT` specifies that the `depthClipEnable` state in VkPipelineRasterizationDepthClipStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetDepthClipEnableEXT before any draw call.

- `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT` specifies that the `sampleLocationsEnable` state in VkPipelineSampleLocationsStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetSampleLocationsEnableEXT before any draw call.

- `VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT` specifies that the `colorBlendOp` state in VkPipelineColorBlendAttachmentState, and `srcPremultiplied`, `dstPremultiplied`, and `blendOverlap` states in VkPipelineColorBlendAdvancedStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetColorBlendAdvancedEXT before any draw call.

- `VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT` specifies that the `provokingVertexMode` state in VkPipelineRasterizationProvokingVertexStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetProvokingVertexModeEXT before any draw call.

- `VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT` specifies that the `lineRasterizationMode` state in VkPipelineRasterizationLineStateCreateInfo will be ignored and must be set dynamically with vkCmdSetLineRasterizationModeEXT before any draw call.

- `VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT` specifies that the `stippledLineEnable` state in VkPipelineRasterizationLineStateCreateInfo will be ignored and must be set dynamically with vkCmdSetLineStippleEnableEXT before any draw call.

- `VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT` specifies that the `negativeOneToOne` state in VkPipelineViewportDepthClipControlCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetDepthClipNegativeOneToOneEXT before any draw call.

- `VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT` specifies that the `depthClampMode` and `pDepthClampRange` state in VkPipelineViewportDepthClampControlCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetDepthClampRangeEXT before any draw call.

- `VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV` specifies that the `viewportWScalingEnable` state in VkPipelineViewportWScalingStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetViewportWScalingEnableNV before any draw call.

- `VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV` specifies that the `viewportCount`, and `pViewportSwizzles` states in VkPipelineViewportSwizzleStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetViewportSwizzleNV before any draw call.

- `VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV` specifies that the `coverageToColorEnable` state in VkPipelineCoverageToColorStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetCoverageToColorEnableNV before any draw call.

- `VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV` specifies that the `coverageToColorLocation` state in VkPipelineCoverageToColorStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetCoverageToColorLocationNV before any draw call.

- `VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV` specifies that the `coverageModulationMode` state in VkPipelineCoverageModulationStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetCoverageModulationModeNV before any draw call.

- `VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV` specifies that the `coverageModulationTableEnable` state in VkPipelineCoverageModulationStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetCoverageModulationTableEnableNV before any draw call.

- `VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV` specifies that the `coverageModulationTableCount`, and `pCoverageModulationTable` states in VkPipelineCoverageModulationStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetCoverageModulationTableNV before any draw call.

- `VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV` specifies that the `shadingRateImageEnable` state in VkPipelineViewportShadingRateImageStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetShadingRateImageEnableNV before any draw call.

- `VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV` specifies that the `representativeFragmentTestEnable` state in VkPipelineRepresentativeFragmentTestStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetRepresentativeFragmentTestEnableNV before any draw call.

- `VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV` specifies that the `coverageReductionMode` state in VkPipelineCoverageReductionStateCreateInfoNV will be ignored and must be set dynamically with vkCmdSetCoverageReductionModeNV before any draw call.

- `VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT` specifies that the `VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT` and `VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT` flags will be ignored and must be set dynamically with vkCmdSetAttachmentFeedbackLoopEnableEXT before any draw call.

#### 10.3.1. Valid Combinations of Stages for Graphics Pipelines

Primitive processing can be handled either on a per primitive basis by the vertex, tessellation, and geometry shader stages, or on a per mesh basis using task and mesh shader stages. If the pipeline includes a mesh shader stage, it uses the mesh pipeline, otherwise it uses the primitive pipeline.

If a task shader is omitted, the task shading stage is skipped.

If tessellation shader stages are omitted, the tessellation shading and fixed-function stages of the pipeline are skipped.

If a geometry shader is omitted, the geometry shading stage is skipped.

If a fragment shader is omitted, fragment color outputs have undefined values, and the fragment depth value is determined by Fragment Operations state. This can be useful for depth-only rendering.

Presence of a shader stage in a pipeline is indicated by including a valid VkPipelineShaderStageCreateInfo with `module` and `pName` selecting an entry point from a shader module, where that entry point is valid for the stage specified by `stage`.

Presence of some of the fixed-function stages in the pipeline is implicitly derived from enabled shaders and provided state. For example, the fixed-function tessellator is always present when the pipeline has valid Tessellation Control and Tessellation Evaluation shaders.

For example:

- Depth/stencil-only rendering in a subpass with no color attachments

  - Active Pipeline Shader Stages

    - Vertex Shader

  - Required: Fixed-Function Pipeline Stages

    - VkPipelineVertexInputStateCreateInfo

    - VkPipelineInputAssemblyStateCreateInfo

    - VkPipelineViewportStateCreateInfo

    - VkPipelineRasterizationStateCreateInfo

    - VkPipelineMultisampleStateCreateInfo

    - VkPipelineDepthStencilStateCreateInfo

- Color-only rendering in a subpass with no depth/stencil attachment

  - Active Pipeline Shader Stages

    - Vertex Shader

    - Fragment Shader

  - Required: Fixed-Function Pipeline Stages

    - VkPipelineVertexInputStateCreateInfo

    - VkPipelineInputAssemblyStateCreateInfo

    - VkPipelineViewportStateCreateInfo

    - VkPipelineRasterizationStateCreateInfo

    - VkPipelineMultisampleStateCreateInfo

    - VkPipelineColorBlendStateCreateInfo

- Rendering pipeline with tessellation and geometry shaders

  - Active Pipeline Shader Stages

    - Vertex Shader

    - Tessellation Control Shader

    - Tessellation Evaluation Shader

    - Geometry Shader

    - Fragment Shader

  - Required: Fixed-Function Pipeline Stages

    - VkPipelineVertexInputStateCreateInfo

    - VkPipelineInputAssemblyStateCreateInfo

    - VkPipelineTessellationStateCreateInfo

    - VkPipelineViewportStateCreateInfo

    - VkPipelineRasterizationStateCreateInfo

    - VkPipelineMultisampleStateCreateInfo

    - VkPipelineDepthStencilStateCreateInfo

    - VkPipelineColorBlendStateCreateInfo

- Rendering pipeline with task and mesh shaders

  - Active Pipeline Shader Stages

    - Task Shader

    - Mesh Shader

    - Fragment Shader

  - Required: Fixed-Function Pipeline Stages

    - VkPipelineViewportStateCreateInfo

    - VkPipelineRasterizationStateCreateInfo

    - VkPipelineMultisampleStateCreateInfo

    - VkPipelineDepthStencilStateCreateInfo

    - VkPipelineColorBlendStateCreateInfo

#### 10.3.2. Graphics Pipeline Shader Groups

Graphics pipelines can contain multiple shader groups that can be bound individually. Each shader group behaves as if it was a pipeline using the shader group’s state. When the pipeline is bound by regular means, it behaves as if the state of group `0` is active, use vkCmdBindPipelineShaderGroupNV to bind an individual shader group.

The primary purpose of shader groups is allowing the device to bind different pipeline state using Device-Generated Commands.

The `VkGraphicsPipelineShaderGroupsCreateInfoNV` structure is defined as:

    // Provided by VK_NV_device_generated_commands
    typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV {
        VkStructureType                             sType;
        const void*                                 pNext;
        uint32_t                                    groupCount;
        const VkGraphicsShaderGroupCreateInfoNV*    pGroups;
        uint32_t                                    pipelineCount;
        const VkPipeline*                           pPipelines;
    } VkGraphicsPipelineShaderGroupsCreateInfoNV;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `groupCount` is the number of elements in the `pGroups` array.

- `pGroups` is a pointer to an array of VkGraphicsShaderGroupCreateInfoNV structures specifying which state of the original VkGraphicsPipelineCreateInfo each shader group overrides.

- `pipelineCount` is the number of elements in the `pPipelines` array.

- `pPipelines` is a pointer to an array of graphics `VkPipeline` structures which are referenced within the created pipeline, including all their shader groups.

When referencing shader groups by index, groups defined in the referenced pipelines are treated as if they were defined as additional entries in `pGroups`. They are appended in the order they appear in the `pPipelines` array and in the `pGroups` array when those pipelines were defined.

The application must maintain the lifetime of all such referenced pipelines based on the pipelines that make use of them.

Valid Usage

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-groupCount-02879
  `groupCount` must be at least `1` and as maximum `VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV`::`maxGraphicsShaderGroupCount`

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-groupCount-02880
  The sum of `groupCount` including those groups added from referenced `pPipelines` must also be as maximum `VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV`::`maxGraphicsShaderGroupCount`

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02881
  The state of the first element of `pGroups` must match its equivalent within the parent’s VkGraphicsPipelineCreateInfo

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02882
  Each element of `pGroups` must in combination with the rest of the pipeline state yield a valid state configuration

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02884
  All elements of `pGroups` must use the same shader stage combinations unless any mesh shader stage is used, then either combination of task and mesh or just mesh shader is valid

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02885
  Mesh and regular primitive shading stages cannot be mixed across `pGroups`

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pPipelines-02886
  Each element of `pPipelines` must have been created with identical state to the pipeline currently created except the state that can be overridden by VkGraphicsShaderGroupCreateInfoNV

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-deviceGeneratedCommands-02887
  The `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV`::`deviceGeneratedCommands` feature must be enabled

Valid Usage (Implicit)

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV`

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-parameter
  If `groupCount` is not `0`, `pGroups` must be a valid pointer to an array of `groupCount` valid VkGraphicsShaderGroupCreateInfoNV structures

- VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pPipelines-parameter
  If `pipelineCount` is not `0`, `pPipelines` must be a valid pointer to an array of `pipelineCount` valid VkPipeline handles

The `VkGraphicsShaderGroupCreateInfoNV` structure provides the state overrides for each shader group. Each shader group behaves like a pipeline that was created from its state as well as the remaining parent’s state. It is defined as:

    // Provided by VK_NV_device_generated_commands
    typedef struct VkGraphicsShaderGroupCreateInfoNV {
        VkStructureType                                 sType;
        const void*                                     pNext;
        uint32_t                                        stageCount;
        const VkPipelineShaderStageCreateInfo*          pStages;
        const VkPipelineVertexInputStateCreateInfo*     pVertexInputState;
        const VkPipelineTessellationStateCreateInfo*    pTessellationState;
    } VkGraphicsShaderGroupCreateInfoNV;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `stageCount` is the number of entries in the `pStages` array.

- `pStages` is a pointer to an array VkPipelineShaderStageCreateInfo structures specifying the set of the shader stages to be included in this shader group.

- `pVertexInputState` is a pointer to a VkPipelineVertexInputStateCreateInfo structure.

- `pTessellationState` is a pointer to a VkPipelineTessellationStateCreateInfo structure, and is ignored if the shader group does not include a tessellation control shader stage and tessellation evaluation shader stage.

Valid Usage

- VUID-VkGraphicsShaderGroupCreateInfoNV-stageCount-02888
  For `stageCount`, the same restrictions as in VkGraphicsPipelineCreateInfo::`stageCount` apply

- VUID-VkGraphicsShaderGroupCreateInfoNV-pStages-02889
  For `pStages`, the same restrictions as in VkGraphicsPipelineCreateInfo::`pStages` apply

- VUID-VkGraphicsShaderGroupCreateInfoNV-pVertexInputState-02890
  For `pVertexInputState`, the same restrictions as in VkGraphicsPipelineCreateInfo::`pVertexInputState` apply

- VUID-VkGraphicsShaderGroupCreateInfoNV-pTessellationState-02891
  For `pTessellationState`, the same restrictions as in VkGraphicsPipelineCreateInfo::`pTessellationState` apply

Valid Usage (Implicit)

- VUID-VkGraphicsShaderGroupCreateInfoNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV`

- VUID-VkGraphicsShaderGroupCreateInfoNV-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkGraphicsShaderGroupCreateInfoNV-pStages-parameter
  `pStages` must be a valid pointer to an array of `stageCount` valid VkPipelineShaderStageCreateInfo structures

- VUID-VkGraphicsShaderGroupCreateInfoNV-stageCount-arraylength
  `stageCount` must be greater than `0`

### 10.4. Ray Tracing Pipelines

Ray tracing pipelines consist of multiple shader stages, fixed-function traversal stages, and a pipeline layout.

`VK_SHADER_UNUSED_KHR` is a special shader index used to indicate that a ray generation, miss, or callable shader member is not used.

    #define VK_SHADER_UNUSED_KHR              (~0U)

or the equivalent

    #define VK_SHADER_UNUSED_NV               VK_SHADER_UNUSED_KHR

To create ray tracing pipelines, call:

    // Provided by VK_NV_ray_tracing
    VkResult vkCreateRayTracingPipelinesNV(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        uint32_t                                    createInfoCount,
        const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
        const VkAllocationCallbacks*                pAllocator,
        VkPipeline*                                 pPipelines);

- `device` is the logical device that creates the ray tracing pipelines.

- `pipelineCache` is either VK_NULL_HANDLE, indicating that pipeline caching is disabled, or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command.

- `createInfoCount` is the length of the `pCreateInfos` and `pPipelines` arrays.

- `pCreateInfos` is a pointer to an array of VkRayTracingPipelineCreateInfoNV structures.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

- `pPipelines` is a pointer to an array in which the resulting ray tracing pipeline objects are returned.

Pipelines are created and returned as described for Multiple Pipeline Creation.

Valid Usage

- VUID-vkCreateRayTracingPipelinesNV-device-09677
  `device` must support at least one queue family with the `VK_QUEUE_COMPUTE_BIT` capability

- VUID-vkCreateRayTracingPipelinesNV-flags-03415
  If the `flags` member of any element of `pCreateInfos` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and the `basePipelineIndex` member of that same element is not `-1`, `basePipelineIndex` must be less than the index into `pCreateInfos` that corresponds to that element

- VUID-vkCreateRayTracingPipelinesNV-flags-03416
  If the `flags` member of any element of `pCreateInfos` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, the base pipeline must have been created with the `VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT` flag set

- VUID-vkCreateRayTracingPipelinesNV-flags-03816
  `flags` must not contain the `VK_PIPELINE_CREATE_DISPATCH_BASE` flag

- VUID-vkCreateRayTracingPipelinesNV-pipelineCache-02903
  If `pipelineCache` was created with `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT`, host access to `pipelineCache` must be externally synchronized

- VUID-vkCreateRayTracingPipelinesNV-pNext-09616
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `pipelineCache` must be VK_NULL_HANDLE

- VUID-vkCreateRayTracingPipelinesNV-pNext-09617
  If a VkPipelineCreateFlags2CreateInfoKHR structure with the `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` flag set is included in the `pNext` chain of any element of `pCreateInfos`, `pipelineCache` must be VK_NULL_HANDLE

- VUID-vkCreateRayTracingPipelinesNV-binaryCount-09620
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT` must not be set in the `flags` of that element

- VUID-vkCreateRayTracingPipelinesNV-binaryCount-09621
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT` must not be set in the `flags` of that element

- VUID-vkCreateRayTracingPipelinesNV-binaryCount-09622
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT` must not be set in the `flags` of that element

- VUID-vkCreateRayTracingPipelinesNV-pNext-10150
  If a VkPipelineCreateFlags2CreateInfoKHR structure is included in the `pNext` chain of any element of `pCreateInfos`, `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` flag must not be set

Valid Usage (Implicit)

- VUID-vkCreateRayTracingPipelinesNV-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parameter
  If `pipelineCache` is not VK_NULL_HANDLE, `pipelineCache` must be a valid VkPipelineCache handle

- VUID-vkCreateRayTracingPipelinesNV-pCreateInfos-parameter
  `pCreateInfos` must be a valid pointer to an array of `createInfoCount` valid VkRayTracingPipelineCreateInfoNV structures

- VUID-vkCreateRayTracingPipelinesNV-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

- VUID-vkCreateRayTracingPipelinesNV-pPipelines-parameter
  `pPipelines` must be a valid pointer to an array of `createInfoCount` VkPipeline handles

- VUID-vkCreateRayTracingPipelinesNV-createInfoCount-arraylength
  `createInfoCount` must be greater than `0`

- VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parent
  If `pipelineCache` is a valid handle, it must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_PIPELINE_COMPILE_REQUIRED_EXT`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

  - `VK_ERROR_INVALID_SHADER_NV`

To create ray tracing pipelines, call:

    // Provided by VK_KHR_ray_tracing_pipeline
    VkResult vkCreateRayTracingPipelinesKHR(
        VkDevice                                    device,
        VkDeferredOperationKHR                      deferredOperation,
        VkPipelineCache                             pipelineCache,
        uint32_t                                    createInfoCount,
        const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
        const VkAllocationCallbacks*                pAllocator,
        VkPipeline*                                 pPipelines);

- `device` is the logical device that creates the ray tracing pipelines.

- `deferredOperation` is VK_NULL_HANDLE or the handle of a valid VkDeferredOperationKHR request deferral object for this command.

- `pipelineCache` is either VK_NULL_HANDLE, indicating that pipeline caching is disabled, or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command.

- `createInfoCount` is the length of the `pCreateInfos` and `pPipelines` arrays.

- `pCreateInfos` is a pointer to an array of VkRayTracingPipelineCreateInfoKHR structures.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

- `pPipelines` is a pointer to an array in which the resulting ray tracing pipeline objects are returned.

The `VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS` error is returned if the implementation is unable to reuse the shader group handles provided in VkRayTracingShaderGroupCreateInfoKHR::`pShaderGroupCaptureReplayHandle` when VkPhysicalDeviceRayTracingPipelineFeaturesKHR::`rayTracingPipelineShaderGroupHandleCaptureReplay` is enabled.

Pipelines are created and returned as described for Multiple Pipeline Creation.

Valid Usage

- VUID-vkCreateRayTracingPipelinesKHR-device-09677
  `device` must support at least one queue family with the `VK_QUEUE_COMPUTE_BIT` capability

- VUID-vkCreateRayTracingPipelinesKHR-flags-03415
  If the `flags` member of any element of `pCreateInfos` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and the `basePipelineIndex` member of that same element is not `-1`, `basePipelineIndex` must be less than the index into `pCreateInfos` that corresponds to that element

- VUID-vkCreateRayTracingPipelinesKHR-flags-03416
  If the `flags` member of any element of `pCreateInfos` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, the base pipeline must have been created with the `VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT` flag set

- VUID-vkCreateRayTracingPipelinesKHR-flags-03816
  `flags` must not contain the `VK_PIPELINE_CREATE_DISPATCH_BASE` flag

- VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-02903
  If `pipelineCache` was created with `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT`, host access to `pipelineCache` must be externally synchronized

- VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-03678
  Any previous deferred operation that was associated with `deferredOperation` must be complete

- VUID-vkCreateRayTracingPipelinesKHR-pNext-09616
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `pipelineCache` must be VK_NULL_HANDLE

- VUID-vkCreateRayTracingPipelinesKHR-pNext-09617
  If a VkPipelineCreateFlags2CreateInfoKHR structure with the `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` flag set is included in the `pNext` chain of any element of `pCreateInfos`, `pipelineCache` must be VK_NULL_HANDLE

- VUID-vkCreateRayTracingPipelinesKHR-binaryCount-09620
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT` must not be set in the `flags` of that element

- VUID-vkCreateRayTracingPipelinesKHR-binaryCount-09621
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT` must not be set in the `flags` of that element

- VUID-vkCreateRayTracingPipelinesKHR-binaryCount-09622
  If VkPipelineBinaryInfoKHR::`binaryCount` is not `0` for any element of `pCreateInfos`, `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT` must not be set in the `flags` of that element

- VUID-vkCreateRayTracingPipelinesKHR-rayTracingPipeline-03586
  The `rayTracingPipeline` feature must be enabled

- VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-03587
  If `deferredOperation` is not VK_NULL_HANDLE, the `flags` member of elements of `pCreateInfos` must not include `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT`

Valid Usage (Implicit)

- VUID-vkCreateRayTracingPipelinesKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-parameter
  If `deferredOperation` is not VK_NULL_HANDLE, `deferredOperation` must be a valid VkDeferredOperationKHR handle

- VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-parameter
  If `pipelineCache` is not VK_NULL_HANDLE, `pipelineCache` must be a valid VkPipelineCache handle

- VUID-vkCreateRayTracingPipelinesKHR-pCreateInfos-parameter
  `pCreateInfos` must be a valid pointer to an array of `createInfoCount` valid VkRayTracingPipelineCreateInfoKHR structures

- VUID-vkCreateRayTracingPipelinesKHR-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

- VUID-vkCreateRayTracingPipelinesKHR-pPipelines-parameter
  `pPipelines` must be a valid pointer to an array of `createInfoCount` VkPipeline handles

- VUID-vkCreateRayTracingPipelinesKHR-createInfoCount-arraylength
  `createInfoCount` must be greater than `0`

- VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-parent
  If `deferredOperation` is a valid handle, it must have been created, allocated, or retrieved from `device`

- VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-parent
  If `pipelineCache` is a valid handle, it must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_OPERATION_DEFERRED_KHR`

  - `VK_OPERATION_NOT_DEFERRED_KHR`

  - `VK_PIPELINE_COMPILE_REQUIRED_EXT`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

  - `VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS`

The `VkRayTracingPipelineCreateInfoNV` structure is defined as:

    // Provided by VK_NV_ray_tracing
    typedef struct VkRayTracingPipelineCreateInfoNV {
        VkStructureType                               sType;
        const void*                                   pNext;
        VkPipelineCreateFlags                         flags;
        uint32_t                                      stageCount;
        const VkPipelineShaderStageCreateInfo*        pStages;
        uint32_t                                      groupCount;
        const VkRayTracingShaderGroupCreateInfoNV*    pGroups;
        uint32_t                                      maxRecursionDepth;
        VkPipelineLayout                              layout;
        VkPipeline                                    basePipelineHandle;
        int32_t                                       basePipelineIndex;
    } VkRayTracingPipelineCreateInfoNV;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `flags` is a bitmask of VkPipelineCreateFlagBits specifying how the pipeline will be generated.

- `stageCount` is the number of entries in the `pStages` array.

- `pStages` is a pointer to an array of VkPipelineShaderStageCreateInfo structures specifying the set of the shader stages to be included in the ray tracing pipeline.

- `groupCount` is the number of entries in the `pGroups` array.

- `pGroups` is a pointer to an array of VkRayTracingShaderGroupCreateInfoNV structures describing the set of the shader stages to be included in each shader group in the ray tracing pipeline.

- `maxRecursionDepth` is the maximum recursion depth of shaders executed by this pipeline.

- `layout` is the description of binding locations used by both the pipeline and descriptor sets used with the pipeline.

- `basePipelineHandle` is a pipeline to derive from.

- `basePipelineIndex` is an index into the `pCreateInfos` parameter to use as a pipeline to derive from.

The parameters `basePipelineHandle` and `basePipelineIndex` are described in more detail in Pipeline Derivatives.

If the `pNext` chain includes a VkPipelineCreateFlags2CreateInfo structure, VkPipelineCreateFlags2CreateInfo::`flags` from that structure is used instead of `flags` from this structure.

Valid Usage

- VUID-VkRayTracingPipelineCreateInfoNV-None-09497
  If the `pNext` chain does not include a VkPipelineCreateFlags2CreateInfo structure, `flags` must be a valid combination of VkPipelineCreateFlagBits values

- VUID-VkRayTracingPipelineCreateInfoNV-flags-07984
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is -1, `basePipelineHandle` must be a valid ray tracing `VkPipeline` handle

- VUID-VkRayTracingPipelineCreateInfoNV-flags-07985
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineHandle` is VK_NULL_HANDLE, `basePipelineIndex` must be a valid index into the calling command’s `pCreateInfos` parameter

- VUID-VkRayTracingPipelineCreateInfoNV-flags-07986
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, `basePipelineIndex` must be -1 or `basePipelineHandle` must be VK_NULL_HANDLE

- VUID-VkRayTracingPipelineCreateInfoNV-layout-07987
  If a push constant block is declared in a shader, a push constant range in `layout` must match the shader stage

- VUID-VkRayTracingPipelineCreateInfoNV-layout-10069
  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

- VUID-VkRayTracingPipelineCreateInfoNV-layout-07988
  If a resource variable is declared in a shader, the corresponding descriptor set in `layout` must match the shader stage

- VUID-VkRayTracingPipelineCreateInfoNV-layout-07990
  If a resource variable is declared in a shader, and the descriptor type is not `VK_DESCRIPTOR_TYPE_MUTABLE_EXT`, the corresponding descriptor set in `layout` must match the descriptor type

- VUID-VkRayTracingPipelineCreateInfoNV-layout-07991
  If a resource variable is declared in a shader as an array, the corresponding descriptor set in `layout` must match the descriptor count

- VUID-VkRayTracingPipelineCreateInfoNV-None-10391
  If a resource variables is declared in a shader as an array of descriptors, then the descriptor type of that variable must not be `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK`

- VUID-VkRayTracingPipelineCreateInfoNV-pStages-03426
  The shader code for the entry points identified by `pStages`, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter

- VUID-VkRayTracingPipelineCreateInfoNV-layout-03428
  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`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-02904
  `flags` must not include `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV`

- VUID-VkRayTracingPipelineCreateInfoNV-pipelineCreationCacheControl-02905
  If the `pipelineCreationCacheControl` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` or `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT`

- VUID-VkRayTracingPipelineCreateInfoNV-stage-06232
  The `stage` member of at least one element of `pStages` must be `VK_SHADER_STAGE_RAYGEN_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03456
  `flags` must not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-maxRecursionDepth-03457
  `maxRecursionDepth` must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::`maxRecursionDepth`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03458
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03459
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03460
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03461
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03462
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03463
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03588
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-04948
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-02957
  `flags` must not include both `VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV` and `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` at the same time

- VUID-VkRayTracingPipelineCreateInfoNV-pipelineStageCreationFeedbackCount-06651
  If VkPipelineCreationFeedbackCreateInfo::`pipelineStageCreationFeedbackCount` is not `0`, it must be equal to `stageCount`

- VUID-VkRayTracingPipelineCreateInfoNV-stage-06898
  The `stage` value in all `pStages` elements must be one of `VK_SHADER_STAGE_RAYGEN_BIT_KHR`, `VK_SHADER_STAGE_ANY_HIT_BIT_KHR`, `VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR`, `VK_SHADER_STAGE_MISS_BIT_KHR`, `VK_SHADER_STAGE_INTERSECTION_BIT_KHR`, or `VK_SHADER_STAGE_CALLABLE_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-07402
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-07998
  `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-11008
  `flags` must not include `VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT`

Valid Usage (Implicit)

- VUID-VkRayTracingPipelineCreateInfoNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV`

- VUID-VkRayTracingPipelineCreateInfoNV-pNext-pNext
  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 VkPipelineCreateFlags2CreateInfo or VkPipelineCreationFeedbackCreateInfo

- VUID-VkRayTracingPipelineCreateInfoNV-sType-unique
  The `sType` value of each struct in the `pNext` chain must be unique

- VUID-VkRayTracingPipelineCreateInfoNV-pStages-parameter
  `pStages` must be a valid pointer to an array of `stageCount` valid VkPipelineShaderStageCreateInfo structures

- VUID-VkRayTracingPipelineCreateInfoNV-pGroups-parameter
  `pGroups` must be a valid pointer to an array of `groupCount` valid VkRayTracingShaderGroupCreateInfoNV structures

- VUID-VkRayTracingPipelineCreateInfoNV-layout-parameter
  `layout` must be a valid VkPipelineLayout handle

- VUID-VkRayTracingPipelineCreateInfoNV-stageCount-arraylength
  `stageCount` must be greater than `0`

- VUID-VkRayTracingPipelineCreateInfoNV-groupCount-arraylength
  `groupCount` must be greater than `0`

- VUID-VkRayTracingPipelineCreateInfoNV-commonparent
  Both of `basePipelineHandle`, and `layout` that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The `VkRayTracingPipelineCreateInfoKHR` structure is defined as:

    // Provided by VK_KHR_ray_tracing_pipeline
    typedef struct VkRayTracingPipelineCreateInfoKHR {
        VkStructureType                                      sType;
        const void*                                          pNext;
        VkPipelineCreateFlags                                flags;
        uint32_t                                             stageCount;
        const VkPipelineShaderStageCreateInfo*               pStages;
        uint32_t                                             groupCount;
        const VkRayTracingShaderGroupCreateInfoKHR*          pGroups;
        uint32_t                                             maxPipelineRayRecursionDepth;
        const VkPipelineLibraryCreateInfoKHR*                pLibraryInfo;
        const VkRayTracingPipelineInterfaceCreateInfoKHR*    pLibraryInterface;
        const VkPipelineDynamicStateCreateInfo*              pDynamicState;
        VkPipelineLayout                                     layout;
        VkPipeline                                           basePipelineHandle;
        int32_t                                              basePipelineIndex;
    } VkRayTracingPipelineCreateInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `flags` is a bitmask of VkPipelineCreateFlagBits specifying how the pipeline will be generated.

- `stageCount` is the number of entries in the `pStages` array.

- `pStages` is a pointer to an array of `stageCount` VkPipelineShaderStageCreateInfo structures describing the set of the shader stages to be included in the ray tracing pipeline.

- `groupCount` is the number of entries in the `pGroups` array.

- `pGroups` is a pointer to an array of `groupCount` VkRayTracingShaderGroupCreateInfoKHR structures describing the set of the shader stages to be included in each shader group in the ray tracing pipeline.

- `maxPipelineRayRecursionDepth` is the maximum recursion depth of shaders executed by this pipeline.

- `pLibraryInfo` is a pointer to a VkPipelineLibraryCreateInfoKHR structure defining pipeline libraries to include.

- `pLibraryInterface` is a pointer to a VkRayTracingPipelineInterfaceCreateInfoKHR structure defining additional information when using pipeline libraries.

- `pDynamicState` is a pointer to a VkPipelineDynamicStateCreateInfo structure, and is used to indicate which properties of the pipeline state object are dynamic and can be changed independently of the pipeline state. This can be `NULL`, which means no state in the pipeline is considered dynamic.

- `layout` is the description of binding locations used by both the pipeline and descriptor sets used with the pipeline.

- `basePipelineHandle` is a pipeline to derive from.

- `basePipelineIndex` is an index into the `pCreateInfos` parameter to use as a pipeline to derive from.

The parameters `basePipelineHandle` and `basePipelineIndex` are described in more detail in Pipeline Derivatives.

When `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` is specified, this pipeline defines a pipeline library which cannot be bound as a ray tracing pipeline directly. Instead, pipeline libraries define common shaders and shader groups which can be included in future pipeline creation.

If pipeline libraries are included in `pLibraryInfo`, shaders defined in those libraries are treated as if they were defined as additional entries in `pStages`, appended in the order they appear in the `pLibraries` array and in the `pStages` array when those libraries were defined.

When referencing shader groups in order to obtain a shader group handle, groups defined in those libraries are treated as if they were defined as additional entries in `pGroups`, appended in the order they appear in the `pLibraries` array and in the `pGroups` array when those libraries were defined. The shaders these groups reference are set when the pipeline library is created, referencing those specified in the pipeline library, not in the pipeline that includes it.

The default stack size for a pipeline if `VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR` is not provided is computed as described in Ray Tracing Pipeline Stack.

If the `pNext` chain includes a VkPipelineCreateFlags2CreateInfo structure, VkPipelineCreateFlags2CreateInfo::`flags` from that structure is used instead of `flags` from this structure.

Valid Usage

- VUID-VkRayTracingPipelineCreateInfoKHR-None-09497
  If the `pNext` chain does not include a VkPipelineCreateFlags2CreateInfo structure, `flags` must be a valid combination of VkPipelineCreateFlagBits values

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-07984
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is -1, `basePipelineHandle` must be a valid ray tracing `VkPipeline` handle

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-07985
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineHandle` is VK_NULL_HANDLE, `basePipelineIndex` must be a valid index into the calling command’s `pCreateInfos` parameter

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-07986
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, `basePipelineIndex` must be -1 or `basePipelineHandle` must be VK_NULL_HANDLE

- VUID-VkRayTracingPipelineCreateInfoKHR-layout-07987
  If a push constant block is declared in a shader, a push constant range in `layout` must match the shader stage

- VUID-VkRayTracingPipelineCreateInfoKHR-layout-10069
  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

- VUID-VkRayTracingPipelineCreateInfoKHR-layout-07988
  If a resource variable is declared in a shader, the corresponding descriptor set in `layout` must match the shader stage

- VUID-VkRayTracingPipelineCreateInfoKHR-layout-07990
  If a resource variable is declared in a shader, and the descriptor type is not `VK_DESCRIPTOR_TYPE_MUTABLE_EXT`, the corresponding descriptor set in `layout` must match the descriptor type

- VUID-VkRayTracingPipelineCreateInfoKHR-layout-07991
  If a resource variable is declared in a shader as an array, the corresponding descriptor set in `layout` must match the descriptor count

- VUID-VkRayTracingPipelineCreateInfoKHR-None-10391
  If a resource variables is declared in a shader as an array of descriptors, then the descriptor type of that variable must not be `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK`

- VUID-VkRayTracingPipelineCreateInfoKHR-pStages-03426
  The shader code for the entry points identified by `pStages`, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter

- VUID-VkRayTracingPipelineCreateInfoKHR-layout-03428
  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`

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-02904
  `flags` must not include `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV`

- VUID-VkRayTracingPipelineCreateInfoKHR-pipelineCreationCacheControl-02905
  If the `pipelineCreationCacheControl` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` or `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT`

- VUID-VkRayTracingPipelineCreateInfoKHR-stage-03425
  If `flags` does not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`, the `stage` member of at least one element of `pStages`, including those implicitly added by `pLibraryInfo`, must be `VK_SHADER_STAGE_RAYGEN_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-maxPipelineRayRecursionDepth-03589
  `maxPipelineRayRecursionDepth` must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::`maxRayRecursionDepth`

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-03465
  If `flags` includes `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`, `pLibraryInterface` must not be `NULL`

- VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03590
  If `pLibraryInfo` is not `NULL` and its `libraryCount` member is greater than `0`, `pLibraryInterface` must not be `NULL`

- VUID-VkRayTracingPipelineCreateInfoKHR-pLibraries-03591
  Each element of `pLibraryInfo->pLibraries` must have been created with the value of `maxPipelineRayRecursionDepth` equal to that in this pipeline

- VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03592
  If `pLibraryInfo` is not `NULL`, each element of its `pLibraries` member must have been created with a `layout` that is compatible with the `layout` in this pipeline

- VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03593
  If `pLibraryInfo` is not `NULL`, each element of its `pLibraries` member must have been created with values of the `maxPipelineRayPayloadSize` and `maxPipelineRayHitAttributeSize` members of `pLibraryInterface` equal to those in this pipeline

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-03594
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR`, each element of `pLibraryInfo->pLibraries` must have been created with the `VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR` bit set

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-04718
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR`, each element of `pLibraryInfo->pLibraries` must have been created with the `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR` bit set

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-04719
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR`, each element of `pLibraryInfo->pLibraries` must have been created with the `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR` bit set

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-04720
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR`, each element of `pLibraryInfo->pLibraries` must have been created with the `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR` bit set

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-04721
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR`, each element of `pLibraryInfo->pLibraries` must have been created with the `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR` bit set

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-04722
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR`, each element of `pLibraryInfo->pLibraries` must have been created with the `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR` bit set

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-04723
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR`, each element of `pLibraryInfo->pLibraries` must have been created with the `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR` bit set

- VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03595
  If the `VK_KHR_pipeline_library` extension is not enabled, `pLibraryInfo` and `pLibraryInterface` must be `NULL`

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-03470
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR`, for any element of `pGroups` with a `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR` or `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR`, the `anyHitShader` of that element must not be `VK_SHADER_UNUSED_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-03471
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR`, for any element of `pGroups` with a `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR` or `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR`, the `closestHitShader` of that element must not be `VK_SHADER_UNUSED_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-rayTraversalPrimitiveCulling-03596
  If the `rayTraversalPrimitiveCulling` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-rayTraversalPrimitiveCulling-03597
  If the `rayTraversalPrimitiveCulling` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-06546
  `flags` must not include both `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR` and `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-03598
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR`, `rayTracingPipelineShaderGroupHandleCaptureReplay` must be enabled

- VUID-VkRayTracingPipelineCreateInfoKHR-rayTracingPipelineShaderGroupHandleCaptureReplay-03599
  If VkPhysicalDeviceRayTracingPipelineFeaturesKHR::`rayTracingPipelineShaderGroupHandleCaptureReplay` is `VK_TRUE` and the `pShaderGroupCaptureReplayHandle` member of any element of `pGroups` is not `NULL`, `flags` must include `VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-07999
  If `pLibraryInfo` is `NULL` or its `libraryCount` is `0`, `stageCount` must not be `0`

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-08700
  If `flags` does not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` and either `pLibraryInfo` is `NULL` or its `libraryCount` is `0`, `groupCount` must not be `0`

- VUID-VkRayTracingPipelineCreateInfoKHR-pDynamicStates-03602
  Any element of the `pDynamicStates` member of `pDynamicState` must be `VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-pipelineStageCreationFeedbackCount-06652
  If VkPipelineCreationFeedbackCreateInfo::`pipelineStageCreationFeedbackCount` is not `0`, it must be equal to `stageCount`

- VUID-VkRayTracingPipelineCreateInfoKHR-stage-06899
  The `stage` value in all `pStages` elements must be one of `VK_SHADER_STAGE_RAYGEN_BIT_KHR`, `VK_SHADER_STAGE_ANY_HIT_BIT_KHR`, `VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR`, `VK_SHADER_STAGE_MISS_BIT_KHR`, `VK_SHADER_STAGE_INTERSECTION_BIT_KHR`, or `VK_SHADER_STAGE_CALLABLE_BIT_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-07403
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT`, each element of `pLibraryInfo->pLibraries` must have been created with the `VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT` bit set

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-08701
  If `flags` includes `VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV`, each element of `pLibraryInfo->pLibraries` must have been created with the `VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV` bit set

Valid Usage (Implicit)

- VUID-VkRayTracingPipelineCreateInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR`

- VUID-VkRayTracingPipelineCreateInfoKHR-pNext-pNext
  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 VkPipelineBinaryInfoKHR, VkPipelineCreateFlags2CreateInfo, VkPipelineCreationFeedbackCreateInfo, or VkPipelineRobustnessCreateInfo

- VUID-VkRayTracingPipelineCreateInfoKHR-sType-unique
  The `sType` value of each struct in the `pNext` chain must be unique

- VUID-VkRayTracingPipelineCreateInfoKHR-pStages-parameter
  If `stageCount` is not `0`, `pStages` must be a valid pointer to an array of `stageCount` valid VkPipelineShaderStageCreateInfo structures

- VUID-VkRayTracingPipelineCreateInfoKHR-pGroups-parameter
  If `groupCount` is not `0`, `pGroups` must be a valid pointer to an array of `groupCount` valid VkRayTracingShaderGroupCreateInfoKHR structures

- VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-parameter
  If `pLibraryInfo` is not `NULL`, `pLibraryInfo` must be a valid pointer to a valid VkPipelineLibraryCreateInfoKHR structure

- VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInterface-parameter
  If `pLibraryInterface` is not `NULL`, `pLibraryInterface` must be a valid pointer to a valid VkRayTracingPipelineInterfaceCreateInfoKHR structure

- VUID-VkRayTracingPipelineCreateInfoKHR-pDynamicState-parameter
  If `pDynamicState` is not `NULL`, `pDynamicState` must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure

- VUID-VkRayTracingPipelineCreateInfoKHR-layout-parameter
  `layout` must be a valid VkPipelineLayout handle

- VUID-VkRayTracingPipelineCreateInfoKHR-commonparent
  Both of `basePipelineHandle`, and `layout` that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice

The `VkRayTracingShaderGroupCreateInfoNV` structure is defined as:

    // Provided by VK_NV_ray_tracing
    typedef struct VkRayTracingShaderGroupCreateInfoNV {
        VkStructureType                   sType;
        const void*                       pNext;
        VkRayTracingShaderGroupTypeKHR    type;
        uint32_t                          generalShader;
        uint32_t                          closestHitShader;
        uint32_t                          anyHitShader;
        uint32_t                          intersectionShader;
    } VkRayTracingShaderGroupCreateInfoNV;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `type` is the type of hit group specified in this structure.

- `generalShader` is the index of the ray generation, miss, or callable shader from VkRayTracingPipelineCreateInfoNV::`pStages` in the group if the shader group has `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV`, and `VK_SHADER_UNUSED_NV` otherwise.

- `closestHitShader` is the optional index of the closest hit shader from VkRayTracingPipelineCreateInfoNV::`pStages` in the group if the shader group has `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV` or `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV`, and `VK_SHADER_UNUSED_NV` otherwise.

- `anyHitShader` is the optional index of the any-hit shader from VkRayTracingPipelineCreateInfoNV::`pStages` in the group if the shader group has `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV` or `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV`, and `VK_SHADER_UNUSED_NV` otherwise.

- `intersectionShader` is the index of the intersection shader from VkRayTracingPipelineCreateInfoNV::`pStages` in the group if the shader group has `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV`, and `VK_SHADER_UNUSED_NV` otherwise.

Valid Usage

- VUID-VkRayTracingShaderGroupCreateInfoNV-type-02413
  If `type` is `VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV` then `generalShader` must be a valid index into VkRayTracingPipelineCreateInfoNV::`pStages` referring to a shader of `VK_SHADER_STAGE_RAYGEN_BIT_NV`, `VK_SHADER_STAGE_MISS_BIT_NV`, or `VK_SHADER_STAGE_CALLABLE_BIT_NV`

- VUID-VkRayTracingShaderGroupCreateInfoNV-type-02414
  If `type` is `VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV` then `closestHitShader`, `anyHitShader`, and `intersectionShader` must be `VK_SHADER_UNUSED_NV`

- VUID-VkRayTracingShaderGroupCreateInfoNV-type-02415
  If `type` is `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV` then `intersectionShader` must be a valid index into VkRayTracingPipelineCreateInfoNV::`pStages` referring to a shader of `VK_SHADER_STAGE_INTERSECTION_BIT_NV`

- VUID-VkRayTracingShaderGroupCreateInfoNV-type-02416
  If `type` is `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV` then `intersectionShader` must be `VK_SHADER_UNUSED_NV`

- VUID-VkRayTracingShaderGroupCreateInfoNV-closestHitShader-02417
  `closestHitShader` must be either `VK_SHADER_UNUSED_NV` or a valid index into VkRayTracingPipelineCreateInfoNV::`pStages` referring to a shader of `VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV`

- VUID-VkRayTracingShaderGroupCreateInfoNV-anyHitShader-02418
  `anyHitShader` must be either `VK_SHADER_UNUSED_NV` or a valid index into VkRayTracingPipelineCreateInfoNV::`pStages` referring to a shader of `VK_SHADER_STAGE_ANY_HIT_BIT_NV`

Valid Usage (Implicit)

- VUID-VkRayTracingShaderGroupCreateInfoNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV`

- VUID-VkRayTracingShaderGroupCreateInfoNV-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkRayTracingShaderGroupCreateInfoNV-type-parameter
  `type` must be a valid VkRayTracingShaderGroupTypeKHR value

The `VkRayTracingShaderGroupCreateInfoKHR` structure is defined as:

    // Provided by VK_KHR_ray_tracing_pipeline
    typedef struct VkRayTracingShaderGroupCreateInfoKHR {
        VkStructureType                   sType;
        const void*                       pNext;
        VkRayTracingShaderGroupTypeKHR    type;
        uint32_t                          generalShader;
        uint32_t                          closestHitShader;
        uint32_t                          anyHitShader;
        uint32_t                          intersectionShader;
        const void*                       pShaderGroupCaptureReplayHandle;
    } VkRayTracingShaderGroupCreateInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `type` is the type of hit group specified in this structure.

- `generalShader` is the index of the ray generation, miss, or callable shader from VkRayTracingPipelineCreateInfoKHR::`pStages` in the group if the shader group has `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR`, and `VK_SHADER_UNUSED_KHR` otherwise.

- `closestHitShader` is the optional index of the closest hit shader from VkRayTracingPipelineCreateInfoKHR::`pStages` in the group if the shader group has `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR` or `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR`, and `VK_SHADER_UNUSED_KHR` otherwise.

- `anyHitShader` is the optional index of the any-hit shader from VkRayTracingPipelineCreateInfoKHR::`pStages` in the group if the shader group has `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR` or `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR`, and `VK_SHADER_UNUSED_KHR` otherwise.

- `intersectionShader` is the index of the intersection shader from VkRayTracingPipelineCreateInfoKHR::`pStages` in the group if the shader group has `type` of `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR`, and `VK_SHADER_UNUSED_KHR` otherwise.

- `pShaderGroupCaptureReplayHandle` is `NULL` or a pointer to replay information for this shader group queried from vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, as described in Ray Tracing Capture Replay. Ignored if VkPhysicalDeviceRayTracingPipelineFeaturesKHR::`rayTracingPipelineShaderGroupHandleCaptureReplay` is `VK_FALSE`.

If the pipeline is created with `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` and the pipelineLibraryGroupHandles feature is enabled, `pShaderGroupCaptureReplayHandle` is inherited by all pipelines which link against this pipeline and remains bitwise identical for any pipeline which references this pipeline library.

Valid Usage

- VUID-VkRayTracingShaderGroupCreateInfoKHR-type-03474
  If `type` is `VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR` then `generalShader` must be a valid index into VkRayTracingPipelineCreateInfoKHR::`pStages` referring to a shader of `VK_SHADER_STAGE_RAYGEN_BIT_KHR`, `VK_SHADER_STAGE_MISS_BIT_KHR`, or `VK_SHADER_STAGE_CALLABLE_BIT_KHR`

- VUID-VkRayTracingShaderGroupCreateInfoKHR-type-03475
  If `type` is `VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR` then `closestHitShader`, `anyHitShader`, and `intersectionShader` must be `VK_SHADER_UNUSED_KHR`

- VUID-VkRayTracingShaderGroupCreateInfoKHR-type-03476
  If `type` is `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR` then `intersectionShader` must be a valid index into VkRayTracingPipelineCreateInfoKHR::`pStages` referring to a shader of `VK_SHADER_STAGE_INTERSECTION_BIT_KHR`

- VUID-VkRayTracingShaderGroupCreateInfoKHR-type-03477
  If `type` is `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR` then `intersectionShader` must be `VK_SHADER_UNUSED_KHR`

- VUID-VkRayTracingShaderGroupCreateInfoKHR-closestHitShader-03478
  `closestHitShader` must be either `VK_SHADER_UNUSED_KHR` or a valid index into VkRayTracingPipelineCreateInfoKHR::`pStages` referring to a shader of `VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR`

- VUID-VkRayTracingShaderGroupCreateInfoKHR-anyHitShader-03479
  `anyHitShader` must be either `VK_SHADER_UNUSED_KHR` or a valid index into VkRayTracingPipelineCreateInfoKHR::`pStages` referring to a shader of `VK_SHADER_STAGE_ANY_HIT_BIT_KHR`

- VUID-VkRayTracingShaderGroupCreateInfoKHR-rayTracingPipelineShaderGroupHandleCaptureReplayMixed-03603
  If VkPhysicalDeviceRayTracingPipelineFeaturesKHR::`rayTracingPipelineShaderGroupHandleCaptureReplayMixed` is `VK_FALSE` then `pShaderGroupCaptureReplayHandle` must not be provided if it has not been provided on a previous call to ray tracing pipeline creation

- VUID-VkRayTracingShaderGroupCreateInfoKHR-rayTracingPipelineShaderGroupHandleCaptureReplayMixed-03604
  If VkPhysicalDeviceRayTracingPipelineFeaturesKHR::`rayTracingPipelineShaderGroupHandleCaptureReplayMixed` is `VK_FALSE` then the caller must guarantee that no ray tracing pipeline creation commands with `pShaderGroupCaptureReplayHandle` provided execute simultaneously with ray tracing pipeline creation commands without `pShaderGroupCaptureReplayHandle` provided

Valid Usage (Implicit)

- VUID-VkRayTracingShaderGroupCreateInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR`

- VUID-VkRayTracingShaderGroupCreateInfoKHR-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkRayTracingShaderGroupCreateInfoKHR-type-parameter
  `type` must be a valid VkRayTracingShaderGroupTypeKHR value

The `VkRayTracingShaderGroupTypeKHR` enumeration is defined as:

    // Provided by VK_KHR_ray_tracing_pipeline
    typedef enum VkRayTracingShaderGroupTypeKHR {
        VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0,
        VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1,
        VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2,
      // Provided by VK_NV_ray_tracing
        VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
      // Provided by VK_NV_ray_tracing
        VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
      // Provided by VK_NV_ray_tracing
        VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR,
    } VkRayTracingShaderGroupTypeKHR;

or the equivalent

    // Provided by VK_NV_ray_tracing
    typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV;

- `VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR` specifies that a shader group with a single `VK_SHADER_STAGE_RAYGEN_BIT_KHR`, `VK_SHADER_STAGE_MISS_BIT_KHR`, or `VK_SHADER_STAGE_CALLABLE_BIT_KHR` shader in it.

- `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR` specifies that a shader group that only hits triangles and must not contain an intersection shader, only closest hit and any-hit shaders.

- `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR` specifies that a shader group that only intersects with custom geometry and must contain an intersection shader and may contain closest hit and any-hit shaders.

Note | For current group types, the hit group type could be inferred from the presence or absence of the intersection shader, but we provide the type explicitly for future hit groups that do not have that property.

The `VkRayTracingPipelineInterfaceCreateInfoKHR` structure is defined as:

    // Provided by VK_KHR_ray_tracing_pipeline
    typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR {
        VkStructureType    sType;
        const void*        pNext;
        uint32_t           maxPipelineRayPayloadSize;
        uint32_t           maxPipelineRayHitAttributeSize;
    } VkRayTracingPipelineInterfaceCreateInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `maxPipelineRayPayloadSize` is the maximum payload size in bytes used by any shader in the pipeline.

- `maxPipelineRayHitAttributeSize` is the maximum attribute structure size in bytes used by any shader in the pipeline.

`maxPipelineRayPayloadSize` is calculated as the maximum size of the block (in bytes) declared in the `RayPayloadKHR` or `IncomingRayPayloadKHR` storage classes. `maxPipelineRayHitAttributeSize` is calculated as the maximum size of any block (in bytes) declared in the `HitAttributeKHR` storage class. As variables in these storage classes do not have explicit offsets, the size should be calculated as if each variable has a scalar alignment equal to the largest scalar alignment of any of the block’s members.

Note | There is no explicit upper limit for `maxPipelineRayPayloadSize`, but in practice it should be kept as small as possible. Similar to invocation local memory, it must be allocated for each shader invocation and for devices which support many simultaneous invocations, this storage can rapidly be exhausted, resulting in failure.

Valid Usage

- VUID-VkRayTracingPipelineInterfaceCreateInfoKHR-maxPipelineRayHitAttributeSize-03605
  `maxPipelineRayHitAttributeSize` must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::`maxRayHitAttributeSize`

Valid Usage (Implicit)

- VUID-VkRayTracingPipelineInterfaceCreateInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR`

- VUID-VkRayTracingPipelineInterfaceCreateInfoKHR-pNext-pNext
  `pNext` must be `NULL`

To query the opaque handles of shaders in the ray tracing pipeline, call:

    // Provided by VK_KHR_ray_tracing_pipeline
    VkResult vkGetRayTracingShaderGroupHandlesKHR(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        uint32_t                                    firstGroup,
        uint32_t                                    groupCount,
        size_t                                      dataSize,
        void*                                       pData);

or the equivalent command

    // Provided by VK_NV_ray_tracing
    VkResult vkGetRayTracingShaderGroupHandlesNV(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        uint32_t                                    firstGroup,
        uint32_t                                    groupCount,
        size_t                                      dataSize,
        void*                                       pData);

- `device` is the logical device containing the ray tracing pipeline.

- `pipeline` is the ray tracing pipeline object containing the shaders.

- `firstGroup` is the index of the first group to retrieve a handle for from the VkRayTracingPipelineCreateInfoKHR::`pGroups` or VkRayTracingPipelineCreateInfoNV::`pGroups` array.

- `groupCount` is the number of shader handles to retrieve.

- `dataSize` is the size in bytes of the buffer pointed to by `pData`.

- `pData` is a pointer to an application-allocated buffer where the results will be written.

On success, an array of `groupCount` shader handles will be written to `pData`, with each element being of size VkPhysicalDeviceRayTracingPipelinePropertiesKHR::`shaderGroupHandleSize`.

If `pipeline` was created with `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` and the pipelineLibraryGroupHandles feature is enabled applications can query group handles from that pipeline, even if the pipeline is a library and is never bound to a command buffer. These group handles remain bitwise identical for any `pipeline` which references the pipeline library. Group indices are assigned as-if the pipeline was created without `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`.

Valid Usage

- VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-04619
  `pipeline` must be a ray tracing pipeline

- VUID-vkGetRayTracingShaderGroupHandlesKHR-firstGroup-04050
  `firstGroup` must be less than the number of shader groups in `pipeline`

- VUID-vkGetRayTracingShaderGroupHandlesKHR-firstGroup-02419
  The sum of `firstGroup` and `groupCount` must be less than or equal to the number of shader groups in `pipeline`

- VUID-vkGetRayTracingShaderGroupHandlesKHR-dataSize-02420
  `dataSize` must be at least VkPhysicalDeviceRayTracingPipelinePropertiesKHR::`shaderGroupHandleSize` × `groupCount`

- VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-07828
  If the pipelineLibraryGroupHandles feature is not enabled, `pipeline` must not have been created with `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

Valid Usage (Implicit)

- VUID-vkGetRayTracingShaderGroupHandlesKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

- VUID-vkGetRayTracingShaderGroupHandlesKHR-pData-parameter
  `pData` must be a valid pointer to an array of `dataSize` bytes

- VUID-vkGetRayTracingShaderGroupHandlesKHR-dataSize-arraylength
  `dataSize` must be greater than `0`

- VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-parent
  `pipeline` must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

To query the opaque capture data of shader groups in a ray tracing pipeline, call:

    // Provided by VK_KHR_ray_tracing_pipeline
    VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        uint32_t                                    firstGroup,
        uint32_t                                    groupCount,
        size_t                                      dataSize,
        void*                                       pData);

- `device` is the logical device containing the ray tracing pipeline.

- `pipeline` is the ray tracing pipeline object containing the shaders.

- `firstGroup` is the index of the first group to retrieve a handle for from the VkRayTracingPipelineCreateInfoKHR::`pGroups` array.

- `groupCount` is the number of shader handles to retrieve.

- `dataSize` is the size in bytes of the buffer pointed to by `pData`.

- `pData` is a pointer to an application-allocated buffer where the results will be written.

On success, an array of `groupCount` shader handles will be written to `pData`, with each element being of size VkPhysicalDeviceRayTracingPipelinePropertiesKHR::`shaderGroupHandleCaptureReplaySize`.

Once queried, this opaque data can be provided at pipeline creation time (in a subsequent execution), using VkRayTracingShaderGroupCreateInfoKHR::`pShaderGroupCaptureReplayHandle`, as described in Ray Tracing Capture Replay.

If `pipeline` was created with `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` and the pipelineLibraryGroupHandles feature is enabled applications can query capture replay group handles from that pipeline. The capture replay handle remains bitwise identical for any `pipeline` which references the pipeline library. Group indices are assigned as-if the pipeline was created without `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`.

Valid Usage

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-04620
  `pipeline` must be a ray tracing pipeline

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-firstGroup-04051
  `firstGroup` must be less than the number of shader groups in `pipeline`

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-firstGroup-03483
  The sum of `firstGroup` and `groupCount` must be less than or equal to the number of shader groups in `pipeline`

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-dataSize-03484
  `dataSize` must be at least VkPhysicalDeviceRayTracingPipelinePropertiesKHR::`shaderGroupHandleCaptureReplaySize` × `groupCount`

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-rayTracingPipelineShaderGroupHandleCaptureReplay-03606
  `VkPhysicalDeviceRayTracingPipelineFeaturesKHR`::`rayTracingPipelineShaderGroupHandleCaptureReplay` must be enabled to call this function

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-03607
  `pipeline` must have been created with a `flags` that included `VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR`

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-07829
  If the pipelineLibraryGroupHandles feature is not enabled, `pipeline` must not have been created with `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

Valid Usage (Implicit)

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pData-parameter
  `pData` must be a valid pointer to an array of `dataSize` bytes

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-dataSize-arraylength
  `dataSize` must be greater than `0`

- VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-parent
  `pipeline` must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

Ray tracing pipelines can contain more shaders than a graphics or compute pipeline, so to allow parallel compilation of shaders within a pipeline, an application can choose to defer compilation until a later point in time.

To compile a deferred shader in a pipeline call:

    // Provided by VK_NV_ray_tracing
    VkResult vkCompileDeferredNV(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        uint32_t                                    shader);

- `device` is the logical device containing the ray tracing pipeline.

- `pipeline` is the ray tracing pipeline object containing the shaders.

- `shader` is the index of the shader to compile.

Valid Usage

- VUID-vkCompileDeferredNV-pipeline-04621
  `pipeline` must be a ray tracing pipeline

- VUID-vkCompileDeferredNV-pipeline-02237
  `pipeline` must have been created with `VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV`

- VUID-vkCompileDeferredNV-shader-02238
  `shader` must not have been called as a deferred compile before

Valid Usage (Implicit)

- VUID-vkCompileDeferredNV-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkCompileDeferredNV-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

- VUID-vkCompileDeferredNV-pipeline-parent
  `pipeline` must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

To query the pipeline stack size of shaders in a shader group in the ray tracing pipeline, call:

    // Provided by VK_KHR_ray_tracing_pipeline
    VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        uint32_t                                    group,
        VkShaderGroupShaderKHR                      groupShader);

- `device` is the logical device containing the ray tracing pipeline.

- `pipeline` is the ray tracing pipeline object containing the shaders groups.

- `group` is the index of the shader group to query.

- `groupShader` is the type of shader from the group to query.

The return value is the ray tracing pipeline stack size in bytes for the specified shader as called from the specified shader group.

Valid Usage

- VUID-vkGetRayTracingShaderGroupStackSizeKHR-pipeline-04622
  `pipeline` must be a ray tracing pipeline

- VUID-vkGetRayTracingShaderGroupStackSizeKHR-group-03608
  The value of `group` must be less than the number of shader groups in `pipeline`

- VUID-vkGetRayTracingShaderGroupStackSizeKHR-groupShader-03609
  The shader identified by `groupShader` in `group` must not be `VK_SHADER_UNUSED_KHR`

Valid Usage (Implicit)

- VUID-vkGetRayTracingShaderGroupStackSizeKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetRayTracingShaderGroupStackSizeKHR-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

- VUID-vkGetRayTracingShaderGroupStackSizeKHR-groupShader-parameter
  `groupShader` must be a valid VkShaderGroupShaderKHR value

- VUID-vkGetRayTracingShaderGroupStackSizeKHR-pipeline-parent
  `pipeline` must have been created, allocated, or retrieved from `device`

Possible values of `groupShader` in vkGetRayTracingShaderGroupStackSizeKHR are:

    // Provided by VK_KHR_ray_tracing_pipeline
    typedef enum VkShaderGroupShaderKHR {
        VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0,
        VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1,
        VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2,
        VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3,
    } VkShaderGroupShaderKHR;

- `VK_SHADER_GROUP_SHADER_GENERAL_KHR` uses the shader specified in the group with VkRayTracingShaderGroupCreateInfoKHR::`generalShader`

- `VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR` uses the shader specified in the group with VkRayTracingShaderGroupCreateInfoKHR::`closestHitShader`

- `VK_SHADER_GROUP_SHADER_ANY_HIT_KHR` uses the shader specified in the group with VkRayTracingShaderGroupCreateInfoKHR::`anyHitShader`

- `VK_SHADER_GROUP_SHADER_INTERSECTION_KHR` uses the shader specified in the group with VkRayTracingShaderGroupCreateInfoKHR::`intersectionShader`

To dynamically set the stack size for a ray tracing pipeline, call:

    // Provided by VK_KHR_ray_tracing_pipeline
    void vkCmdSetRayTracingPipelineStackSizeKHR(
        VkCommandBuffer                             commandBuffer,
        uint32_t                                    pipelineStackSize);

- `commandBuffer` is the command buffer into which the command will be recorded.

- `pipelineStackSize` is the stack size to use for subsequent ray tracing trace commands.

This command sets the stack size for subsequent ray tracing commands when the ray tracing pipeline is created with `VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR` set in VkPipelineDynamicStateCreateInfo::`pDynamicStates`. Otherwise, the stack size is computed as described in Ray Tracing Pipeline Stack.

Valid Usage

- VUID-vkCmdSetRayTracingPipelineStackSizeKHR-pipelineStackSize-03610
  `pipelineStackSize` must be large enough for any dynamic execution through the shaders in the ray tracing pipeline used by a subsequent trace call

Valid Usage (Implicit)

- VUID-vkCmdSetRayTracingPipelineStackSizeKHR-commandBuffer-parameter
  `commandBuffer` must be a valid VkCommandBuffer handle

- VUID-vkCmdSetRayTracingPipelineStackSizeKHR-commandBuffer-recording
  `commandBuffer` must be in the recording state

- VUID-vkCmdSetRayTracingPipelineStackSizeKHR-commandBuffer-cmdpool
  The `VkCommandPool` that `commandBuffer` was allocated from must support compute operations

- VUID-vkCmdSetRayTracingPipelineStackSizeKHR-renderpass
  This command must only be called outside of a render pass instance

- VUID-vkCmdSetRayTracingPipelineStackSizeKHR-videocoding
  This command must only be called outside of a video coding scope

Host Synchronization

- Host access to `commandBuffer` must be externally synchronized

- Host access to the `VkCommandPool` that `commandBuffer` was allocated from must be externally synchronized

Command Properties

Command Buffer Levels | Render Pass Scope | Video Coding Scope | Supported Queue Types | Command Type
--- | --- | --- | --- | ---
Primary Secondary | Outside | Outside | Compute | State

### 10.5. Pipeline Destruction

To destroy a pipeline, call:

    // Provided by VK_VERSION_1_0
    void vkDestroyPipeline(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        const VkAllocationCallbacks*                pAllocator);

- `device` is the logical device that destroys the pipeline.

- `pipeline` is the handle of the pipeline to destroy.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

- VUID-vkDestroyPipeline-pipeline-00765
  All submitted commands that refer to `pipeline` must have completed execution

- VUID-vkDestroyPipeline-pipeline-00766
  If `VkAllocationCallbacks` were provided when `pipeline` was created, a compatible set of callbacks must be provided here

- VUID-vkDestroyPipeline-pipeline-00767
  If no `VkAllocationCallbacks` were provided when `pipeline` was created, `pAllocator` must be `NULL`

Valid Usage (Implicit)

- VUID-vkDestroyPipeline-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkDestroyPipeline-pipeline-parameter
  If `pipeline` is not VK_NULL_HANDLE, `pipeline` must be a valid VkPipeline handle

- VUID-vkDestroyPipeline-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

- VUID-vkDestroyPipeline-pipeline-parent
  If `pipeline` is a valid handle, it must have been created, allocated, or retrieved from `device`

Host Synchronization

- Host access to `pipeline` must be externally synchronized

### 10.6. Pipeline Derivatives

A pipeline derivative is a child pipeline created from a parent pipeline, where the child and parent are expected to have much commonality.

The goal of derivative pipelines is that they be cheaper to create using the parent as a starting point, and that it be more efficient (on either host or device) to switch/bind between children of the same parent.

A derivative pipeline is created by setting the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag in the `Vk*PipelineCreateInfo` structure. If this is set, then exactly one of `basePipelineHandle` or `basePipelineIndex` members of the structure must have a valid handle/index, and specifies the parent pipeline. If `basePipelineHandle` is used, the parent pipeline must have already been created. If `basePipelineIndex` is used, then the parent is being created in the same command. VK_NULL_HANDLE acts as the invalid handle for `basePipelineHandle`, and -1 is the invalid index for `basePipelineIndex`. If `basePipelineIndex` is used, the base pipeline must appear earlier in the array. The base pipeline must have been created with the `VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT` flag set.

### 10.7. Pipeline Cache

Pipeline cache objects allow the result of pipeline construction to be reused between pipelines and between runs of an application. Reuse between pipelines is achieved by passing the same pipeline cache object when creating multiple related pipelines. Reuse across runs of an application is achieved by retrieving pipeline cache contents in one run of an application, saving the contents, and using them to preinitialize a pipeline cache on a subsequent run. The contents of the pipeline cache objects are managed by the implementation. Applications can manage the host memory consumed by a pipeline cache object and control the amount of data retrieved from a pipeline cache object.

Pipeline cache objects are represented by `VkPipelineCache` handles:

    // Provided by VK_VERSION_1_0
    VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)

#### 10.7.1. Creating a Pipeline Cache

To create pipeline cache objects, call:

    // Provided by VK_VERSION_1_0
    VkResult vkCreatePipelineCache(
        VkDevice                                    device,
        const VkPipelineCacheCreateInfo*            pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkPipelineCache*                            pPipelineCache);

- `device` is the logical device that creates the pipeline cache object.

- `pCreateInfo` is a pointer to a VkPipelineCacheCreateInfo structure containing initial parameters for the pipeline cache object.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

- `pPipelineCache` is a pointer to a VkPipelineCache handle in which the resulting pipeline cache object is returned.

Note | Applications can track and manage the total host memory size of a pipeline cache object using the `pAllocator`. Applications can limit the amount of data retrieved from a pipeline cache object in `vkGetPipelineCacheData`. Implementations should not internally limit the total number of entries added to a pipeline cache object or the total host memory consumed.

Once created, a pipeline cache can be passed to the vkCreateGraphicsPipelines vkCreateRayTracingPipelinesKHR, vkCreateRayTracingPipelinesNV, and vkCreateComputePipelines commands. If the pipeline cache passed into these commands is not VK_NULL_HANDLE, the implementation will query it for possible reuse opportunities and update it with new content. The use of the pipeline cache object in these commands is internally synchronized, and the same pipeline cache object can be used in multiple threads simultaneously.

If `flags` of `pCreateInfo` includes `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT`, all commands that modify the returned pipeline cache object must be externally synchronized.

Note | Implementations should make every effort to limit any critical sections to the actual accesses to the cache, which is expected to be significantly shorter than the duration of the `vkCreate*Pipelines` commands.

Valid Usage (Implicit)

- VUID-vkCreatePipelineCache-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkCreatePipelineCache-pCreateInfo-parameter
  `pCreateInfo` must be a valid pointer to a valid VkPipelineCacheCreateInfo structure

- VUID-vkCreatePipelineCache-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

- VUID-vkCreatePipelineCache-pPipelineCache-parameter
  `pPipelineCache` must be a valid pointer to a VkPipelineCache handle

Return Codes

Success

  - `VK_SUCCESS`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

The `VkPipelineCacheCreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkPipelineCacheCreateInfo {
        VkStructureType               sType;
        const void*                   pNext;
        VkPipelineCacheCreateFlags    flags;
        size_t                        initialDataSize;
        const void*                   pInitialData;
    } VkPipelineCacheCreateInfo;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `flags` is a bitmask of VkPipelineCacheCreateFlagBits specifying the behavior of the pipeline cache.

- `initialDataSize` is the number of bytes in `pInitialData`. If `initialDataSize` is zero, the pipeline cache will initially be empty.

- `pInitialData` is a pointer to previously retrieved pipeline cache data. If the pipeline cache data is incompatible (as defined below) with the device, the pipeline cache will be initially empty. If `initialDataSize` is zero, `pInitialData` is ignored.

Valid Usage

- VUID-VkPipelineCacheCreateInfo-initialDataSize-00768
  If `initialDataSize` is not `0`, it must be equal to the size of `pInitialData`, as returned by `vkGetPipelineCacheData` when `pInitialData` was originally retrieved

- VUID-VkPipelineCacheCreateInfo-initialDataSize-00769
  If `initialDataSize` is not `0`, `pInitialData` must have been retrieved from a previous call to `vkGetPipelineCacheData`

- VUID-VkPipelineCacheCreateInfo-pipelineCreationCacheControl-02892
  If the `pipelineCreationCacheControl` feature is not enabled, `flags` must not include `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT`

Valid Usage (Implicit)

- VUID-VkPipelineCacheCreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO`

- VUID-VkPipelineCacheCreateInfo-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkPipelineCacheCreateInfo-flags-parameter
  `flags` must be a valid combination of VkPipelineCacheCreateFlagBits values

- VUID-VkPipelineCacheCreateInfo-pInitialData-parameter
  If `initialDataSize` is not `0`, `pInitialData` must be a valid pointer to an array of `initialDataSize` bytes

    // Provided by VK_VERSION_1_0
    typedef VkFlags VkPipelineCacheCreateFlags;

`VkPipelineCacheCreateFlags` is a bitmask type for setting a mask of zero or more VkPipelineCacheCreateFlagBits.

Bits which can be set in VkPipelineCacheCreateInfo::`flags`, specifying behavior of the pipeline cache, are:

    // Provided by VK_EXT_pipeline_creation_cache_control
    typedef enum VkPipelineCacheCreateFlagBits {
      // Provided by VK_VERSION_1_3
        VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
      // Provided by VK_EXT_pipeline_creation_cache_control
        VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
    } VkPipelineCacheCreateFlagBits;

- `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT` specifies that all commands that modify the created VkPipelineCache will be externally synchronized. When set, the implementation may skip any unnecessary processing needed to support simultaneous modification from multiple threads where allowed.

#### 10.7.2. Merging Pipeline Caches

Pipeline cache objects can be merged using the command:

    // Provided by VK_VERSION_1_0
    VkResult vkMergePipelineCaches(
        VkDevice                                    device,
        VkPipelineCache                             dstCache,
        uint32_t                                    srcCacheCount,
        const VkPipelineCache*                      pSrcCaches);

- `device` is the logical device that owns the pipeline cache objects.

- `dstCache` is the handle of the pipeline cache to merge results into.

- `srcCacheCount` is the length of the `pSrcCaches` array.

- `pSrcCaches` is a pointer to an array of pipeline cache handles, which will be merged into `dstCache`. The previous contents of `dstCache` are included after the merge.

Note | The details of the merge operation are implementation-dependent, but implementations should merge the contents of the specified pipelines and prune duplicate entries.

Valid Usage

- VUID-vkMergePipelineCaches-dstCache-00770
  `dstCache` must not appear in the list of source caches

Valid Usage (Implicit)

- VUID-vkMergePipelineCaches-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkMergePipelineCaches-dstCache-parameter
  `dstCache` must be a valid VkPipelineCache handle

- VUID-vkMergePipelineCaches-pSrcCaches-parameter
  `pSrcCaches` must be a valid pointer to an array of `srcCacheCount` valid VkPipelineCache handles

- VUID-vkMergePipelineCaches-srcCacheCount-arraylength
  `srcCacheCount` must be greater than `0`

- VUID-vkMergePipelineCaches-dstCache-parent
  `dstCache` must have been created, allocated, or retrieved from `device`

- VUID-vkMergePipelineCaches-pSrcCaches-parent
  Each element of `pSrcCaches` must have been created, allocated, or retrieved from `device`

Host Synchronization

- Host access to `dstCache` must be externally synchronized

Return Codes

Success

  - `VK_SUCCESS`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

#### 10.7.3. Retrieving Pipeline Cache Data

Data can be retrieved from a pipeline cache object using the command:

    // Provided by VK_VERSION_1_0
    VkResult vkGetPipelineCacheData(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        size_t*                                     pDataSize,
        void*                                       pData);

- `device` is the logical device that owns the pipeline cache.

- `pipelineCache` is the pipeline cache to retrieve data from.

- `pDataSize` is a pointer to a `size_t` value related to the amount of data in the pipeline cache, as described below.

- `pData` is either `NULL` or a pointer to a buffer.

If `pData` is `NULL`, then the maximum size of the data that can be retrieved from the pipeline cache, in bytes, is returned in `pDataSize`. Otherwise, `pDataSize` must point to a variable set by the application to the size of the buffer, in bytes, pointed to by `pData`, and on return the variable is overwritten with the amount of data actually written to `pData`. If `pDataSize` is less than the maximum size that can be retrieved by the pipeline cache, at most `pDataSize` bytes will be written to `pData`, and `VK_INCOMPLETE` will be returned instead of `VK_SUCCESS`, to indicate that not all of the pipeline cache was returned.

Any data written to `pData` is valid and can be provided as the `pInitialData` member of the VkPipelineCacheCreateInfo structure passed to `vkCreatePipelineCache`.

Two calls to `vkGetPipelineCacheData` with the same parameters must retrieve the same data unless a command that modifies the contents of the cache is called between them.

The initial bytes written to `pData` must be a header as described in the Pipeline Cache Header section.

If `pDataSize` is less than what is necessary to store this header, nothing will be written to `pData` and zero will be written to `pDataSize`.

Valid Usage (Implicit)

- VUID-vkGetPipelineCacheData-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetPipelineCacheData-pipelineCache-parameter
  `pipelineCache` must be a valid VkPipelineCache handle

- VUID-vkGetPipelineCacheData-pDataSize-parameter
  `pDataSize` must be a valid pointer to a `size_t` value

- VUID-vkGetPipelineCacheData-pData-parameter
  If the value referenced by `pDataSize` is not `0`, and `pData` is not `NULL`, `pData` must be a valid pointer to an array of `pDataSize` bytes

- VUID-vkGetPipelineCacheData-pipelineCache-parent
  `pipelineCache` must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_INCOMPLETE`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

#### 10.7.4. Pipeline Cache Header

Applications can store the data retrieved from the pipeline cache, and use these data, possibly in a future run of the application, to populate new pipeline cache objects. The results of pipeline compiles, however, may depend on the vendor ID, device ID, driver version, and other details of the device. To enable applications to detect when previously retrieved data is incompatible with the device, the pipeline cache data must begin with a valid pipeline cache header.

Note | Structures described in this section are not part of the Vulkan API and are only used to describe the representation of data elements in pipeline cache data. Accordingly, the valid usage clauses defined for structures defined in this section do not define valid usage conditions for APIs accepting pipeline cache data as input, as providing invalid pipeline cache data as input to any Vulkan API commands will result in the provided pipeline cache data being ignored.

Version one of the pipeline cache header is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkPipelineCacheHeaderVersionOne {
        uint32_t                        headerSize;
        VkPipelineCacheHeaderVersion    headerVersion;
        uint32_t                        vendorID;
        uint32_t                        deviceID;
        uint8_t                         pipelineCacheUUID[VK_UUID_SIZE];
    } VkPipelineCacheHeaderVersionOne;

- `headerSize` is the length in bytes of the pipeline cache header.

- `headerVersion` is a VkPipelineCacheHeaderVersion value specifying the version of the header. A consumer of the pipeline cache should use the cache version to interpret the remainder of the cache header.

- `vendorID` is the `VkPhysicalDeviceProperties`::`vendorID` of the implementation.

- `deviceID` is the `VkPhysicalDeviceProperties`::`deviceID` of the implementation.

- `pipelineCacheUUID` is the `VkPhysicalDeviceProperties`::`pipelineCacheUUID` of the implementation.

Unlike most structures declared by the Vulkan API, all fields of this structure are written with the least significant byte first, regardless of host byte-order.

The C language specification does not define the packing of structure members. This layout assumes tight structure member packing, with members laid out in the order listed in the structure, and the intended size of the structure is 32 bytes. If a compiler produces code that diverges from that pattern, applications must employ another method to set values at the correct offsets.

Valid Usage

- VUID-VkPipelineCacheHeaderVersionOne-headerSize-04967
  `headerSize` must be 32

- VUID-VkPipelineCacheHeaderVersionOne-headerVersion-04968
  `headerVersion` must be `VK_PIPELINE_CACHE_HEADER_VERSION_ONE`

- VUID-VkPipelineCacheHeaderVersionOne-headerSize-08990
  `headerSize` must not exceed the size of the pipeline cache

Valid Usage (Implicit)

- VUID-VkPipelineCacheHeaderVersionOne-headerVersion-parameter
  `headerVersion` must be a valid VkPipelineCacheHeaderVersion value

Possible values of the `headerVersion` value of the pipeline cache header are:

    // Provided by VK_VERSION_1_0
    typedef enum VkPipelineCacheHeaderVersion {
        VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
    } VkPipelineCacheHeaderVersion;

- `VK_PIPELINE_CACHE_HEADER_VERSION_ONE` specifies version one of the pipeline cache, described by VkPipelineCacheHeaderVersionOne.

#### 10.7.5. Destroying a Pipeline Cache

To destroy a pipeline cache, call:

    // Provided by VK_VERSION_1_0
    void vkDestroyPipelineCache(
        VkDevice                                    device,
        VkPipelineCache                             pipelineCache,
        const VkAllocationCallbacks*                pAllocator);

- `device` is the logical device that destroys the pipeline cache object.

- `pipelineCache` is the handle of the pipeline cache to destroy.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

- VUID-vkDestroyPipelineCache-pipelineCache-00771
  If `VkAllocationCallbacks` were provided when `pipelineCache` was created, a compatible set of callbacks must be provided here

- VUID-vkDestroyPipelineCache-pipelineCache-00772
  If no `VkAllocationCallbacks` were provided when `pipelineCache` was created, `pAllocator` must be `NULL`

Valid Usage (Implicit)

- VUID-vkDestroyPipelineCache-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkDestroyPipelineCache-pipelineCache-parameter
  If `pipelineCache` is not VK_NULL_HANDLE, `pipelineCache` must be a valid VkPipelineCache handle

- VUID-vkDestroyPipelineCache-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

- VUID-vkDestroyPipelineCache-pipelineCache-parent
  If `pipelineCache` is a valid handle, it must have been created, allocated, or retrieved from `device`

Host Synchronization

- Host access to `pipelineCache` must be externally synchronized

### 10.8. Pipeline Binaries

Pipeline binary objects allow the result of pipeline construction to be reused between pipelines and between runs of an application. Reuse is achieved by extracting pipeline binaries from a VkPipeline object, associating them with a corresponding VkPipelineBinaryKeyKHR and then adding a VkPipelineBinaryInfoKHR to the `pNext` chain of any `Vk*PipelineCreateInfo` when creating a pipeline. Pipeline binaries can be reused between runs by extracting `VkPipelineBinaryDataKHR` from `VkPipelineBinaryKHR` objects, saving the contents, and then using them to create a `VkPipelineBinaryKHR` object on subsequent runs.

When creating a pipeline that includes VkPipelineBinaryInfoKHR in the `pNext` chain, or has the `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` flag set, the use of VkPipelineCache objects is not allowed.

Pipeline binary objects are represented by `VkPipelineBinaryKHR` handles:

    // Provided by VK_KHR_pipeline_binary
    VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineBinaryKHR)

#### 10.8.1. Generating the Pipeline Key

To generate the key for a particular pipeline creation info, call:

    // Provided by VK_KHR_pipeline_binary
    VkResult vkGetPipelineKeyKHR(
        VkDevice                                    device,
        const VkPipelineCreateInfoKHR*              pPipelineCreateInfo,
        VkPipelineBinaryKeyKHR*                     pPipelineKey);

- `device` is the logical device that creates the pipeline object.

- `pPipelineCreateInfo` is `NULL` or a pointer to a VkPipelineCreateInfoKHR structure.

- `pPipelineKey` is a pointer to a VkPipelineBinaryKeyKHR structure in which the resulting key is returned.

If `pPipelineCreateInfo` is `NULL`, then the implementation must return the global key that applies to all pipelines. If the key obtained in this way changes between saving and restoring data obtained from vkGetPipelineBinaryDataKHR in a different VkDevice, then the application must assume that the restored data is invalid and cannot be passed to vkCreatePipelineBinariesKHR. Otherwise the application can assume the data is still valid.

If `pPipelineCreateInfo` is not `NULL`, the key obtained functions as a method to compare two pipeline creation info structures. Implementations may not compare parts of a pipeline creation info which would not contribute to the final binary output. If a shader module identifier is used instead of a shader module, the `pPipelineKey` generated must be equal to the key generated when using the shader module from which the identifier was queried. If the content of two `pPipelineKey` are equal, pipelines created with the two `pPipelineCreateInfo->pname`:pNext create infos must produce the same VkPipelineBinaryKHR contents.

The pipeline key is distinct from pipeline binary key. Pipeline binary keys can only be obtained after compilation. The pipeline key is intended to optionally allow associating pipeline create info with multiple pipeline binary keys.

Valid Usage

- VUID-vkGetPipelineKeyKHR-pNext-09605
  The `pNext` chain of `pPipelineCreateInfo` must not set VkPipelineBinaryInfoKHR::`binaryCount` to a value greater than `0`

Valid Usage (Implicit)

- VUID-vkGetPipelineKeyKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetPipelineKeyKHR-pPipelineCreateInfo-parameter
  If `pPipelineCreateInfo` is not `NULL`, `pPipelineCreateInfo` must be a valid pointer to a valid VkPipelineCreateInfoKHR structure

- VUID-vkGetPipelineKeyKHR-pPipelineKey-parameter
  `pPipelineKey` must be a valid pointer to a VkPipelineBinaryKeyKHR structure

Return Codes

Success

  - `VK_SUCCESS`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

The `VkPipelineCreateInfoKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_binary
    typedef struct VkPipelineCreateInfoKHR {
        VkStructureType    sType;
        void*              pNext;
    } VkPipelineCreateInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is a pointer to a structure extending this structure.

Valid Usage

- VUID-VkPipelineCreateInfoKHR-pNext-09604
  `pNext` must be pointer to a valid instance of VkGraphicsPipelineCreateInfo, VkExecutionGraphPipelineCreateInfoAMDX, VkRayTracingPipelineCreateInfoKHR, or VkComputePipelineCreateInfo

Valid Usage (Implicit)

- VUID-VkPipelineCreateInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR`

The `VkPipelineBinaryKeyKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_binary
    typedef struct VkPipelineBinaryKeyKHR {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           keySize;
        uint8_t            key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR];
    } VkPipelineBinaryKeyKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `keySize` is the size, in bytes, of valid data returned in `key`.

- `key` is a buffer of opaque data specifying a pipeline binary key.

Any returned values beyond the first `keySize` bytes are undefined. Implementations must return a `keySize` greater than 0, and less-or-equal to `VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR`.

Two keys are considered equal if `keySize` is equal and the first `keySize` bytes of `key` compare equal.

Implementations may return a different `keySize` for different binaries.

Implementations should ensure that `keySize` is large enough to uniquely identify a pipeline binary.

Valid Usage (Implicit)

- VUID-VkPipelineBinaryKeyKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR`

- VUID-VkPipelineBinaryKeyKHR-pNext-pNext
  `pNext` must be `NULL`

`VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR` is the length in bytes of a binary key, as returned in VkPipelineBinaryKeyKHR::`keySize`.

    #define VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR 32U

#### 10.8.2. Creating Pipeline Binaries

To create pipeline binary objects, call:

    // Provided by VK_KHR_pipeline_binary
    VkResult vkCreatePipelineBinariesKHR(
        VkDevice                                    device,
        const VkPipelineBinaryCreateInfoKHR*        pCreateInfo,
        const VkAllocationCallbacks*                pAllocator,
        VkPipelineBinaryHandlesInfoKHR*             pBinaries);

- `device` is the logical device that creates the pipeline binary objects.

- `pCreateInfo` is a pointer to a VkPipelineBinaryCreateInfoKHR structure that contains the data to create the pipeline binaries from.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

- `pBinaries` is a pointer to a VkPipelineBinaryHandlesInfoKHR structure in which the resulting pipeline binaries are returned.

The implementation will attempt to create all pipeline binaries. If creation fails for any pipeline binary, then:

- The corresponding entry in the `pPipelineBinaries` output array will be filled with VK_NULL_HANDLE.

- The `VkResult` returned by vkCreatePipelineBinariesKHR will contain the error value for the first entry in the output array in `pBinaries` containing VK_NULL_HANDLE.

Valid Usage (Implicit)

- VUID-vkCreatePipelineBinariesKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkCreatePipelineBinariesKHR-pCreateInfo-parameter
  `pCreateInfo` must be a valid pointer to a valid VkPipelineBinaryCreateInfoKHR structure

- VUID-vkCreatePipelineBinariesKHR-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

- VUID-vkCreatePipelineBinariesKHR-pBinaries-parameter
  `pBinaries` must be a valid pointer to a VkPipelineBinaryHandlesInfoKHR structure

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_INCOMPLETE`

  - `VK_PIPELINE_BINARY_MISSING_KHR`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

  - `VK_ERROR_INITIALIZATION_FAILED`

The `VkPipelineBinaryHandlesInfoKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_binary
    typedef struct VkPipelineBinaryHandlesInfoKHR {
        VkStructureType         sType;
        const void*             pNext;
        uint32_t                pipelineBinaryCount;
        VkPipelineBinaryKHR*    pPipelineBinaries;
    } VkPipelineBinaryHandlesInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `pipelineBinaryCount` is the number of binaries associated with this pipeline or the number of entries in the `pPipelineBinaries` array.

- `pPipelineBinaries` is `NULL` or a pointer to an array of VkPipelineBinaryKHR handles in which the resulting pipeline binaries are returned.

If `pPipelineBinaries` is `NULL`, the number of binaries that would be created is returned in `pipelineBinaryCount`. Otherwise, `pipelineBinaryCount` must be the number of entries in the `pPipelineBinaries` array, and on return from vkCreatePipelineBinariesKHR `pipelineBinaryCount` is overwritten with the number of handles actually written to `pPipelineBinaries`. If the value of `pipelineBinaryCount` is less than the number of binaries that would have been created, at most `pipelineBinaryCount` handles will be written to `pPipelineBinaries` and `VK_INCOMPLETE` will be returned instead of `VK_SUCCESS`, to indicate that `pPipelineBinaries` was not large enough to create all the binaries.

Valid Usage (Implicit)

- VUID-VkPipelineBinaryHandlesInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR`

- VUID-VkPipelineBinaryHandlesInfoKHR-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkPipelineBinaryHandlesInfoKHR-pPipelineBinaries-parameter
  If `pipelineBinaryCount` is not `0`, and `pPipelineBinaries` is not `NULL`, `pPipelineBinaries` must be a valid pointer to an array of `pipelineBinaryCount` VkPipelineBinaryKHR handles

The `VkPipelineBinaryCreateInfoKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_binary
    typedef struct VkPipelineBinaryCreateInfoKHR {
        VkStructureType                          sType;
        const void*                              pNext;
        const VkPipelineBinaryKeysAndDataKHR*    pKeysAndDataInfo;
        VkPipeline                               pipeline;
        const VkPipelineCreateInfoKHR*           pPipelineCreateInfo;
    } VkPipelineBinaryCreateInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `pKeysAndDataInfo` is `NULL` or a pointer to a VkPipelineBinaryKeysAndDataKHR structure that contains keys and data to create the pipeline binaries from.

- `pipeline` is VK_NULL_HANDLE or a `VkPipeline` that contains data to create the pipeline binaries from.

- `pPipelineCreateInfo` is `NULL` or a pointer to a VkPipelineCreateInfoKHR structure with the pipeline creation info. This is used to probe the implementation’s internal cache for pipeline binaries.

When `pPipelineCreateInfo` is not `NULL`, an implementation will attempt to retrieve pipeline binary data from an internal cache external to the application if `pipelineBinaryInternalCache` is `VK_TRUE`. Applications can use this to determine if a pipeline can be created without compilation. If the implementation fails to create a pipeline binary due to missing an internal cache entry, `VK_PIPELINE_BINARY_MISSING_KHR` is returned. If creation succeeds, the resulting binary can be used to create a pipeline. `VK_PIPELINE_BINARY_MISSING_KHR` may be returned for any reason in this situation, even if creating a pipeline binary with the same parameters that succeeded earlier.

If `pipelineBinaryPrecompiledInternalCache` is `VK_TRUE`, the implementation may be able to create pipeline binaries even when `pPipelineCreateInfo` has not been used to create binaries before by the application.

Note | On some platforms, internal pipeline caches may be pre-populated before running the application.

Valid Usage

- VUID-VkPipelineBinaryCreateInfoKHR-pipeline-09607
  If `pipeline` is not VK_NULL_HANDLE, `pipeline` must have been created with `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR`

- VUID-VkPipelineBinaryCreateInfoKHR-pipeline-09608
  If `pipeline` is not VK_NULL_HANDLE, vkReleaseCapturedPipelineDataKHR must not have been called on `pipeline` prior to this command

- VUID-VkPipelineBinaryCreateInfoKHR-pipelineBinaryInternalCache-09609
  If `pipelineBinaryInternalCache` is `VK_FALSE` pPipelineCreateInfo must be `NULL`

- VUID-VkPipelineBinaryCreateInfoKHR-device-09610
  If `device` was created with VkDevicePipelineBinaryInternalCacheControlKHR::`disableInternalCache` set to `VK_TRUE`, `pPipelineCreateInfo` must be `NULL`

- VUID-VkPipelineBinaryCreateInfoKHR-pKeysAndDataInfo-09619
  One and only one of `pKeysAndDataInfo`, `pipeline`, or `pPipelineCreateInfo` must be non-`NULL`

- VUID-VkPipelineBinaryCreateInfoKHR-pPipelineCreateInfo-09606
  If `pPipelineCreateInfo` is not `NULL`, the `pNext` chain of `pPipelineCreateInfo` must not set VkPipelineBinaryInfoKHR::`binaryCount` to a value greater than `0`

Valid Usage (Implicit)

- VUID-VkPipelineBinaryCreateInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR`

- VUID-VkPipelineBinaryCreateInfoKHR-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkPipelineBinaryCreateInfoKHR-pKeysAndDataInfo-parameter
  If `pKeysAndDataInfo` is not `NULL`, `pKeysAndDataInfo` must be a valid pointer to a valid VkPipelineBinaryKeysAndDataKHR structure

- VUID-VkPipelineBinaryCreateInfoKHR-pipeline-parameter
  If `pipeline` is not VK_NULL_HANDLE, `pipeline` must be a valid VkPipeline handle

- VUID-VkPipelineBinaryCreateInfoKHR-pPipelineCreateInfo-parameter
  If `pPipelineCreateInfo` is not `NULL`, `pPipelineCreateInfo` must be a valid pointer to a valid VkPipelineCreateInfoKHR structure

The `VkPipelineBinaryKeysAndDataKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_binary
    typedef struct VkPipelineBinaryKeysAndDataKHR {
        uint32_t                          binaryCount;
        const VkPipelineBinaryKeyKHR*     pPipelineBinaryKeys;
        const VkPipelineBinaryDataKHR*    pPipelineBinaryData;
    } VkPipelineBinaryKeysAndDataKHR;

- `binaryCount` is the size of the `pPipelineBinaryKeys` and `pPipelineBinaryData` arrays

- `pPipelineBinaryKeys` is a pointer to an array of VkPipelineBinaryKeyKHR structures containing the pipeline binary keys

- `pPipelineBinaryData` is a pointer to an array of VkPipelineBinaryDataKHR structures containing the pipeline binary data

Valid Usage (Implicit)

- VUID-VkPipelineBinaryKeysAndDataKHR-pPipelineBinaryKeys-parameter
  `pPipelineBinaryKeys` must be a valid pointer to an array of `binaryCount` valid VkPipelineBinaryKeyKHR structures

- VUID-VkPipelineBinaryKeysAndDataKHR-pPipelineBinaryData-parameter
  `pPipelineBinaryData` must be a valid pointer to an array of `binaryCount` valid VkPipelineBinaryDataKHR structures

- VUID-VkPipelineBinaryKeysAndDataKHR-binaryCount-arraylength
  `binaryCount` must be greater than `0`

The `VkPipelineBinaryDataKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_binary
    typedef struct VkPipelineBinaryDataKHR {
        size_t    dataSize;
        void*     pData;
    } VkPipelineBinaryDataKHR;

- `dataSize` is the size of the `pData` buffer in bytes.

- `pData` is a pointer to a buffer of `size` bytes that contains pipeline binary data obtained from `vkGetPipelineBinaryDataKHR`.

Valid Usage (Implicit)

- VUID-VkPipelineBinaryDataKHR-pData-parameter
  `pData` must be a valid pointer to an array of `dataSize` bytes

- VUID-VkPipelineBinaryDataKHR-dataSize-arraylength
  `dataSize` must be greater than `0`

#### 10.8.3. Retrieving Pipeline Binary Data

Data can be retrieved from a pipeline binary object using the command:

    // Provided by VK_KHR_pipeline_binary
    VkResult vkGetPipelineBinaryDataKHR(
        VkDevice                                    device,
        const VkPipelineBinaryDataInfoKHR*          pInfo,
        VkPipelineBinaryKeyKHR*                     pPipelineBinaryKey,
        size_t*                                     pPipelineBinaryDataSize,
        void*                                       pPipelineBinaryData);

- `device` is the logical device that created the pipeline binary.

- `pInfo` is a pointer to a VkPipelineBinaryDataInfoKHR structure which describes the pipeline binary to get data from.

- `pPipelineBinaryKey` is a pointer to a VkPipelineBinaryKeyKHR structure where the key for this binary will be written.

- `pPipelineBinaryDataSize` is a pointer to a `size_t` value related to the amount of data in the pipeline binary, as described below.

- `pPipelineBinaryData` is either `NULL` or a pointer to a buffer.

If `pPipelineBinaryData` is `NULL`, then the size of the data, in bytes, that is required to store the binary is returned in `pPipelineBinaryDataSize`. Otherwise, `pPipelineBinaryDataSize` must contain the size of the buffer, in bytes, pointed to by `pPipelineBinaryData`, and on return `pPipelineBinaryDataSize` is overwritten with the size of the data, in bytes, that is required to store the binary. If `pPipelineBinaryDataSize` is less than the size that is required to store the binary, nothing is written to `pPipelineBinaryData` and `VK_ERROR_NOT_ENOUGH_SPACE_KHR` will be returned, instead of `VK_SUCCESS`.

If the call returns one of the success return codes, the pipeline binary key is written to `pPipelineBinaryKey`, regardless of whether `pPipelineBinaryData` is `NULL` or not.

If pipelineBinaryCompressedData is `VK_FALSE`, implementations should not return compressed pipeline binary data to the application.

Valid Usage (Implicit)

- VUID-vkGetPipelineBinaryDataKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetPipelineBinaryDataKHR-pInfo-parameter
  `pInfo` must be a valid pointer to a valid VkPipelineBinaryDataInfoKHR structure

- VUID-vkGetPipelineBinaryDataKHR-pPipelineBinaryKey-parameter
  `pPipelineBinaryKey` must be a valid pointer to a VkPipelineBinaryKeyKHR structure

- VUID-vkGetPipelineBinaryDataKHR-pPipelineBinaryDataSize-parameter
  `pPipelineBinaryDataSize` must be a valid pointer to a `size_t` value

- VUID-vkGetPipelineBinaryDataKHR-pPipelineBinaryData-parameter
  If the value referenced by `pPipelineBinaryDataSize` is not `0`, and `pPipelineBinaryData` is not `NULL`, `pPipelineBinaryData` must be a valid pointer to an array of `pPipelineBinaryDataSize` bytes

Return Codes

Success

  - `VK_SUCCESS`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

  - `VK_ERROR_NOT_ENOUGH_SPACE_KHR`

The `VkPipelineBinaryDataInfoKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_binary
    typedef struct VkPipelineBinaryDataInfoKHR {
        VkStructureType        sType;
        void*                  pNext;
        VkPipelineBinaryKHR    pipelineBinary;
    } VkPipelineBinaryDataInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `pipelineBinary` is the pipeline binary to get data from.

Valid Usage (Implicit)

- VUID-VkPipelineBinaryDataInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR`

- VUID-VkPipelineBinaryDataInfoKHR-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkPipelineBinaryDataInfoKHR-pipelineBinary-parameter
  `pipelineBinary` must be a valid VkPipelineBinaryKHR handle

#### 10.8.4. Releasing Captured Pipeline Binary Data

To release pipeline resources captured with `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR`, call:

    // Provided by VK_KHR_pipeline_binary
    VkResult vkReleaseCapturedPipelineDataKHR(
        VkDevice                                    device,
        const VkReleaseCapturedPipelineDataInfoKHR* pInfo,
        const VkAllocationCallbacks*                pAllocator);

- `device` is the logical device that created the pipeline object.

- `pInfo` is a pointer to a VkReleaseCapturedPipelineDataInfoKHR structure which describes the pipeline to release the data from.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

The implementation may free any resources captured as a result of creating the pipeline with `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` and put the pipeline into a state as if `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` had not been provided at pipeline creation time.

Note | Any resources captured as a result of creating the pipeline with `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR` are implicitly freed by vkDestroyPipeline.

Valid Usage

- VUID-vkReleaseCapturedPipelineDataKHR-pipeline-09611
  If `VkAllocationCallbacks` were provided when `pipeline` was created, a compatible set of callbacks must be provided in `pAllocator`

- VUID-vkReleaseCapturedPipelineDataKHR-pipeline-09612
  If no VkAllocationCallbacks were provided when `pipeline` was created, `pAllocator` must be `NULL`

Valid Usage (Implicit)

- VUID-vkReleaseCapturedPipelineDataKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkReleaseCapturedPipelineDataKHR-pInfo-parameter
  `pInfo` must be a valid pointer to a valid VkReleaseCapturedPipelineDataInfoKHR structure

- VUID-vkReleaseCapturedPipelineDataKHR-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

Host Synchronization

- Host access to `pInfo->pipeline` must be externally synchronized

Return Codes

Success

  - `VK_SUCCESS`

Failure

  None

The `VkReleaseCapturedPipelineDataInfoKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_binary
    typedef struct VkReleaseCapturedPipelineDataInfoKHR {
        VkStructureType    sType;
        void*              pNext;
        VkPipeline         pipeline;
    } VkReleaseCapturedPipelineDataInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `pipeline` the handle of the pipeline object to release the data from.

Valid Usage

- VUID-VkReleaseCapturedPipelineDataInfoKHR-pipeline-09613
  `pipeline` must have been created with `VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR`

- VUID-VkReleaseCapturedPipelineDataInfoKHR-pipeline-09618
  `pipeline` must not have been used in a previous call to `vkReleaseCapturedPipelineDataKHR`

Valid Usage (Implicit)

- VUID-VkReleaseCapturedPipelineDataInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR`

- VUID-VkReleaseCapturedPipelineDataInfoKHR-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkReleaseCapturedPipelineDataInfoKHR-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

#### 10.8.5. Destroying Pipeline Binaries

To destroy a VkPipelineBinaryKHR, call:

    // Provided by VK_KHR_pipeline_binary
    void vkDestroyPipelineBinaryKHR(
        VkDevice                                    device,
        VkPipelineBinaryKHR                         pipelineBinary,
        const VkAllocationCallbacks*                pAllocator);

- `device` is the logical device that created the pipeline binary object.

- `pipelineBinary` is the handle of the pipeline binary object to destroy.

- `pAllocator` controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

- VUID-vkDestroyPipelineBinaryKHR-pipelineBinary-09614
  If `VkAllocationCallbacks` were provided when `pipelineBinary` was created, a compatible set of callbacks must be provided here

- VUID-vkDestroyPipelineBinaryKHR-pipelineBinary-09615
  If no VkAllocationCallbacks were provided when `pipelineBinary` was created, `pAllocator` must be `NULL`

Valid Usage (Implicit)

- VUID-vkDestroyPipelineBinaryKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkDestroyPipelineBinaryKHR-pipelineBinary-parameter
  If `pipelineBinary` is not VK_NULL_HANDLE, `pipelineBinary` must be a valid VkPipelineBinaryKHR handle

- VUID-vkDestroyPipelineBinaryKHR-pAllocator-parameter
  If `pAllocator` is not `NULL`, `pAllocator` must be a valid pointer to a valid VkAllocationCallbacks structure

- VUID-vkDestroyPipelineBinaryKHR-pipelineBinary-parent
  If `pipelineBinary` is a valid handle, it must have been created, allocated, or retrieved from `device`

Host Synchronization

- Host access to `pipelineBinary` must be externally synchronized

### 10.9. Specialization Constants

Specialization constants are a mechanism whereby constants in a SPIR-V module can have their constant value specified at the time the `VkPipeline` is created. This allows a SPIR-V module to have constants that can be modified while executing an application that uses the Vulkan API.

Note | Specialization constants are useful to allow a compute shader to have its local workgroup size changed at runtime by the user, for example.

Each VkPipelineShaderStageCreateInfo structure contains a `pSpecializationInfo` member, which can be `NULL` to indicate no specialization constants, or point to a `VkSpecializationInfo` structure.

The `VkSpecializationInfo` structure is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkSpecializationInfo {
        uint32_t                           mapEntryCount;
        const VkSpecializationMapEntry*    pMapEntries;
        size_t                             dataSize;
        const void*                        pData;
    } VkSpecializationInfo;

- `mapEntryCount` is the number of entries in the `pMapEntries` array.

- `pMapEntries` is a pointer to an array of `VkSpecializationMapEntry` structures, which map constant IDs to offsets in `pData`.

- `dataSize` is the byte size of the `pData` buffer.

- `pData` contains the actual constant values to specialize with.

Valid Usage

- VUID-VkSpecializationInfo-offset-00773
  The `offset` member of each element of `pMapEntries` must be less than `dataSize`

- VUID-VkSpecializationInfo-pMapEntries-00774
  The `size` member of each element of `pMapEntries` must be less than or equal to `dataSize` minus `offset`

- VUID-VkSpecializationInfo-constantID-04911
  The `constantID` value of each element of `pMapEntries` must be unique within `pMapEntries`

Valid Usage (Implicit)

- VUID-VkSpecializationInfo-pMapEntries-parameter
  If `mapEntryCount` is not `0`, `pMapEntries` must be a valid pointer to an array of `mapEntryCount` valid VkSpecializationMapEntry structures

- VUID-VkSpecializationInfo-pData-parameter
  If `dataSize` is not `0`, `pData` must be a valid pointer to an array of `dataSize` bytes

The `VkSpecializationMapEntry` structure is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkSpecializationMapEntry {
        uint32_t    constantID;
        uint32_t    offset;
        size_t      size;
    } VkSpecializationMapEntry;

- `constantID` is the ID of the specialization constant in SPIR-V.

- `offset` is the byte offset of the specialization constant value within the supplied data buffer.

- `size` is the byte size of the specialization constant value within the supplied data buffer.

If a `constantID` value is not a specialization constant ID used in the shader, that map entry does not affect the behavior of the pipeline.

Valid Usage

- VUID-VkSpecializationMapEntry-constantID-00776
  For a `constantID` specialization constant declared in a shader, `size` must match the byte size of the `constantID`. If the specialization constant is of type `boolean`, `size` must be the byte size of VkBool32

In human readable SPIR-V:

    OpDecorate %x SpecId 13 ; decorate .x component of WorkgroupSize with ID 13
    OpDecorate %y SpecId 42 ; decorate .y component of WorkgroupSize with ID 42
    OpDecorate %z SpecId 3  ; decorate .z component of WorkgroupSize with ID 3
    OpDecorate %wgsize BuiltIn WorkgroupSize ; decorate WorkgroupSize onto constant
    %i32 = OpTypeInt 32 0 ; declare an unsigned 32-bit type
    %uvec3 = OpTypeVector %i32 3 ; declare a 3 element vector type of unsigned 32-bit
    %x = OpSpecConstant %i32 1 ; declare the .x component of WorkgroupSize
    %y = OpSpecConstant %i32 1 ; declare the .y component of WorkgroupSize
    %z = OpSpecConstant %i32 1 ; declare the .z component of WorkgroupSize
    %wgsize = OpSpecConstantComposite %uvec3 %x %y %z ; declare WorkgroupSize

From the above we have three specialization constants, one for each of the x, y and z elements of the WorkgroupSize vector.

Now to specialize the above via the specialization constants mechanism:

    const VkSpecializationMapEntry entries[] =
    {
        {
            .constantID = 13,
            .offset = 0 * sizeof(uint32_t),
            .size = sizeof(uint32_t)
        },
        {
            .constantID = 42,
            .offset = 1 * sizeof(uint32_t),
            .size = sizeof(uint32_t)
        },
        {
            .constantID = 3,
            .offset = 2 * sizeof(uint32_t),
            .size = sizeof(uint32_t)
        }
    };

    const uint32_t data[] = { 16, 8, 4 }; // our workgroup size is 16x8x4

    const VkSpecializationInfo info =
    {
        .mapEntryCount = 3,
        .pMapEntries  = entries,
        .dataSize = 3 * sizeof(uint32_t),
        .pData = data,
    };

Then when calling vkCreateComputePipelines, and passing the `VkSpecializationInfo` we defined as the `pSpecializationInfo` parameter of VkPipelineShaderStageCreateInfo, we will create a compute pipeline with the runtime specified local workgroup size.

Another example would be that an application has a SPIR-V module that has some platform-dependent constants they wish to use.

In human readable SPIR-V:

    OpDecorate %1 SpecId 0  ; decorate our signed 32-bit integer constant
    OpDecorate %2 SpecId 12 ; decorate our 32-bit floating-point constant
    %i32 = OpTypeInt 32 1   ; declare a signed 32-bit type
    %float = OpTypeFloat 32 ; declare a 32-bit floating-point type
    %1 = OpSpecConstant %i32 -1 ; some signed 32-bit integer constant
    %2 = OpSpecConstant %float 0.5 ; some 32-bit floating-point constant

From the above we have two specialization constants, one is a signed 32-bit integer and the second is a 32-bit floating-point value.

Now to specialize the above via the specialization constants mechanism:

    struct SpecializationData {
        int32_t data0;
        float data1;
    };

    const VkSpecializationMapEntry entries[] =
    {
        {
            .constantID = 0,
            .offset = offsetof(SpecializationData, data0),
            .size = sizeof(SpecializationData::data0)
        },
        {
            .constantID = 12,
            .offset = offsetof(SpecializationData, data1),
            .size = sizeof(SpecializationData::data1)
        }
    };

    SpecializationData data;
    data.data0 = -42;    // set the data for the 32-bit integer
    data.data1 = 42.0f;  // set the data for the 32-bit floating-point

    const VkSpecializationInfo info =
    {
        .mapEntryCount = 2,
        .pMapEntries = entries,
        .dataSize = sizeof(data),
        .pdata = &data,
    };

It is legal for a SPIR-V module with specializations to be compiled into a pipeline where no specialization information was provided. SPIR-V specialization constants contain default values such that if a specialization is not provided, the default value will be used. In the examples above, it would be valid for an application to only specialize some of the specialization constants within the SPIR-V module, and let the other constants use their default values encoded within the OpSpecConstant declarations.

### 10.10. Pipeline Libraries

A pipeline library is a special pipeline that was created using the `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` and cannot be bound, instead it defines a set of pipeline state which can be linked into other pipelines. For ray tracing pipelines this includes shaders and shader groups. For graphics pipelines this includes distinct library types defined by VkGraphicsPipelineLibraryFlagBitsEXT. The application must maintain the lifetime of a pipeline library based on the pipelines that link with it.

This linkage is achieved by using the following structure within the appropriate creation mechanisms:

The `VkPipelineLibraryCreateInfoKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_library
    typedef struct VkPipelineLibraryCreateInfoKHR {
        VkStructureType      sType;
        const void*          pNext;
        uint32_t             libraryCount;
        const VkPipeline*    pLibraries;
    } VkPipelineLibraryCreateInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `libraryCount` is the number of pipeline libraries in `pLibraries`.

- `pLibraries` is a pointer to an array of VkPipeline structures specifying pipeline libraries to use when creating a pipeline.

Valid Usage

- VUID-VkPipelineLibraryCreateInfoKHR-pLibraries-03381
  Each element of `pLibraries` must have been created with `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

- VUID-VkPipelineLibraryCreateInfoKHR-pLibraries-06855
  If any library in `pLibraries` was created with a shader stage with VkPipelineShaderStageModuleIdentifierCreateInfoEXT and `identifierSize` not equal to 0, the pipeline must be created with the `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT` flag set

- VUID-VkPipelineLibraryCreateInfoKHR-pLibraries-08096
  If any element of `pLibraries` was created with `VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT`, all elements must have been created with `VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT`

- VUID-VkPipelineLibraryCreateInfoKHR-pipeline-07404
  If `pipeline` is being created with `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT`, every element of `pLibraries` must have been created with `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT`

- VUID-VkPipelineLibraryCreateInfoKHR-pipeline-07405
  If `pipeline` is being created without `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT`, every element of `pLibraries` must have been created without `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT`

- VUID-VkPipelineLibraryCreateInfoKHR-pipeline-07406
  If `pipeline` is being created with `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT`, every element of `pLibraries` must have been created with `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT`

- VUID-VkPipelineLibraryCreateInfoKHR-pipeline-07407
  If `pipeline` is being created without `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT`, every element of `pLibraries` must have been created without `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT`

Valid Usage (Implicit)

- VUID-VkPipelineLibraryCreateInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR`

- VUID-VkPipelineLibraryCreateInfoKHR-pLibraries-parameter
  If `libraryCount` is not `0`, `pLibraries` must be a valid pointer to an array of `libraryCount` valid VkPipeline handles

Pipelines created with `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` libraries can depend on other pipeline libraries in VkPipelineLibraryCreateInfoKHR.

A pipeline library is considered in-use, as long as one of the linking pipelines is in-use. This applies recursively if a pipeline library includes other pipeline libraries.

### 10.11. Pipeline Binding

Once a pipeline has been created, it can be bound to the command buffer using the command:

    // Provided by VK_VERSION_1_0
    void vkCmdBindPipeline(
        VkCommandBuffer                             commandBuffer,
        VkPipelineBindPoint                         pipelineBindPoint,
        VkPipeline                                  pipeline);

- `commandBuffer` is the command buffer that the pipeline will be bound to.

- `pipelineBindPoint` is a VkPipelineBindPoint value specifying to which bind point the pipeline is bound. Binding one does not disturb the others.

- `pipeline` is the pipeline to be bound.

Once bound, a pipeline binding affects subsequent commands that interact with the given pipeline type in the command buffer until a different pipeline of the same type is bound to the bind point, or until the pipeline bind point is disturbed by binding a shader object as described in Interaction with Pipelines. Commands that do not interact with the given pipeline type must not be affected by the pipeline state.

Valid Usage

- VUID-vkCmdBindPipeline-pipelineBindPoint-00777
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_COMPUTE`, the `VkCommandPool` that `commandBuffer` was allocated from must support compute operations

- VUID-vkCmdBindPipeline-pipelineBindPoint-00778
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_GRAPHICS`, the `VkCommandPool` that `commandBuffer` was allocated from must support graphics operations

- VUID-vkCmdBindPipeline-pipelineBindPoint-00779
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_COMPUTE`, `pipeline` must be a compute pipeline

- VUID-vkCmdBindPipeline-pipelineBindPoint-00780
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_GRAPHICS`, `pipeline` must be a graphics pipeline

- VUID-vkCmdBindPipeline-pipeline-00781
  If the `variableMultisampleRate` feature is not supported, `pipeline` is a graphics pipeline, the current subpass uses no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline must match that set in the previous pipeline

- VUID-vkCmdBindPipeline-variableSampleLocations-01525
  If VkPhysicalDeviceSampleLocationsPropertiesEXT::`variableSampleLocations` is `VK_FALSE`, and `pipeline` is a graphics pipeline created with a VkPipelineSampleLocationsStateCreateInfoEXT structure having its `sampleLocationsEnable` member set to `VK_TRUE` but without `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT` enabled then the current render pass instance must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose `pPostSubpassSampleLocations` member contains an element with a `subpassIndex` matching the current subpass index and the `sampleLocationsInfo` member of that element must match the `sampleLocationsInfo` specified in VkPipelineSampleLocationsStateCreateInfoEXT when the pipeline was created

- VUID-vkCmdBindPipeline-None-02323
  This command must not be recorded when transform feedback is active

- VUID-vkCmdBindPipeline-pipelineBindPoint-02391
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR`, the `VkCommandPool` that `commandBuffer` was allocated from must support compute operations

- VUID-vkCmdBindPipeline-pipelineBindPoint-02392
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR`, `pipeline` must be a ray tracing pipeline

- VUID-vkCmdBindPipeline-pipelineBindPoint-06721
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR`, `commandBuffer` must not be a protected command buffer

- VUID-vkCmdBindPipeline-pipelineProtectedAccess-07408
  If the `pipelineProtectedAccess` feature is enabled, and `commandBuffer` is a protected command buffer, `pipeline` must have been created without `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT`

- VUID-vkCmdBindPipeline-pipelineProtectedAccess-07409
  If the `pipelineProtectedAccess` feature is enabled, and `commandBuffer` is not a protected command buffer, `pipeline` must have been created without `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT`

- VUID-vkCmdBindPipeline-pipeline-03382
  `pipeline` must not have been created with `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR` set

- VUID-vkCmdBindPipeline-commandBuffer-04808
  If `commandBuffer` is a secondary command buffer with VkCommandBufferInheritanceViewportScissorInfoNV::`viewportScissor2D` enabled and `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_GRAPHICS`, then the `pipeline` must have been created with `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT` or `VK_DYNAMIC_STATE_VIEWPORT`, and `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT` or `VK_DYNAMIC_STATE_SCISSOR` enabled

- VUID-vkCmdBindPipeline-commandBuffer-04809
  If `commandBuffer` is a secondary command buffer with VkCommandBufferInheritanceViewportScissorInfoNV::`viewportScissor2D` enabled and `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_GRAPHICS` and `pipeline` was created with VkPipelineDiscardRectangleStateCreateInfoEXT structure and its `discardRectangleCount` member is not `0`, or the pipeline was created with `VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT` enabled, then the pipeline must have been created with `VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT` enabled

- VUID-vkCmdBindPipeline-pipelineBindPoint-04881
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_GRAPHICS` and the `provokingVertexModePerPipeline` limit is `VK_FALSE`, then pipeline’s VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::`provokingVertexMode` must be the same as that of any other pipelines previously bound to this bind point within the current render pass instance, including any pipeline already bound when beginning the render pass instance

- VUID-vkCmdBindPipeline-pipelineBindPoint-04949
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI`, the `VkCommandPool` that `commandBuffer` was allocated from must support compute operations

- VUID-vkCmdBindPipeline-pipelineBindPoint-04950
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI`, `pipeline` must be a subpass shading pipeline

Valid Usage (Implicit)

- VUID-vkCmdBindPipeline-commandBuffer-parameter
  `commandBuffer` must be a valid VkCommandBuffer handle

- VUID-vkCmdBindPipeline-pipelineBindPoint-parameter
  `pipelineBindPoint` must be a valid VkPipelineBindPoint value

- VUID-vkCmdBindPipeline-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

- VUID-vkCmdBindPipeline-commandBuffer-recording
  `commandBuffer` must be in the recording state

- VUID-vkCmdBindPipeline-commandBuffer-cmdpool
  The `VkCommandPool` that `commandBuffer` was allocated from must support graphics, or compute operations

- VUID-vkCmdBindPipeline-videocoding
  This command must only be called outside of a video coding scope

- VUID-vkCmdBindPipeline-commonparent
  Both of `commandBuffer`, and `pipeline` must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

- Host access to `commandBuffer` must be externally synchronized

- Host access to the `VkCommandPool` that `commandBuffer` was allocated from must be externally synchronized

Command Properties

Command Buffer Levels | Render Pass Scope | Video Coding Scope | Supported Queue Types | Command Type
--- | --- | --- | --- | ---
Primary Secondary | Both | Outside | Graphics Compute | State

Possible values of vkCmdBindPipeline::`pipelineBindPoint`, specifying the bind point of a pipeline object, are:

    // Provided by VK_VERSION_1_0
    typedef enum VkPipelineBindPoint {
        VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
        VK_PIPELINE_BIND_POINT_COMPUTE = 1,
    #ifdef VK_ENABLE_BETA_EXTENSIONS
      // Provided by VK_AMDX_shader_enqueue
        VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX = 1000134000,
    #endif
      // Provided by VK_KHR_ray_tracing_pipeline
        VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000,
      // Provided by VK_HUAWEI_subpass_shading
        VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003,
      // Provided by VK_NV_ray_tracing
        VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
    } VkPipelineBindPoint;

- `VK_PIPELINE_BIND_POINT_COMPUTE` specifies binding as a compute pipeline.

- `VK_PIPELINE_BIND_POINT_GRAPHICS` specifies binding as a graphics pipeline.

- `VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR` specifies binding as a ray tracing pipeline.

- `VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI` specifies binding as a subpass shading pipeline.

- `VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX` specifies binding as an execution graph pipeline.

For pipelines that were created with the support of multiple shader groups (see Graphics Pipeline Shader Groups), the regular `vkCmdBindPipeline` command will bind Shader Group `0`. To explicitly bind a shader group use:

    // Provided by VK_NV_device_generated_commands
    void vkCmdBindPipelineShaderGroupNV(
        VkCommandBuffer                             commandBuffer,
        VkPipelineBindPoint                         pipelineBindPoint,
        VkPipeline                                  pipeline,
        uint32_t                                    groupIndex);

- `commandBuffer` is the command buffer that the pipeline will be bound to.

- `pipelineBindPoint` is a VkPipelineBindPoint value specifying the bind point to which the pipeline will be bound.

- `pipeline` is the pipeline to be bound.

- `groupIndex` is the shader group to be bound.

Valid Usage

- VUID-vkCmdBindPipelineShaderGroupNV-groupIndex-02893
  `groupIndex` must be `0` or less than the effective VkGraphicsPipelineShaderGroupsCreateInfoNV::`groupCount` including the referenced pipelines

- VUID-vkCmdBindPipelineShaderGroupNV-pipelineBindPoint-02894
  The `pipelineBindPoint` must be `VK_PIPELINE_BIND_POINT_GRAPHICS`

- VUID-vkCmdBindPipelineShaderGroupNV-groupIndex-02895
  The same restrictions as vkCmdBindPipeline apply as if the bound pipeline was created only with the Shader Group from the `groupIndex` information

- VUID-vkCmdBindPipelineShaderGroupNV-deviceGeneratedCommands-02896
  The `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV`::`deviceGeneratedCommands` feature must be enabled

Valid Usage (Implicit)

- VUID-vkCmdBindPipelineShaderGroupNV-commandBuffer-parameter
  `commandBuffer` must be a valid VkCommandBuffer handle

- VUID-vkCmdBindPipelineShaderGroupNV-pipelineBindPoint-parameter
  `pipelineBindPoint` must be a valid VkPipelineBindPoint value

- VUID-vkCmdBindPipelineShaderGroupNV-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

- VUID-vkCmdBindPipelineShaderGroupNV-commandBuffer-recording
  `commandBuffer` must be in the recording state

- VUID-vkCmdBindPipelineShaderGroupNV-commandBuffer-cmdpool
  The `VkCommandPool` that `commandBuffer` was allocated from must support graphics, or compute operations

- VUID-vkCmdBindPipelineShaderGroupNV-videocoding
  This command must only be called outside of a video coding scope

- VUID-vkCmdBindPipelineShaderGroupNV-commonparent
  Both of `commandBuffer`, and `pipeline` must have been created, allocated, or retrieved from the same VkDevice

Host Synchronization

- Host access to `commandBuffer` must be externally synchronized

- Host access to the `VkCommandPool` that `commandBuffer` was allocated from must be externally synchronized

Command Properties

Command Buffer Levels | Render Pass Scope | Video Coding Scope | Supported Queue Types | Command Type
--- | --- | --- | --- | ---
Primary Secondary | Both | Outside | Graphics Compute | State

#### 10.11.1. Interaction With Shader Objects

If the `shaderObject` feature is enabled, applications can use both pipelines and shader objects at the same time. The interaction between pipelines and shader objects is described in Interaction with Pipelines.

### 10.12. Dynamic State

When a pipeline object is bound, any pipeline object state that is not specified as dynamic is applied to the command buffer state. Pipeline object state that is specified as dynamic is not applied to the command buffer state at this time.

Instead, dynamic state can be modified at any time and persists for the lifetime of the command buffer, or until modified by another dynamic state setting command, or made invalid by binding a pipeline in which that state is statically specified.

If the `commandBufferInheritance` feature is enabled, all valid state from the previously executed command buffer in the queue is inherited into the next command buffer executed in the same queue. This inherited state does not need to be set again before draw or dispatch commands.

When a pipeline object is bound, the following applies to each state parameter:

- If the state is not specified as dynamic in the new pipeline object, then that command buffer state is overwritten by the state in the new pipeline object. Before any draw or dispatch call with this pipeline there must not have been any calls to any of the corresponding dynamic state setting commands after this pipeline was bound.

- If the state is specified as dynamic in the new pipeline object, then that command buffer state is not disturbed. Before any draw or dispatch call with this pipeline there must have been at least one call to each of the corresponding dynamic state setting commands. The state-setting commands must be recorded after command buffer recording was begun, or after the last command binding a pipeline object with that state specified as static, whichever was the latter.

- If the state is not included (corresponding pointer in VkGraphicsPipelineCreateInfo was `NULL` or was ignored) in the new pipeline object, then that command buffer state is not disturbed. For example, mesh shading pipelines do not include vertex input state and therefore do not disturb any such command buffer state.

Dynamic state that does not affect the result of operations can be left undefined.

Note | For example, if blending is disabled by the pipeline object state then the dynamic color blend constants do not need to be specified in the command buffer, even if this state is specified as dynamic in the pipeline object.

Note | Applications running on Vulkan implementations advertising an VkPhysicalDeviceDriverProperties::`conformanceVersion` less than 1.3.8.0 should be aware that rebinding the bound pipeline object may not reapply static state.

### 10.13. Pipeline Properties and Shader Information

When a pipeline is created, its state and shaders are compiled into zero or more device-specific executables, which are used when executing commands against that pipeline. To query the properties of these pipeline executables, call:

    // Provided by VK_KHR_pipeline_executable_properties
    VkResult vkGetPipelineExecutablePropertiesKHR(
        VkDevice                                    device,
        const VkPipelineInfoKHR*                    pPipelineInfo,
        uint32_t*                                   pExecutableCount,
        VkPipelineExecutablePropertiesKHR*          pProperties);

- `device` is the device that created the pipeline.

- `pPipelineInfo` describes the pipeline being queried.

- `pExecutableCount` is a pointer to an integer related to the number of pipeline executables available or queried, as described below.

- `pProperties` is either `NULL` or a pointer to an array of VkPipelineExecutablePropertiesKHR structures.

If `pProperties` is `NULL`, then the number of pipeline executables associated with the pipeline is returned in `pExecutableCount`. Otherwise, `pExecutableCount` must point to a variable set by the application to the number of elements in the `pProperties` array, and on return the variable is overwritten with the number of structures actually written to `pProperties`. If `pExecutableCount` is less than the number of pipeline executables associated with the pipeline, at most `pExecutableCount` structures will be written, and `VK_INCOMPLETE` will be returned instead of `VK_SUCCESS`, to indicate that not all the available properties were returned.

Valid Usage

- VUID-vkGetPipelineExecutablePropertiesKHR-pipelineExecutableInfo-03270
  The `pipelineExecutableInfo` feature must be enabled

- VUID-vkGetPipelineExecutablePropertiesKHR-pipeline-03271
  The `pipeline` member of `pPipelineInfo` must have been created with `device`

Valid Usage (Implicit)

- VUID-vkGetPipelineExecutablePropertiesKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetPipelineExecutablePropertiesKHR-pPipelineInfo-parameter
  `pPipelineInfo` must be a valid pointer to a valid VkPipelineInfoKHR structure

- VUID-vkGetPipelineExecutablePropertiesKHR-pExecutableCount-parameter
  `pExecutableCount` must be a valid pointer to a `uint32_t` value

- VUID-vkGetPipelineExecutablePropertiesKHR-pProperties-parameter
  If the value referenced by `pExecutableCount` is not `0`, and `pProperties` is not `NULL`, `pProperties` must be a valid pointer to an array of `pExecutableCount` VkPipelineExecutablePropertiesKHR structures

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_INCOMPLETE`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

The `VkPipelineExecutablePropertiesKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_executable_properties
    typedef struct VkPipelineExecutablePropertiesKHR {
        VkStructureType       sType;
        void*                 pNext;
        VkShaderStageFlags    stages;
        char                  name[VK_MAX_DESCRIPTION_SIZE];
        char                  description[VK_MAX_DESCRIPTION_SIZE];
        uint32_t              subgroupSize;
    } VkPipelineExecutablePropertiesKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `stages` is a bitmask of zero or more VkShaderStageFlagBits indicating which shader stages (if any) were principally used as inputs to compile this pipeline executable.

- `name` is an array of `VK_MAX_DESCRIPTION_SIZE` `char` containing a null-terminated UTF-8 string which is a short human readable name for this pipeline executable.

- `description` is an array of `VK_MAX_DESCRIPTION_SIZE` `char` containing a null-terminated UTF-8 string which is a human readable description for this pipeline executable.

- `subgroupSize` is the subgroup size with which this pipeline executable is dispatched.

Not all implementations have a 1:1 mapping between shader stages and pipeline executables and some implementations may reduce a given shader stage to fixed function hardware programming such that no pipeline executable is available. No guarantees are provided about the mapping between shader stages and pipeline executables and `stages` should be considered a best effort hint. Because the application cannot rely on the `stages` field to provide an exact description, `name` and `description` provide a human readable name and description which more accurately describes the given pipeline executable.

Valid Usage (Implicit)

- VUID-VkPipelineExecutablePropertiesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR`

- VUID-VkPipelineExecutablePropertiesKHR-pNext-pNext
  `pNext` must be `NULL`

To query the pipeline properties call:

    // Provided by VK_EXT_pipeline_properties
    VkResult vkGetPipelinePropertiesEXT(
        VkDevice                                    device,
        const VkPipelineInfoEXT*                    pPipelineInfo,
        VkBaseOutStructure*                         pPipelineProperties);

- `device` is the logical device that created the pipeline.

- `pPipelineInfo` is a pointer to a VkPipelineInfoEXT structure which describes the pipeline being queried.

- `pPipelineProperties` is a pointer to a VkBaseOutStructure structure in which the pipeline properties will be written.

To query a pipeline’s `pipelineIdentifier` pass a VkPipelinePropertiesIdentifierEXT structure in `pPipelineProperties`. Each pipeline is associated with a `pipelineIdentifier` and the identifier is implementation specific.

Valid Usage

- VUID-vkGetPipelinePropertiesEXT-pipeline-06738
  The `pipeline` member of `pPipelineInfo` must have been created with `device`

- VUID-vkGetPipelinePropertiesEXT-pPipelineProperties-06739
  `pPipelineProperties` must be a valid pointer to a VkPipelinePropertiesIdentifierEXT structure

- VUID-vkGetPipelinePropertiesEXT-None-06766
  The `pipelinePropertiesIdentifier` feature must be enabled

Valid Usage (Implicit)

- VUID-vkGetPipelinePropertiesEXT-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetPipelinePropertiesEXT-pPipelineInfo-parameter
  `pPipelineInfo` must be a valid pointer to a valid VkPipelineInfoEXT structure

Return Codes

Success

  - `VK_SUCCESS`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

The `VkPipelinePropertiesIdentifierEXT` structure is defined as:

    // Provided by VK_EXT_pipeline_properties
    typedef struct VkPipelinePropertiesIdentifierEXT {
        VkStructureType    sType;
        void*              pNext;
        uint8_t            pipelineIdentifier[VK_UUID_SIZE];
    } VkPipelinePropertiesIdentifierEXT;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `pipelineIdentifier` is an array of `VK_UUID_SIZE` `uint8_t` values into which the pipeline identifier will be written.

Valid Usage (Implicit)

- VUID-VkPipelinePropertiesIdentifierEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT`

- VUID-VkPipelinePropertiesIdentifierEXT-pNext-pNext
  `pNext` must be `NULL`

The `VkPipelineInfoKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_executable_properties
    typedef struct VkPipelineInfoKHR {
        VkStructureType    sType;
        const void*        pNext;
        VkPipeline         pipeline;
    } VkPipelineInfoKHR;

or the equivalent

    // Provided by VK_EXT_pipeline_properties
    typedef VkPipelineInfoKHR VkPipelineInfoEXT;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `pipeline` is a `VkPipeline` handle.

Valid Usage (Implicit)

- VUID-VkPipelineInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR`

- VUID-VkPipelineInfoKHR-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkPipelineInfoKHR-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

Each pipeline executable may have a set of statistics associated with it that are generated by the pipeline compilation process. These statistics may include things such as instruction counts, amount of spilling (if any), maximum number of simultaneous threads, or anything else which may aid developers in evaluating the expected performance of a shader. To query the compile time statistics associated with a pipeline executable, call:

    // Provided by VK_KHR_pipeline_executable_properties
    VkResult vkGetPipelineExecutableStatisticsKHR(
        VkDevice                                    device,
        const VkPipelineExecutableInfoKHR*          pExecutableInfo,
        uint32_t*                                   pStatisticCount,
        VkPipelineExecutableStatisticKHR*           pStatistics);

- `device` is the device that created the pipeline.

- `pExecutableInfo` describes the pipeline executable being queried.

- `pStatisticCount` is a pointer to an integer related to the number of statistics available or queried, as described below.

- `pStatistics` is either `NULL` or a pointer to an array of VkPipelineExecutableStatisticKHR structures.

If `pStatistics` is `NULL`, then the number of statistics associated with the pipeline executable is returned in `pStatisticCount`. Otherwise, `pStatisticCount` must point to a variable set by the application to the number of elements in the `pStatistics` array, and on return the variable is overwritten with the number of structures actually written to `pStatistics`. If `pStatisticCount` is less than the number of statistics associated with the pipeline executable, at most `pStatisticCount` structures will be written, and `VK_INCOMPLETE` will be returned instead of `VK_SUCCESS`, to indicate that not all the available statistics were returned.

Valid Usage

- VUID-vkGetPipelineExecutableStatisticsKHR-pipelineExecutableInfo-03272
  The `pipelineExecutableInfo` feature must be enabled

- VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03273
  The `pipeline` member of `pExecutableInfo` must have been created with `device`

- VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03274
  The `pipeline` member of `pExecutableInfo` must have been created with `VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR`

Valid Usage (Implicit)

- VUID-vkGetPipelineExecutableStatisticsKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetPipelineExecutableStatisticsKHR-pExecutableInfo-parameter
  `pExecutableInfo` must be a valid pointer to a valid VkPipelineExecutableInfoKHR structure

- VUID-vkGetPipelineExecutableStatisticsKHR-pStatisticCount-parameter
  `pStatisticCount` must be a valid pointer to a `uint32_t` value

- VUID-vkGetPipelineExecutableStatisticsKHR-pStatistics-parameter
  If the value referenced by `pStatisticCount` is not `0`, and `pStatistics` is not `NULL`, `pStatistics` must be a valid pointer to an array of `pStatisticCount` VkPipelineExecutableStatisticKHR structures

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_INCOMPLETE`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

The `VkPipelineExecutableInfoKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_executable_properties
    typedef struct VkPipelineExecutableInfoKHR {
        VkStructureType    sType;
        const void*        pNext;
        VkPipeline         pipeline;
        uint32_t           executableIndex;
    } VkPipelineExecutableInfoKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `pipeline` is the pipeline to query.

- `executableIndex` is the index of the pipeline executable to query in the array of executable properties returned by vkGetPipelineExecutablePropertiesKHR.

Valid Usage

- VUID-VkPipelineExecutableInfoKHR-executableIndex-03275
  `executableIndex` must be less than the number of pipeline executables associated with `pipeline` as returned in the `pExecutableCount` parameter of `vkGetPipelineExecutablePropertiesKHR`

Valid Usage (Implicit)

- VUID-VkPipelineExecutableInfoKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR`

- VUID-VkPipelineExecutableInfoKHR-pNext-pNext
  `pNext` must be `NULL`

- VUID-VkPipelineExecutableInfoKHR-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

The `VkPipelineExecutableStatisticKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_executable_properties
    typedef struct VkPipelineExecutableStatisticKHR {
        VkStructureType                           sType;
        void*                                     pNext;
        char                                      name[VK_MAX_DESCRIPTION_SIZE];
        char                                      description[VK_MAX_DESCRIPTION_SIZE];
        VkPipelineExecutableStatisticFormatKHR    format;
        VkPipelineExecutableStatisticValueKHR     value;
    } VkPipelineExecutableStatisticKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `name` is an array of `VK_MAX_DESCRIPTION_SIZE` `char` containing a null-terminated UTF-8 string which is a short human readable name for this statistic.

- `description` is an array of `VK_MAX_DESCRIPTION_SIZE` `char` containing a null-terminated UTF-8 string which is a human readable description for this statistic.

- `format` is a VkPipelineExecutableStatisticFormatKHR value specifying the format of the data found in `value`.

- `value` is the value of this statistic.

Valid Usage (Implicit)

- VUID-VkPipelineExecutableStatisticKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR`

- VUID-VkPipelineExecutableStatisticKHR-pNext-pNext
  `pNext` must be `NULL`

The `VkPipelineExecutableStatisticFormatKHR` enum is defined as:

    // Provided by VK_KHR_pipeline_executable_properties
    typedef enum VkPipelineExecutableStatisticFormatKHR {
        VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
        VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
        VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
        VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
    } VkPipelineExecutableStatisticFormatKHR;

- `VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR` specifies that the statistic is returned as a 32-bit boolean value which must be either `VK_TRUE` or `VK_FALSE` and should be read from the `b32` field of `VkPipelineExecutableStatisticValueKHR`.

- `VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR` specifies that the statistic is returned as a signed 64-bit integer and should be read from the `i64` field of `VkPipelineExecutableStatisticValueKHR`.

- `VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR` specifies that the statistic is returned as an unsigned 64-bit integer and should be read from the `u64` field of `VkPipelineExecutableStatisticValueKHR`.

- `VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR` specifies that the statistic is returned as a 64-bit floating-point value and should be read from the `f64` field of `VkPipelineExecutableStatisticValueKHR`.

The `VkPipelineExecutableStatisticValueKHR` union is defined as:

    // Provided by VK_KHR_pipeline_executable_properties
    typedef union VkPipelineExecutableStatisticValueKHR {
        VkBool32    b32;
        int64_t     i64;
        uint64_t    u64;
        double      f64;
    } VkPipelineExecutableStatisticValueKHR;

- `b32` is the 32-bit boolean value if the `VkPipelineExecutableStatisticFormatKHR` is `VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR`.

- `i64` is the signed 64-bit integer value if the `VkPipelineExecutableStatisticFormatKHR` is `VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR`.

- `u64` is the unsigned 64-bit integer value if the `VkPipelineExecutableStatisticFormatKHR` is `VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR`.

- `f64` is the 64-bit floating-point value if the `VkPipelineExecutableStatisticFormatKHR` is `VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR`.

Each pipeline executable may have one or more text or binary internal representations associated with it which are generated as part of the compile process. These may include the final shader assembly, a binary form of the compiled shader, or the shader compiler’s internal representation at any number of intermediate compile steps. To query the internal representations associated with a pipeline executable, call:

    // Provided by VK_KHR_pipeline_executable_properties
    VkResult vkGetPipelineExecutableInternalRepresentationsKHR(
        VkDevice                                    device,
        const VkPipelineExecutableInfoKHR*          pExecutableInfo,
        uint32_t*                                   pInternalRepresentationCount,
        VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);

- `device` is the device that created the pipeline.

- `pExecutableInfo` describes the pipeline executable being queried.

- `pInternalRepresentationCount` is a pointer to an integer related to the number of internal representations available or queried, as described below.

- `pInternalRepresentations` is either `NULL` or a pointer to an array of VkPipelineExecutableInternalRepresentationKHR structures.

If `pInternalRepresentations` is `NULL`, then the number of internal representations associated with the pipeline executable is returned in `pInternalRepresentationCount`. Otherwise, `pInternalRepresentationCount` must point to a variable set by the application to the number of elements in the `pInternalRepresentations` array, and on return the variable is overwritten with the number of structures actually written to `pInternalRepresentations`. If `pInternalRepresentationCount` is less than the number of internal representations associated with the pipeline executable, at most `pInternalRepresentationCount` structures will be written, and `VK_INCOMPLETE` will be returned instead of `VK_SUCCESS`, to indicate that not all the available representations were returned.

While the details of the internal representations remain implementation-dependent, the implementation should order the internal representations in the order in which they occur in the compiled pipeline with the final shader assembly (if any) last.

Valid Usage

- VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipelineExecutableInfo-03276
  The `pipelineExecutableInfo` feature must be enabled

- VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03277
  The `pipeline` member of `pExecutableInfo` must have been created with `device`

- VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03278
  The `pipeline` member of `pExecutableInfo` must have been created with `VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR`

Valid Usage (Implicit)

- VUID-vkGetPipelineExecutableInternalRepresentationsKHR-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pExecutableInfo-parameter
  `pExecutableInfo` must be a valid pointer to a valid VkPipelineExecutableInfoKHR structure

- VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentationCount-parameter
  `pInternalRepresentationCount` must be a valid pointer to a `uint32_t` value

- VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentations-parameter
  If the value referenced by `pInternalRepresentationCount` is not `0`, and `pInternalRepresentations` is not `NULL`, `pInternalRepresentations` must be a valid pointer to an array of `pInternalRepresentationCount` VkPipelineExecutableInternalRepresentationKHR structures

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_INCOMPLETE`

Failure

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

  - `VK_ERROR_OUT_OF_DEVICE_MEMORY`

The `VkPipelineExecutableInternalRepresentationKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_executable_properties
    typedef struct VkPipelineExecutableInternalRepresentationKHR {
        VkStructureType    sType;
        void*              pNext;
        char               name[VK_MAX_DESCRIPTION_SIZE];
        char               description[VK_MAX_DESCRIPTION_SIZE];
        VkBool32           isText;
        size_t             dataSize;
        void*              pData;
    } VkPipelineExecutableInternalRepresentationKHR;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `name` is an array of `VK_MAX_DESCRIPTION_SIZE` `char` containing a null-terminated UTF-8 string which is a short human readable name for this internal representation.

- `description` is an array of `VK_MAX_DESCRIPTION_SIZE` `char` containing a null-terminated UTF-8 string which is a human readable description for this internal representation.

- `isText` specifies whether the returned data is text or opaque data. If `isText` is `VK_TRUE` then the data returned in `pData` is text and is guaranteed to be a null-terminated UTF-8 string.

- `dataSize` is an integer related to the size, in bytes, of the internal representation’s data, as described below.

- `pData` is either `NULL` or a pointer to a block of data into which the implementation will write the internal representation.

If `pData` is `NULL`, then the size, in bytes, of the internal representation data is returned in `dataSize`. Otherwise, `dataSize` must be the size of the buffer, in bytes, pointed to by `pData` and on return `dataSize` is overwritten with the number of bytes of data actually written to `pData` including any trailing null character. If `dataSize` is less than the size, in bytes, of the internal representation’s data, at most `dataSize` bytes of data will be written to `pData`, and `VK_INCOMPLETE` will be returned instead of `VK_SUCCESS`, to indicate that not all the available representation was returned.

If `isText` is `VK_TRUE` and `pData` is not `NULL` and `dataSize` is not zero, the last byte written to `pData` will be a null character.

Valid Usage (Implicit)

- VUID-VkPipelineExecutableInternalRepresentationKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR`

- VUID-VkPipelineExecutableInternalRepresentationKHR-pNext-pNext
  `pNext` must be `NULL`

Information about a particular shader that has been compiled as part of a pipeline object can be extracted by calling:

    // Provided by VK_AMD_shader_info
    VkResult vkGetShaderInfoAMD(
        VkDevice                                    device,
        VkPipeline                                  pipeline,
        VkShaderStageFlagBits                       shaderStage,
        VkShaderInfoTypeAMD                         infoType,
        size_t*                                     pInfoSize,
        void*                                       pInfo);

- `device` is the device that created `pipeline`.

- `pipeline` is the target of the query.

- `shaderStage` is a VkShaderStageFlagBits specifying the particular shader within the pipeline about which information is being queried.

- `infoType` describes what kind of information is being queried.

- `pInfoSize` is a pointer to a value related to the amount of data the query returns, as described below.

- `pInfo` is either `NULL` or a pointer to a buffer.

If `pInfo` is `NULL`, then the maximum size of the information that can be retrieved about the shader, in bytes, is returned in `pInfoSize`. Otherwise, `pInfoSize` must point to a variable set by the application to the size of the buffer, in bytes, pointed to by `pInfo`, and on return the variable is overwritten with the amount of data actually written to `pInfo`. If `pInfoSize` is less than the maximum size that can be retrieved by the pipeline cache, then at most `pInfoSize` bytes will be written to `pInfo`, and `VK_INCOMPLETE` will be returned, instead of `VK_SUCCESS`, to indicate that not all required of the pipeline cache was returned.

Not all information is available for every shader and implementations may not support all kinds of information for any shader. When a certain type of information is unavailable, the function returns `VK_ERROR_FEATURE_NOT_PRESENT`.

If information is successfully and fully queried, the function will return `VK_SUCCESS`.

For `infoType` `VK_SHADER_INFO_TYPE_STATISTICS_AMD`, a `VkShaderStatisticsInfoAMD` structure will be written to the buffer pointed to by `pInfo`. This structure will be populated with statistics regarding the physical device resources used by that shader along with other miscellaneous information and is described in further detail below.

For `infoType` `VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD`, `pInfo` is a pointer to a null-terminated UTF-8 string containing human-readable disassembly. The exact formatting and contents of the disassembly string are vendor-specific.

The formatting and contents of all other types of information, including `infoType` `VK_SHADER_INFO_TYPE_BINARY_AMD`, are left to the vendor and are not further specified by this extension.

Valid Usage (Implicit)

- VUID-vkGetShaderInfoAMD-device-parameter
  `device` must be a valid VkDevice handle

- VUID-vkGetShaderInfoAMD-pipeline-parameter
  `pipeline` must be a valid VkPipeline handle

- VUID-vkGetShaderInfoAMD-shaderStage-parameter
  `shaderStage` must be a valid VkShaderStageFlagBits value

- VUID-vkGetShaderInfoAMD-infoType-parameter
  `infoType` must be a valid VkShaderInfoTypeAMD value

- VUID-vkGetShaderInfoAMD-pInfoSize-parameter
  `pInfoSize` must be a valid pointer to a `size_t` value

- VUID-vkGetShaderInfoAMD-pInfo-parameter
  If the value referenced by `pInfoSize` is not `0`, and `pInfo` is not `NULL`, `pInfo` must be a valid pointer to an array of `pInfoSize` bytes

- VUID-vkGetShaderInfoAMD-pipeline-parent
  `pipeline` must have been created, allocated, or retrieved from `device`

Return Codes

Success

  - `VK_SUCCESS`

  - `VK_INCOMPLETE`

Failure

  - `VK_ERROR_FEATURE_NOT_PRESENT`

  - `VK_ERROR_OUT_OF_HOST_MEMORY`

Possible values of vkGetShaderInfoAMD::`infoType`, specifying the information being queried from a shader, are:

    // Provided by VK_AMD_shader_info
    typedef enum VkShaderInfoTypeAMD {
        VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,
        VK_SHADER_INFO_TYPE_BINARY_AMD = 1,
        VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
    } VkShaderInfoTypeAMD;

- `VK_SHADER_INFO_TYPE_STATISTICS_AMD` specifies that device resources used by a shader will be queried.

- `VK_SHADER_INFO_TYPE_BINARY_AMD` specifies that implementation-specific information will be queried.

- `VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD` specifies that human-readable disassembly of a shader.

The `VkShaderStatisticsInfoAMD` structure is defined as:

    // Provided by VK_AMD_shader_info
    typedef struct VkShaderStatisticsInfoAMD {
        VkShaderStageFlags          shaderStageMask;
        VkShaderResourceUsageAMD    resourceUsage;
        uint32_t                    numPhysicalVgprs;
        uint32_t                    numPhysicalSgprs;
        uint32_t                    numAvailableVgprs;
        uint32_t                    numAvailableSgprs;
        uint32_t                    computeWorkGroupSize[3];
    } VkShaderStatisticsInfoAMD;

- `shaderStageMask` are the combination of logical shader stages contained within this shader.

- `resourceUsage` is a VkShaderResourceUsageAMD structure describing internal physical device resources used by this shader.

- `numPhysicalVgprs` is the maximum number of vector instruction general-purpose registers (VGPRs) available to the physical device.

- `numPhysicalSgprs` is the maximum number of scalar instruction general-purpose registers (SGPRs) available to the physical device.

- `numAvailableVgprs` is the maximum limit of VGPRs made available to the shader compiler.

- `numAvailableSgprs` is the maximum limit of SGPRs made available to the shader compiler.

- `computeWorkGroupSize` is the local workgroup size of this shader in { X, Y, Z } dimensions.

Some implementations may merge multiple logical shader stages together in a single shader. In such cases, `shaderStageMask` will contain a bitmask of all of the stages that are active within that shader. Consequently, if specifying those stages as input to vkGetShaderInfoAMD, the same output information may be returned for all such shader stage queries.

The number of available VGPRs and SGPRs (`numAvailableVgprs` and `numAvailableSgprs` respectively) are the shader-addressable subset of physical registers that is given as a limit to the compiler for register assignment. These values may further be limited by implementations due to performance optimizations where register pressure is a bottleneck.

The `VkShaderResourceUsageAMD` structure is defined as:

    // Provided by VK_AMD_shader_info
    typedef struct VkShaderResourceUsageAMD {
        uint32_t    numUsedVgprs;
        uint32_t    numUsedSgprs;
        uint32_t    ldsSizePerLocalWorkGroup;
        size_t      ldsUsageSizeInBytes;
        size_t      scratchMemUsageInBytes;
    } VkShaderResourceUsageAMD;

- `numUsedVgprs` is the number of vector instruction general-purpose registers used by this shader.

- `numUsedSgprs` is the number of scalar instruction general-purpose registers used by this shader.

- `ldsSizePerLocalWorkGroup` is the maximum local data store size per work group in bytes.

- `ldsUsageSizeInBytes` is the LDS usage size in bytes per work group by this shader.

- `scratchMemUsageInBytes` is the scratch memory usage in bytes by this shader.

### 10.14. Pipeline Compiler Control

The compilation of a pipeline can be tuned by adding a `VkPipelineCompilerControlCreateInfoAMD` structure to the `pNext` chain of VkGraphicsPipelineCreateInfo or VkComputePipelineCreateInfo.

    // Provided by VK_AMD_pipeline_compiler_control
    typedef struct VkPipelineCompilerControlCreateInfoAMD {
        VkStructureType                      sType;
        const void*                          pNext;
        VkPipelineCompilerControlFlagsAMD    compilerControlFlags;
    } VkPipelineCompilerControlCreateInfoAMD;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `compilerControlFlags` is a bitmask of VkPipelineCompilerControlFlagBitsAMD affecting how the pipeline will be compiled.

Valid Usage (Implicit)

- VUID-VkPipelineCompilerControlCreateInfoAMD-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD`

- VUID-VkPipelineCompilerControlCreateInfoAMD-compilerControlFlags-zerobitmask
  `compilerControlFlags` must be `0`

There are currently no available flags for this extension; flags will be added by future versions of this extension.

    // Provided by VK_AMD_pipeline_compiler_control
    typedef enum VkPipelineCompilerControlFlagBitsAMD {
    } VkPipelineCompilerControlFlagBitsAMD;

    // Provided by VK_AMD_pipeline_compiler_control
    typedef VkFlags VkPipelineCompilerControlFlagsAMD;

`VkPipelineCompilerControlFlagsAMD` is a bitmask type for setting a mask of zero or more VkPipelineCompilerControlFlagBitsAMD.

### 10.15. Pipeline Creation Feedback

Feedback about the creation of a particular pipeline object can be obtained by adding a `VkPipelineCreationFeedbackCreateInfo` structure to the `pNext` chain of VkGraphicsPipelineCreateInfo, VkRayTracingPipelineCreateInfoKHR, VkRayTracingPipelineCreateInfoNV, or VkComputePipelineCreateInfo. The `VkPipelineCreationFeedbackCreateInfo` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPipelineCreationFeedbackCreateInfo {
        VkStructureType                sType;
        const void*                    pNext;
        VkPipelineCreationFeedback*    pPipelineCreationFeedback;
        uint32_t                       pipelineStageCreationFeedbackCount;
        VkPipelineCreationFeedback*    pPipelineStageCreationFeedbacks;
    } VkPipelineCreationFeedbackCreateInfo;

or the equivalent

    // Provided by VK_EXT_pipeline_creation_feedback
    typedef VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackCreateInfoEXT;

- `sType` is a VkStructureType value identifying this structure.

- `pNext` is `NULL` or a pointer to a structure extending this structure.

- `pPipelineCreationFeedback` is a pointer to a VkPipelineCreationFeedback structure.

- `pipelineStageCreationFeedbackCount` is the number of elements in `pPipelineStageCreationFeedbacks`.

- `pPipelineStageCreationFeedbacks` is a pointer to an array of `pipelineStageCreationFeedbackCount` VkPipelineCreationFeedback structures.

An implementation should write pipeline creation feedback to `pPipelineCreationFeedback` and may write pipeline stage creation feedback to `pPipelineStageCreationFeedbacks`. An implementation must set or clear the `VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT` in VkPipelineCreationFeedback::`flags` for `pPipelineCreationFeedback` and every element of `pPipelineStageCreationFeedbacks`.

Note | One common scenario for an implementation to skip per-stage feedback is when `VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT` is set in `pPipelineCreationFeedback`.

When chained to VkRayTracingPipelineCreateInfoKHR, VkRayTracingPipelineCreateInfoNV, or VkGraphicsPipelineCreateInfo, the `i` element of `pPipelineStageCreationFeedbacks` corresponds to the `i` element of VkRayTracingPipelineCreateInfoKHR::`pStages`, VkRayTracingPipelineCreateInfoNV::`pStages`, or VkGraphicsPipelineCreateInfo::`pStages`. When chained to VkComputePipelineCreateInfo, the first element of `pPipelineStageCreationFeedbacks` corresponds to VkComputePipelineCreateInfo::`stage`.

Valid Usage (Implicit)

- VUID-VkPipelineCreationFeedbackCreateInfo-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO`

- VUID-VkPipelineCreationFeedbackCreateInfo-pPipelineCreationFeedback-parameter
  `pPipelineCreationFeedback` must be a valid pointer to a VkPipelineCreationFeedback structure

- VUID-VkPipelineCreationFeedbackCreateInfo-pPipelineStageCreationFeedbacks-parameter
  If `pipelineStageCreationFeedbackCount` is not `0`, `pPipelineStageCreationFeedbacks` must be a valid pointer to an array of `pipelineStageCreationFeedbackCount` VkPipelineCreationFeedback structures

The `VkPipelineCreationFeedback` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPipelineCreationFeedback {
        VkPipelineCreationFeedbackFlags    flags;
        uint64_t                           duration;
    } VkPipelineCreationFeedback;

or the equivalent

    // Provided by VK_EXT_pipeline_creation_feedback
    typedef VkPipelineCreationFeedback VkPipelineCreationFeedbackEXT;

- `flags` is a bitmask of VkPipelineCreationFeedbackFlagBits providing feedback about the creation of a pipeline or of a pipeline stage.

- `duration` is the duration spent creating a pipeline or pipeline stage in nanoseconds.

If the `VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT` is not set in `flags`, an implementation must not set any other bits in `flags`, and the values of all other `VkPipelineCreationFeedback` data members are undefined.

Possible values of the `flags` member of VkPipelineCreationFeedback are:

    // Provided by VK_VERSION_1_3
    typedef enum VkPipelineCreationFeedbackFlagBits {
        VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001,
        VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002,
        VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004,
      // Provided by VK_EXT_pipeline_creation_feedback
        VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT,
      // Provided by VK_EXT_pipeline_creation_feedback
        VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT,
      // Provided by VK_EXT_pipeline_creation_feedback
        VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT,
    } VkPipelineCreationFeedbackFlagBits;

or the equivalent

    // Provided by VK_EXT_pipeline_creation_feedback
    typedef VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFlagBitsEXT;

- `VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT` specifies that the feedback information is valid.

- `VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT` specifies that a readily usable pipeline or pipeline stage was found in the `pipelineCache` specified by the application in the pipeline creation command.

  An implementation should set the `VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT` bit if it was able to avoid the large majority of pipeline or pipeline stage creation work by using the `pipelineCache` parameter of vkCreateGraphicsPipelines, vkCreateRayTracingPipelinesKHR, vkCreateRayTracingPipelinesNV, or vkCreateComputePipelines. When an implementation sets this bit for the entire pipeline, it may leave it unset for any stage.

  Note | Implementations are encouraged to provide a meaningful signal to applications using this bit. The intention is to communicate to the application that the pipeline or pipeline stage was created “as fast as it gets” using the pipeline cache provided by the application. If an implementation uses an internal cache, it is discouraged from setting this bit as the feedback would be unactionable.

- `VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT` specifies that the base pipeline specified by the `basePipelineHandle` or `basePipelineIndex` member of the `Vk*PipelineCreateInfo` structure was used to accelerate the creation of the pipeline.

  An implementation should set the `VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT` bit if it was able to avoid a significant amount of work by using the base pipeline.

  Note | While “significant amount of work” is subjective, implementations are encouraged to provide a meaningful signal to applications using this bit. For example, a 1% reduction in duration may not warrant setting this bit, while a 50% reduction would.

    // Provided by VK_VERSION_1_3
    typedef VkFlags VkPipelineCreationFeedbackFlags;

or the equivalent

    // Provided by VK_EXT_pipeline_creation_feedback
    typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT;

`VkPipelineCreationFeedbackFlags` is a bitmask type for providing zero or more VkPipelineCreationFeedbackFlagBits.