Author: The Khronos® Vulkan Working Group

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

The Khronos® Vulkan Working Group
version 1.3.235, 2022-11-19 16:32:39Z
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.

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.

No state, including dynamic state, is inherited from one command buffer to another.

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. 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.

  | editing-note TODO (Jon) - Should we say something like “the i’th element of the `pPipelines` array is created based on the corresponding element of the `pCreateInfos` array”? Also for vkCreateGraphicsPipelines below.

Valid Usage

- 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

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 the type of 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.

Valid Usage

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

- VUID-VkComputePipelineCreateInfo-flags-00698
  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-00699
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is not -1, `basePipelineHandle` must be VK_NULL_HANDLE

- VUID-VkComputePipelineCreateInfo-flags-00700
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineHandle` is not VK_NULL_HANDLE, `basePipelineIndex` must be -1

- 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-00703
  `layout` must be consistent with the layout of the compute shader specified in `stage`

- 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-flags-03364
  `flags` must not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

- 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-02874
  `flags` must not include `VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV`

- 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-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`

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 VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreationFeedbackCreateInfo, VkPipelineRobustnessCreateInfoEXT, or VkSubpassShadingPipelineCreateInfoHUAWEI

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

- VUID-VkComputePipelineCreateInfo-flags-parameter
  `flags` must be a valid combination of VkPipelineCreateFlagBits values

- 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 the type of 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 the `graphicsPipelineLibrary` feature is enabled and an instance of VkShaderModuleCreateInfo is included in the `pNext` chain, `module` can be VK_NULL_HANDLE. 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-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 any variables in its interface that are declared with the `ClipDistance` or `CullDistance` `BuiltIn` decoration, those variables must not have array sizes which sum to more than `VkPhysicalDeviceLimits`::`maxCombinedClipAndCullDistances`

- VUID-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-00712
  If `stage` is `VK_SHADER_STAGE_VERTEX_BIT`, the identified entry point must not include any input variable in its interface that is decorated with `CullDistance`

- VUID-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-00718
  If `stage` is `VK_SHADER_STAGE_FRAGMENT_BIT`, the identified entry point must not include any output variables in its interface decorated with `CullDistance`

- 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-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`, 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-stage-06844
  If a shader module identifier is specified for this `stage`, a VkShaderModuleCreateInfo structure must not be present in the `pNext` chain

- 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

- VUID-VkPipelineShaderStageCreateInfo-stage-06846
  If a shader module identifier is not specified for this `stage`, and the `graphicsPipelineLibrary` feature is not enabled, `module` must be a valid VkShaderModule

- 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, VkPipelineRobustnessCreateInfoEXT, VkPipelineShaderStageModuleIdentifierCreateInfoEXT, 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 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_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_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;

- `sType` is the type of 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.

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 the type of 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`

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 a VkExtent2D structure

- VUID-vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI-renderpass-parent
  `renderpass` 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`

  - `VK_ERROR_SURFACE_LOST_KHR`

The `VkPipelineRobustnessCreateInfoEXT` structure is defined as:

    // Provided by VK_EXT_pipeline_robustness
    typedef struct VkPipelineRobustnessCreateInfoEXT {
        VkStructureType                          sType;
        const void*                              pNext;
        VkPipelineRobustnessBufferBehaviorEXT    storageBuffers;
        VkPipelineRobustnessBufferBehaviorEXT    uniformBuffers;
        VkPipelineRobustnessBufferBehaviorEXT    vertexInputs;
        VkPipelineRobustnessImageBehaviorEXT     images;
    } VkPipelineRobustnessCreateInfoEXT;

- `sType` is the type of this structure.

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

- `storageBuffers` sets the behaviour 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 behaviour 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 behaviour of out of bounds accesses made to vertex input attributes

- `images` describes the behaviour 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 `VkPipelineRobustnessCreateInfoEXT` depends on which structure’s `pNext` chain it is included in.

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

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

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

When `VkPipelineRobustnessCreateInfoEXT` 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-VkPipelineRobustnessCreateInfoEXT-pipelineRobustness-06926
  If the `pipelineRobustness` feature is not enabled, `storageBuffers` must be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT`

- VUID-VkPipelineRobustnessCreateInfoEXT-pipelineRobustness-06927
  If the `pipelineRobustness` feature is not enabled, `uniformBuffers` must be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT`

- VUID-VkPipelineRobustnessCreateInfoEXT-pipelineRobustness-06928
  If the `pipelineRobustness` feature is not enabled, `vertexInputs` must be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT`

- VUID-VkPipelineRobustnessCreateInfoEXT-pipelineRobustness-06929
  If the `pipelineRobustness` feature is not enabled, `images` must be `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT`

- VUID-VkPipelineRobustnessCreateInfoEXT-robustImageAccess-06930
  If the `robustImageAccess` feature is not supported, `images` must not be `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT`

- VUID-VkPipelineRobustnessCreateInfoEXT-robustBufferAccess2-06931
  If the `robustBufferAccess2` feature is not supported, `storageBuffers` must not be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT`

- VUID-VkPipelineRobustnessCreateInfoEXT-robustBufferAccess2-06932
  If the `robustBufferAccess2` feature is not supported, `uniformBuffers` must not be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT`

- VUID-VkPipelineRobustnessCreateInfoEXT-robustBufferAccess2-06933
  If the `robustBufferAccess2` feature is not supported, `vertexInputs` must not be `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT`

- VUID-VkPipelineRobustnessCreateInfoEXT-robustImageAccess2-06934
  If the `robustImageAccess2` feature is not supported, `images` must not be `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT`

Valid Usage (Implicit)

- VUID-VkPipelineRobustnessCreateInfoEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT`

- VUID-VkPipelineRobustnessCreateInfoEXT-storageBuffers-parameter
  `storageBuffers` must be a valid VkPipelineRobustnessBufferBehaviorEXT value

- VUID-VkPipelineRobustnessCreateInfoEXT-uniformBuffers-parameter
  `uniformBuffers` must be a valid VkPipelineRobustnessBufferBehaviorEXT value

- VUID-VkPipelineRobustnessCreateInfoEXT-vertexInputs-parameter
  `vertexInputs` must be a valid VkPipelineRobustnessBufferBehaviorEXT value

- VUID-VkPipelineRobustnessCreateInfoEXT-images-parameter
  `images` must be a valid VkPipelineRobustnessImageBehaviorEXT value

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

    // Provided by VK_EXT_pipeline_robustness
    typedef enum VkPipelineRobustnessBufferBehaviorEXT {
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = 0,
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = 1,
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = 2,
        VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = 3,
    } VkPipelineRobustnessBufferBehaviorEXT;

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

- `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT` 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_EXT` 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_EXT` 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 VkPipelineRobustnessCreateInfoEXT are:

    // Provided by VK_EXT_pipeline_robustness
    typedef enum VkPipelineRobustnessImageBehaviorEXT {
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = 0,
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = 1,
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = 2,
        VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = 3,
    } VkPipelineRobustnessImageBehaviorEXT;

- `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT` 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_EXT` 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_EXT` 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_EXT` 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 the type of 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` points 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

### 10.2. 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.

Valid Usage

- 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

| 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 the type of 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 is ignored 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. 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.

- `pViewportState` is a pointer to a VkPipelineViewportStateCreateInfo structure defining viewport state used when rasterization is enabled.

- `pRasterizationState` is a pointer to a VkPipelineRasterizationStateCreateInfo structure defining rasterization state.

- `pMultisampleState` is a pointer to a VkPipelineMultisampleStateCreateInfo structure defining multisample state used when rasterization is enabled.

- `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.

- `pColorBlendState` is a pointer to a VkPipelineColorBlendStateCreateInfo structure defining color blend state used when rasterization is enabled for any color attachments accessed during rendering.

- `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.

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 is defined by:

- VkPipelineVertexInputStateCreateInfo

- VkPipelineInputAssemblyStateCreateInfo

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

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

Fragment output state is defined by:

- VkPipelineColorBlendStateCreateInfo

- VkRenderPass and `subpass` parameter

- VkPipelineMultisampleStateCreateInfo

- VkPipelineRenderingCreateInfo

- VkAttachmentSampleCountInfoAMD

- VkAttachmentSampleCountInfoNV

- 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

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.

A complete graphics pipeline always includes pre-rasterization shader state, with other subsets included depending on that state. If the pre-rasterization shader state includes a vertex shader, then vertex input state is included in a complete graphics pipeline. If the value of VkPipelineRasterizationStateCreateInfo::`rasterizerDiscardEnable` in the pre-rasterization shader state is `VK_FALSE` or the `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE` dynamic state is enabled fragment shader state and fragment output interface state is included in a complete graphics pipeline.

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.

Valid Usage

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

- VUID-VkGraphicsPipelineCreateInfo-flags-00723
  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-00724
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is not -1, `basePipelineHandle` must be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-flags-00725
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineHandle` is not VK_NULL_HANDLE, `basePipelineIndex` must be -1

- VUID-VkGraphicsPipelineCreateInfo-pStages-02095
  If the pipeline is being created with 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-stage-02096
  If the pipeline is being created with pre-rasterization shader state the `stage` member of one element of `pStages` must be either `VK_SHADER_STAGE_VERTEX_BIT` or `VK_SHADER_STAGE_MESH_BIT_EXT`

- 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 is being created with 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 is being created with pre-rasterization shader state and `pStages` includes a tessellation evaluation shader stage, it must include a tessellation control shader stage

- VUID-VkGraphicsPipelineCreateInfo-pStages-00731
  If the pipeline is being created with pre-rasterization shader state and `pStages` includes a tessellation control shader stage and a tessellation evaluation shader stage, `pTessellationState` must be a valid pointer to a valid VkPipelineTessellationStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pStages-00732
  If the pipeline is being created with 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 is being created with 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 is being created with 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 is being created with 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-00736
  If the pipeline is being created with pre-rasterization shader state and `pStages` includes tessellation shader stages, the `topology` member of `pInputAssembly` must be `VK_PRIMITIVE_TOPOLOGY_PATCH_LIST`

- VUID-VkGraphicsPipelineCreateInfo-topology-00737
  If the pipeline is being created with pre-rasterization shader state and the `topology` member of `pInputAssembly` is `VK_PRIMITIVE_TOPOLOGY_PATCH_LIST`, `pStages` must include tessellation shader stages

- VUID-VkGraphicsPipelineCreateInfo-Vertex-07722
  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`, a `PointSize` decorated variable must be written to

- 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 shaderTessellationAndGeometryPointSize is enabled, a `PointSize` decorated variable must be written to

- 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 shaderTessellationAndGeometryPointSize is not enabled, a `PointSize` decorated variable must not be written to

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

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

- VUID-VkGraphicsPipelineCreateInfo-pStages-00738
  If the pipeline is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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, and the pipeline is being created with fragment output interface state, and the `pColorBlendState` pointer is not `NULL`, 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 is being created with 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`, the `pViewports` member of `pViewportState` must be a valid pointer to an array of `pViewportState->viewportCount` valid `VkViewport` structures

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04131
  If the pipeline is being created with pre-rasterization shader state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_SCISSOR` or `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT`, the `pScissors` member of `pViewportState` must be a valid pointer to an array of `pViewportState->scissorCount` `VkRect2D` structures

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749
  If the pipeline is being created with 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-00750
  If the pipeline is being created with pre-rasterization shader state, and the `rasterizerDiscardEnable` member of `pRasterizationState` is `VK_FALSE`, `pViewportState` must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pViewportState-04892
  If the pipeline is being created with pre-rasterization shader state, and the graphics pipeline state was created with the `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE` dynamic state enabled, `pViewportState` must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751
  If the pipeline is being created with fragment output interface state, `pMultisampleState` must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure

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

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

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754
  If the pipeline is being created with 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 is being created with fragment shader state, and 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 is being created with fragment shader state or fragment output interface state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT` or `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT`, and the `sampleLocationsEnable` member of a VkPipelineSampleLocationsStateCreateInfoEXT structure 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 is being created with fragment shader state or fragment output interface state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT` or `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT`, and the `sampleLocationsEnable` member of a VkPipelineSampleLocationsStateCreateInfoEXT structure 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 is being created with fragment shader state or fragment output interface state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT` or `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT`, and the `sampleLocationsEnable` member of a VkPipelineSampleLocationsStateCreateInfoEXT structure 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-pDynamicStates-07613
  If the pipeline is being created with fragment shader state or fragment output interface state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT`, and the `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT` state is set, and the `sampleLocationsEnable` member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the `pNext` chain of `pMultisampleState` is `VK_TRUE` or `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT` is used, `sampleLocationsInfo.sampleLocationGridSize.width` must evenly divide VkMultisamplePropertiesEXT::`sampleLocationGridSize.width` as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a `samples` parameter equaling the value of `rasterizationSamples` in the last call to vkCmdSetRasterizationSamplesEXT

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07614
  If the pipeline is being created with fragment shader state or fragment output interface state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT`, and the `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT` state is set, and the `sampleLocationsEnable` member of a VkPipelineSampleLocationsStateCreateInfoEXT structure 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` in the last call to vkCmdSetRasterizationSamplesEXT

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07615
  If the pipeline is being created with fragment shader state or fragment output interface state, and no element of the `pDynamicStates` member of `pDynamicState` is `VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT`, and the `VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT` state is set, and the `sampleLocationsEnable` member of a VkPipelineSampleLocationsStateCreateInfoEXT structure 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` in the last call to vkCmdSetRasterizationSamplesEXT

- VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524
  If the pipeline is being created with 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-layout-00756
  `layout` must be consistent with all shaders specified in `pStages`

- VUID-VkGraphicsPipelineCreateInfo-multisampledRenderToSingleSampled-06853
  If the pipeline is being created with 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, 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 is being created with fragment output interface state, and the `VK_AMD_mixed_attachment_samples` extension is enabled, 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, 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 is being created with fragment output interface state, and the `VK_NV_framebuffer_mixed_samples` extension is enabled, 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 is being created with fragment output interface state, and the `VK_NV_framebuffer_mixed_samples` extension is enabled, 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 is being created with fragment output interface state, and the `VK_NV_coverage_reduction_mode` extension is enabled, 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 is being created with fragment output interface state, 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-06049
  If `renderPass` is not VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, and `subpass` viewMask is not `0`, all of the shaders in the pipeline must not write to the `Layer` built-in output

- 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-07717
  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 `ViewMask` 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 is being created with 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 is being created with 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 is being created with 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-04057
  If the pipeline is being created with 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 is being created with 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-pVertexInputState-04910
  If the pipeline is being created with vertex input state, and `VK_DYNAMIC_STATE_VERTEX_INPUT_EXT` is not set, `pVertexInputState` must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pStages-02098
  If the pipeline is being created with vertex input state, `pInputAssemblyState` must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-pStages-02317
  If the pipeline is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 VkPipelineRasterizationLineStateCreateInfoEXT structure included in the `pNext` chain of `pRasterizationState` is `VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT` or `VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT`, then the `alphaToCoverageEnable`, `alphaToOneEnable`, and `sampleShadingEnable` members of `pMultisampleState` must all be `VK_FALSE`

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

- 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-03379
  If the pipeline is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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-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 is being created with 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 `deviceGeneratedCommands` feature must be enabled

- VUID-VkGraphicsPipelineCreateInfo-flags-02966
  If the pipeline is being created with 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-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_EXT` or `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-flags-07369
  `flags` must not include both `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT` and `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04494
  If the pipeline is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with fragment shader state, and the `VK_QCOM_render_pass_shader_resolve` extension is enabled, 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 is being created with 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-renderPass-06575
  If the pipeline is being created with pre-rasterization shader state, fragment shader state, or fragment output interface state, `renderPass` must be VK_NULL_HANDLE or a valid render pass object

- VUID-VkGraphicsPipelineCreateInfo-dynamicRendering-06576
  If the `dynamicRendering` feature is not enabled and the pipeline is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 aspect

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06588
  If the pipeline is being created with 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 aspect

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06589
  If the pipeline is being created with 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-06053
  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`, `pDepthStencilState` must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06590
  If `renderPass` is VK_NULL_HANDLE and the pipeline is being created with fragment shader state but not fragment output interface state, `pDepthStencilState` must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06054
  If `renderPass` is VK_NULL_HANDLE, the pipeline is being created with fragment output interface state, and VkPipelineRenderingCreateInfo::`colorAttachmentCount` is not equal to `0`, `pColorBlendState` must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure

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

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06056
  If `renderPass` is VK_NULL_HANDLE and the pipeline is being created with fragment shader state the fragment shader must not read from any input attachment

- 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-07718
  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 write to the `Layer` built-in output

- 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-07719
  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 `ViewIndex` 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 pipeline is being created with fragment shader state and `renderPass` is VK_NULL_HANDLE, fragment shaders in `pStages` must not include the `InputAttachment` capability

- VUID-VkGraphicsPipelineCreateInfo-renderPass-06062
  If the pipeline is being created with 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 is being created with 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 pipeline is being created with 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-flags-06483
  If the pipeline is being created with 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-flags-06484
  If the pipeline is being created with fragment output interface state 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-flags-06485
  If the pipeline is being created with fragment output interface state 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-flags-06486
  If the pipeline is being created with fragment output interface state 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-graphicsPipelineLibrary-06606
  If the `graphicsPipelineLibrary` feature is not enabled, `flags` must not include `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

- VUID-VkGraphicsPipelineCreateInfo-graphicsPipelineLibrary-06607
  If the `graphicsPipelineLibrary` feature is not enabled, the pipeline must be created with a complete set of state

- VUID-VkGraphicsPipelineCreateInfo-flags-06608
  If 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-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, 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 be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-flags-06680
  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 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-pMultisampleState-06629
  If the pipeline is being created with fragment shader state `pMultisampleState` must be `NULL` or a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure

- VUID-VkGraphicsPipelineCreateInfo-renderpass-06631
  If the pipeline is being created with fragment shader state and `renderpass` is not VK_NULL_HANDLE, then `pMultisampleState` must not be `NULL`

- VUID-VkGraphicsPipelineCreateInfo-Input-06632
  If the pipeline is being created with fragment shader state with a fragment shader that either enables sample shading or decorates any variable in the `Input` storage class with `Sample`, then `pMultisampleState` must not be `NULL`

- 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->sampleShading` 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->sampleShading` is `VK_TRUE`, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` was created with `VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT`, the `pMultisampleState` used to create that library must be identically defined `pMultisampleState`

- 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-06641
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes `VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT`, `pRasterizationState` must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure

- 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-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, VkPipelineLibraryCreateInfoKHR::`libraryCount` is `0`, and the `pNext` chain includes an instance of VkGraphicsPipelineShaderGroupsCreateInfoNV, VkGraphicsPipelineShaderGroupsCreateInfoNV::`groupCount` must be greater than `0`

- 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 a valid VkPipelineLayout that is 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 a valid VkPipelineLayout that is compatible with the union of the libraries' pipeline layouts

- VUID-VkGraphicsPipelineCreateInfo-conservativePointAndLineRasterization-06759
  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`, then VkPipelineRasterizationConservativeStateCreateInfoEXT::`conservativeRasterizationMode` must be `VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT`

- VUID-VkGraphicsPipelineCreateInfo-conservativePointAndLineRasterization-06760
  If `conservativePointAndLineRasterization` is not supported, the pipeline is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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 is being created with 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-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`

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, VkGraphicsPipelineLibraryCreateInfoEXT, VkGraphicsPipelineShaderGroupsCreateInfoNV, VkMultiviewPerViewAttributesInfoNVX, VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreationFeedbackCreateInfo, VkPipelineDiscardRectangleStateCreateInfoEXT, VkPipelineFragmentShadingRateEnumStateCreateInfoNV, VkPipelineFragmentShadingRateStateCreateInfoKHR, VkPipelineLibraryCreateInfoKHR, VkPipelineRenderingCreateInfo, VkPipelineRepresentativeFragmentTestStateCreateInfoNV, or VkPipelineRobustnessCreateInfoEXT

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

- VUID-VkGraphicsPipelineCreateInfo-flags-parameter
  `flags` must be a valid combination of VkPipelineCreateFlagBits values

- 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 the type of 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 this structure is present in the `pNext` chain of VkGraphicsPipelineCreateInfo, 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.

Valid Usage (Implicit)

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

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_KHR_dynamic_rendering with VK_KHR_fragment_shading_rate
        VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000,
      // Provided by VK_KHR_dynamic_rendering with VK_EXT_fragment_density_map
        VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000,
      // 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_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,
      // Provided by VK_EXT_pipeline_protected_access
        VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000,
      // Provided by VK_EXT_pipeline_protected_access
        VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000,
      // Provided by VK_VERSION_1_1
        VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
      // Provided by VK_KHR_dynamic_rendering with VK_KHR_fragment_shading_rate
        VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
      // Provided by VK_KHR_dynamic_rendering with VK_EXT_fragment_density_map
        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_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_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,
    } 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 `OpTraceRayKHR`.

- `VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR` specifies that AABB primitives will be skipped during traversal using `OpTraceRayKHR`.

- `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 set to 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.

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

- `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.

- `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.

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

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

- `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT` 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 `VkGraphicsPipelineLibraryCreateInfoEXT` structure is defined as:

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

- `sType` is the type of 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 the type of 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_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_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_NV = 1000205001,
      // Provided by VK_KHR_fragment_shading_rate
        VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
      // Provided by VK_EXT_line_rasterization
        VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
      // 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_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002,
      // 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
        VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031,
      // Provided by VK_EXT_extended_dynamic_state3
        VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032,
      // 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,
    } 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 the `depthBiasConstantFactor`, `depthBiasClamp` and `depthBiasSlopeFactor` states in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with vkCmdSetDepthBias before any draws are performed with `depthBiasEnable` in VkPipelineRasterizationStateCreateInfo set to `VK_TRUE`.

- `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. The VkDiscardRectangleModeEXT and the number of active discard rectangles is still specified by the `discardRectangleMode` and `discardRectangleCount` members of VkPipelineDiscardRectangleStateCreateInfoEXT.

- `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. The number of exclusive scissor rectangles used by a pipeline is still specified by the `exclusiveScissorCount` member of VkPipelineViewportExclusiveScissorStateCreateInfoNV.

- `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_EXT` specifies that the `lineStippleFactor` and `lineStipplePattern` state in VkPipelineRasterizationLineStateCreateInfoEXT will be ignored and must be set dynamically with vkCmdSetLineStippleEXT before any draws are performed with a pipeline state with VkPipelineRasterizationLineStateCreateInfoEXT 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 VkPipelineRasterizationLineStateCreateInfoEXT 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 VkPipelineRasterizationLineStateCreateInfoEXT 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_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.

#### 10.2.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.2.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 the type of 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 `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 the type of 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.3. 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.

Valid Usage

- 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

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 re-use the shader group handles provided in VkRayTracingShaderGroupCreateInfoKHR::`pShaderGroupCaptureReplayHandle` when VkPhysicalDeviceRayTracingPipelineFeaturesKHR::`rayTracingPipelineShaderGroupHandleCaptureReplay` is enabled.

Valid Usage

- 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-03677
  If `deferredOperation` is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object

- VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-03678
  Any previous deferred operation that was associated with `deferredOperation` must be complete

- 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 the type of 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.

Valid Usage

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03421
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is `-1`, `basePipelineHandle` must be a valid handle to a ray tracing `VkPipeline`

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03422
  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-03423
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is not `-1`, `basePipelineHandle` must be VK_NULL_HANDLE

- VUID-VkRayTracingPipelineCreateInfoNV-flags-03424
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineHandle` is not VK_NULL_HANDLE, `basePipelineIndex` must be `-1`

- 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-03427
  `layout` must be consistent with all shaders specified in `pStages`

- 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`

Valid Usage (Implicit)

- VUID-VkRayTracingPipelineCreateInfoNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV`

- VUID-VkRayTracingPipelineCreateInfoNV-pNext-pNext
  `pNext` must be `NULL` or a pointer to a valid instance of VkPipelineCreationFeedbackCreateInfo

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

- VUID-VkRayTracingPipelineCreateInfoNV-flags-parameter
  `flags` must be a valid combination of VkPipelineCreateFlagBits values

- 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 the type of 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.

Valid Usage

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-03421
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is `-1`, `basePipelineHandle` must be a valid handle to a ray tracing `VkPipeline`

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-03422
  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-03423
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineIndex` is not `-1`, `basePipelineHandle` must be VK_NULL_HANDLE

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-03424
  If `flags` contains the `VK_PIPELINE_CREATE_DERIVATIVE_BIT` flag, and `basePipelineHandle` is not VK_NULL_HANDLE, `basePipelineIndex` must be `-1`

- 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-03427
  `layout` must be consistent with all shaders specified in `pStages`

- 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-03600
  If `pLibraryInfo` is not `NULL` and its `libraryCount` is `0`, `stageCount` must not be `0`

- VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03601
  If `pLibraryInfo` is not `NULL` and 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

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 VkPipelineCreationFeedbackCreateInfo or VkPipelineRobustnessCreateInfoEXT

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

- VUID-VkRayTracingPipelineCreateInfoKHR-flags-parameter
  `flags` must be a valid combination of VkPipelineCreateFlagBits values

- 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 the type of 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 the type of 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. Ignored if VkPhysicalDeviceRayTracingPipelineFeaturesKHR::`rayTracingPipelineShaderGroupHandleCaptureReplay` is `VK_FALSE`.

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

Possible values of `type` in `VkRayTracingShaderGroupCreateInfoKHR` are:

    // 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` indicates 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 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 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 the type of 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 number of bytes used by any block declared in the `RayPayloadKHR` or `IncomingRayPayloadKHR` storage classes. `maxPipelineRayHitAttributeSize` is calculated as the maximum number of bytes used by any block 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 a user-allocated buffer where the results will be written.

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-03482
  `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 optional capture handle information of shaders in the 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 a user-allocated buffer where the results will be written.

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-06720
  `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.4. 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.5. Multiple Pipeline Creation

Multiple pipelines can be created simultaneously by passing an array of VkGraphicsPipelineCreateInfo, VkRayTracingPipelineCreateInfoKHR, VkRayTracingPipelineCreateInfoNV, or VkComputePipelineCreateInfo structures into the vkCreateGraphicsPipelines, vkCreateRayTracingPipelinesKHR, vkCreateRayTracingPipelinesNV, and vkCreateComputePipelines commands, respectively. Applications can group together similar pipelines to be created in a single call, and implementations are encouraged to look for reuse opportunities within a group-create.

When an application attempts to create many pipelines in a single command, it is possible that some subset may fail creation. In that case, the corresponding entries in the `pPipelines` output array will be filled with VK_NULL_HANDLE values. If any pipeline fails creation despite valid arguments (for example, due to out of memory errors), the VkResult code returned by `vkCreate*Pipelines` 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 had `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT` set, pipelines at an index in the `pPipelines` array greater than or equal to that of the failing pipeline must be set to VK_NULL_HANDLE.

If multiple pipelines fail to be created, the VkResult must be the return value of any of the pipelines which did not return `VK_SUCCESS`.

### 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 the type of 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 user 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.

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 enum 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`

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.

#### 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. 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 & z elements of the WorkgroupSize vector.

Now to specialize the above via the specialization constants mechanism:

    const VkSpecializationMapEntry entries[] =
    {
        {
            13,                             // constantID
            0 * sizeof(uint32_t),           // offset
            sizeof(uint32_t)                // size
        },
        {
            42,                             // constantID
            1 * sizeof(uint32_t),           // offset
            sizeof(uint32_t)                // size
        },
        {
            3,                              // constantID
            2 * sizeof(uint32_t),           // offset
            sizeof(uint32_t)                // size
        }
    };

    const uint32_t data[] = { 16, 8, 4 }; // our workgroup size is 16x8x4

    const VkSpecializationInfo info =
    {
        3,                                  // mapEntryCount
        entries,                            // pMapEntries
        3 * sizeof(uint32_t),               // dataSize
        data,                               // pData
    };

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[] =
    {
        {
            0,                                    // constantID
            offsetof(SpecializationData, data0),  // offset
            sizeof(SpecializationData::data0)     // size
        },
        {
            12,                                   // constantID
            offsetof(SpecializationData, data1),  // offset
            sizeof(SpecializationData::data1)     // size
        }
    };

    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 =
    {
        2,                                  // mapEntryCount
        entries,                            // pMapEntries
        sizeof(data),                       // dataSize
        &data,                              // pData
    };

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.9. 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 the type of 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_EXT`, every element of `pLibraries` must have been created with `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT`

- VUID-VkPipelineLibraryCreateInfoKHR-pipeline-07405
  If `pipeline` is being created without `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT`, every element of `pLibraries` must have been created without `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT`

- VUID-VkPipelineLibraryCreateInfoKHR-pipeline-07406
  If `pipeline` is being created with `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT`, every element of `pLibraries` must have been created with `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT`

- VUID-VkPipelineLibraryCreateInfoKHR-pipeline-07407
  If `pipeline` is being created without `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT`, every element of `pLibraries` must have been created without `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT`

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.10. 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. Commands that do not interact with the given pipeline type must not be affected by the pipeline state.

- The pipeline bound to `VK_PIPELINE_BIND_POINT_COMPUTE` controls the behavior of all dispatching commands.

- The pipeline bound to `VK_PIPELINE_BIND_POINT_GRAPHICS` controls the behavior of all drawing commands.

- The pipeline bound to `VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR` controls the behavior of vkCmdTraceRaysKHR and vkCmdTraceRaysIndirectKHR.

- The pipeline bound to `VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI` controls the behavior of vkCmdSubpassShadingHUAWEI.

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_EXT`

- 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_EXT`

- 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`, 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

- VUID-vkCmdBindPipeline-pipeline-06856
  If `pipeline` is a graphics pipeline, this command has been called inside a render pass instance started with vkCmdBeginRendering, and the `pNext` chain of VkRenderingInfo includes a VkMultisampledRenderToSingleSampledInfoEXT structure with `multisampledRenderToSingleSampledEnable` equal to `VK_TRUE`, then the value of VkGraphicsPipelineCreateInfo::`pMultisampleState`::`rasterizationSamples` must be equal to VkMultisampledRenderToSingleSampledInfoEXT::`rasterizationSamples`.

- VUID-vkCmdBindPipeline-pipelineBindPoint-06653
  If `pipelineBindPoint` is `VK_PIPELINE_BIND_POINT_GRAPHICS`, `pipeline` must have been created without `VK_PIPELINE_CREATE_LIBRARY_BIT_KHR`

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,
      // 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.

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 `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. 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 another pipeline bind with that state specified as static.

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.

### 10.12. 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 user 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 the type of 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 the type of 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 the type of 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 user 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 the type of 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 the type of 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 user 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 the type of 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 user 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 UTF-8 null-terminated 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.13. 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 the type of 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.14. 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 the type of 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,
        VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT,
        VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT,
        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` indicates that the feedback information is valid.

- `VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT` indicates 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` indicates 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.