# VkGraphicsPipelineCreateInfo(3) Manual Page

## Name

VkGraphicsPipelineCreateInfo - Structure specifying parameters of a newly created graphics pipeline

Loading… please wait.

## C Specification

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;

## Members

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- `layout` is the description of binding locations used by both the pipeline and descriptor sets used with the pipeline. If VkPhysicalDeviceProperties::`apiVersion` is greater than or equal to Vulkan 1.3 or VK_KHR_maintenance4 is enabled `layout` must not be accessed by the implementation outside of the duration of the command this structure is passed to.

- `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. The implementation must not access this object outside of the duration of the command this structure is passed to.

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

## Description

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

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

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

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

Vertex Input State

Vertex input state is defined by:

- VkPipelineVertexInputStateCreateInfo

- VkPipelineInputAssemblyStateCreateInfo

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

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

Pre-Rasterization Shader State

Pre-rasterization shader state is defined by:

- VkPipelineShaderStageCreateInfo entries for:

  - Vertex shaders

  - Tessellation control shaders

  - Tessellation evaluation shaders

  - Geometry shaders

  - Task shaders

  - Mesh shaders

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

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

- VkPipelineViewportStateCreateInfo

- VkPipelineRasterizationStateCreateInfo

- VkPipelineTessellationStateCreateInfo

- VkRenderPass and `subpass` parameter

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

- VkPipelineDiscardRectangleStateCreateInfoEXT

- VkPipelineFragmentShadingRateStateCreateInfoKHR

- Inclusion/omission of the VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE flag

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

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

Fragment Shader State

Fragment shader state is defined by:

- A VkPipelineShaderStageCreateInfo entry for the fragment shader

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

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

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

- VkPipelineDepthStencilStateCreateInfo

- VkRenderPass and `subpass` parameter

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

- VkPipelineFragmentShadingRateStateCreateInfoKHR

- VkPipelineFragmentShadingRateEnumStateCreateInfoNV

- VkPipelineRepresentativeFragmentTestStateCreateInfoNV

- Inclusion/omission of the VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR flag

- Inclusion/omission of the VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT flag

- VkRenderingInputAttachmentIndexInfo

- Inclusion/omission of the VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE flag

- The `customResolve` parameter of VkCustomResolveCreateInfoEXT. Formats are ignored, and not including the structure behaves identically to setting `customResolve` to VK_FALSE, unlike in fragment output interface state.

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

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

Fragment Output State

Fragment output state is defined by:

- VkPipelineColorBlendStateCreateInfo

- VkRenderPass and `subpass` parameter

- VkPipelineMultisampleStateCreateInfo

- The format parameters of VkPipelineRenderingCreateInfo (`viewMask` is ignored)

- VkAttachmentSampleCountInfoAMD

- VkAttachmentSampleCountInfoNV

- VkExternalFormatANDROID

- VkCustomResolveCreateInfoEXT

- Inclusion/omission of the VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT and VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT flags

- Inclusion/omission of the VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT flag

- VkRenderingAttachmentLocationInfo

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

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

Dynamic State

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

Complete Graphics Pipelines

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

Graphics Pipeline Library Layouts

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

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

Valid Usage

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-layout-10069
  If a push constant block is declared in a shader and `layout` is not VK_NULL_HANDLE, the block must be contained inside the push constant range in `layout` that matches the stage

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

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

- VUID-VkGraphicsPipelineCreateInfo-layout-07991
  If a resource variable is declared in a shader as an array and `layout` is not VK_NULL_HANDLE, the corresponding descriptor binding used to create `layout` must have a `descriptorCount` that is greater than or equal to the length of the array

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

- VUID-VkGraphicsPipelineCreateInfo-flags-11798
  If shader64BitIndexing feature is not enabled, `flags` must not contain VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT

- VUID-VkGraphicsPipelineCreateInfo-pipelineCreationCacheControl-02878
  If the `pipelineCreationCacheControl` feature is not enabled, `flags` must not include VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT nor 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 nor VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT

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

- VUID-VkGraphicsPipelineCreateInfo-flags-11311
  If VkPipelineCreateFlags2CreateInfoKHR::`flags` includes VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, `layout` must be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-flags-11312
  If VkPipelineCreateFlags2CreateInfoKHR::`flags` includes VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, all shader variables in the shader resource interface with a `DescriptorSet` and `Binding` decoration must have a mapping declared in VkShaderDescriptorSetAndBindingMappingInfoEXT::`pMappings`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-10913
  If the pipeline requires fragment shader state, no element of the `pDynamicStates` member of `pDynamicState` is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and `pDynamicStates` includes VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE or the `depthBoundsTestEnable` member of `pDepthStencilState` is VK_TRUE, `minDepthBounds` must be less than or equal to `maxDepthBounds`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-renderPass-12325
  If `renderPass` is not VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, `pStages` include a mesh shader, and `subpass` viewMask is not `0`, then the index of the most significant bit in `viewMask` must be less than `maxMeshMultiviewViewCount`

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

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

- VUID-VkGraphicsPipelineCreateInfo-layout-01688
  The number of resources in `layout` accessible to each shader stage that is used by the pipeline must be less than or equal to `VkPhysicalDeviceLimits`::`maxPerStageResources`

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-09198
  If the pipeline is being created with vertex input state and `pVertexInputState` is not dynamic, and VkVertexInputAttributeDescription::`format` has a 64-bit component, then all `Input` variables at the corresponding `Location` in the `Vertex` `Execution` `Model` `OpEntryPoint` must not use components that are not present in the format

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766
  If the pipeline requires pre-rasterization shader state and at least one of fragment output interface state or fragment shader state, and `pMultisampleState` is not `NULL`, the `lineRasterizationMode` member of a VkPipelineRasterizationLineStateCreateInfo structure included in the `pNext` chain of `pRasterizationState` is VK_LINE_RASTERIZATION_MODE_BRESENHAM or VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, then the `alphaToCoverageEnable`, `alphaToOneEnable`, and `sampleShadingEnable` members of `pMultisampleState` must all be VK_FALSE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04494
  If the pipeline requires pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.width` must be greater than or equal to `1`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04495
  If the pipeline requires pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.height` must be greater than or equal to `1`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04496
  If the pipeline requires pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.width` must be a power-of-two value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04497
  If the pipeline requires pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.height` must be a power-of-two value

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04498
  If the pipeline requires pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.width` must be less than or equal to `4`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04499
  If the pipeline requires pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in `pDynamicState->pDynamicStates`, VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.height` must be less than or equal to `4`

- VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04500
  If the pipeline requires pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in `pDynamicState->pDynamicStates`, and the `pipelineFragmentShadingRate` feature is not enabled, VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.width` and VkPipelineFragmentShadingRateStateCreateInfoKHR::`fragmentSize.height` must both be equal to `1`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-renderPass-11504
  If `renderPass` is VK_NULL_HANDLE, a VkCustomResolveCreateInfoEXT is in the pNext chain, and the pipeline is being created with fragment output interface state, VkPipelineRenderingCreateInfo::`colorAttachmentCount` must be equal to VkCustomResolveCreateInfoEXT::`colorAttachmentCount`

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-renderPass-12326
  If `renderPass` is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, `pStages` include a mesh shader, and VkPipelineRenderingCreateInfo::`viewMask` is not `0`, then the index of the most significant bit in `viewMask` must be less than `maxMeshMultiviewViewCount`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-layout-06602
  If the pipeline requires fragment shader state or pre-rasterization shader state, and VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, `layout` must be a valid VkPipelineLayout handle

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-flags-06612
  If VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, and 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, and 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, VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT was not used, and any element of the `pSetLayouts` array when `layout` was created and the corresponding element of the `pSetLayouts` array used to create the library’s `layout` must not both be VK_NULL_HANDLE

- VUID-VkGraphicsPipelineCreateInfo-pLibraries-06681
  If VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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, VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT was not used, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, and 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 VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, 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 either VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, and the other element is included in VkPipelineLibraryCreateInfoKHR::`pLibraries`, 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 VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT and VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT are included in two elements of VkPipelineLibraryCreateInfoKHR::`pLibraries`, and `renderPass` was VK_NULL_HANDLE for both libraries, the value of VkPipelineRenderingCreateInfo::`viewMask` set by each library must be identical

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-flags-11856
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes either VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, VkCustomResolveCreateInfoEXT is included and VkCustomResolveCreateInfoEXT::`customResolve` is VK_TRUE, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` also includes either VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, the library must also include VkCustomResolveCreateInfoEXT and the VkCustomResolveCreateInfoEXT::`customResolve` specified by the library must be VK_TRUE

- VUID-VkGraphicsPipelineCreateInfo-flags-11857
  If VkGraphicsPipelineLibraryCreateInfoEXT::`flags` includes either VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, VkCustomResolveCreateInfoEXT is not included or VkCustomResolveCreateInfoEXT::`customResolve` is VK_FALSE, and an element of VkPipelineLibraryCreateInfoKHR::`pLibraries` also includes either VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, either the library must not include VkCustomResolveCreateInfoEXT or the VkCustomResolveCreateInfoEXT::`customResolve` specified by the library must be VK_FALSE

- VUID-VkGraphicsPipelineCreateInfo-customResolve-11858
  If one element of VkPipelineLibraryCreateInfoKHR includes either VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, VkCustomResolveCreateInfoEXT is included and VkCustomResolveCreateInfoEXT::`customResolve` is VK_TRUE, and another element of VkPipelineLibraryCreateInfoKHR::`pLibraries` also includes either VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, the other library must also include VkCustomResolveCreateInfoEXT and the VkCustomResolveCreateInfoEXT::`customResolve` specified by the library must be VK_TRUE

- VUID-VkGraphicsPipelineCreateInfo-customResolve-11859
  If one element of VkPipelineLibraryCreateInfoKHR includes either VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, VkCustomResolveCreateInfoEXT is not included or VkCustomResolveCreateInfoEXT::`customResolve` is VK_FALSE, and another element of VkPipelineLibraryCreateInfoKHR::`pLibraries` also includes either VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT or VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, either the other library must not include VkCustomResolveCreateInfoEXT or the VkCustomResolveCreateInfoEXT::`customResolve` specified by the library must be VK_FALSE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-conservativePointAndLineRasterization-08892
  If `conservativePointAndLineRasterization` is not supported and the effective rasterization input topology is in line or point topology class, then VkPipelineRasterizationConservativeStateCreateInfoEXT::`conservativeRasterizationMode` must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-multiviewPerViewViewports-12249
  If the `multiviewPerViewViewports` feature is enabled, `renderpass` is VK_NULL_HANDLE, the pipeline requires pre-rasterization shader state, and no element of the `pDynamicStates` member of `pDynamicState` is VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, then the index of the most significant bit in VkPipelineRenderingCreateInfo::`viewMask` must be less than `pViewportState->viewportCount`

- VUID-VkGraphicsPipelineCreateInfo-multiviewPerViewViewports-12250
  If the `multiviewPerViewViewports` feature is enabled, `renderpass` is VK_NULL_HANDLE, the pipeline requires pre-rasterization shader state, and no element of the `pDynamicStates` member of `pDynamicState` is VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, then the index of the most significant bit in VkPipelineRenderingCreateInfo::`viewMask` must be less than `pViewportState->scissorCount`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-VkGraphicsPipelineCreateInfo-flags-11273
  If VkPipelineCreateFlags2CreateInfoKHR::`flags` includes VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, all libraries linked to this pipeline must also have that flag set

- VUID-VkGraphicsPipelineCreateInfo-flags-11274
  If VkPipelineCreateFlags2CreateInfoKHR::`flags` does not include VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, all libraries linked to this pipeline must also not have that flag set

- VUID-VkGraphicsPipelineCreateInfo-flags-12355
  If `flags` includes VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, all libraries linked to this pipeline must also have that flag set

- VUID-VkGraphicsPipelineCreateInfo-flags-12356
  If `flags` does not include VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, all libraries linked to this pipeline must also not have that flag set

- VUID-VkGraphicsPipelineCreateInfo-flags-12357
  If `flags` includes VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, all libraries linked to this pipeline must also have that flag set

- VUID-VkGraphicsPipelineCreateInfo-flags-12358
  If `flags` does not include VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, all libraries linked to this pipeline must also not have that flag set

- VUID-VkGraphicsPipelineCreateInfo-flags-12359
  If `flags` includes VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, all libraries linked to this pipeline must also have that flag set

- VUID-VkGraphicsPipelineCreateInfo-flags-12360
  If `flags` does not include VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, all libraries linked to this pipeline must also not have that flag set

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, VkCustomResolveCreateInfoEXT, VkExternalFormatANDROID, VkExternalFormatOHOS, VkGraphicsPipelineLibraryCreateInfoEXT, VkGraphicsPipelineShaderGroupsCreateInfoNV, VkMultiviewPerViewAttributesInfoNVX, VkPipelineBinaryInfoKHR, VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreateFlags2CreateInfo, VkPipelineCreationFeedbackCreateInfo, VkPipelineDiscardRectangleStateCreateInfoEXT, VkPipelineFragmentDensityMapLayeredCreateInfoVALVE, VkPipelineFragmentShadingRateEnumStateCreateInfoNV, VkPipelineFragmentShadingRateStateCreateInfoKHR, VkPipelineLibraryCreateInfoKHR, VkPipelineRenderingCreateInfo, VkPipelineRepresentativeFragmentTestStateCreateInfoNV, VkPipelineRobustnessCreateInfo, VkRenderingAttachmentLocationInfo, or VkRenderingInputAttachmentIndexInfo

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

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

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

## See Also

VK_VERSION_1_0, VkPipeline, VkPipelineColorBlendStateCreateInfo, VkPipelineCreateFlags, VkPipelineDepthStencilStateCreateInfo, VkPipelineDynamicStateCreateInfo, VkPipelineInputAssemblyStateCreateInfo, VkPipelineLayout, VkPipelineMultisampleStateCreateInfo, VkPipelineRasterizationStateCreateInfo, VkPipelineShaderStageCreateInfo, VkPipelineTessellationStateCreateInfo, VkPipelineVertexInputStateCreateInfo, VkPipelineViewportStateCreateInfo, VkRenderPass, VkStructureType, vkCreateGraphicsPipelines

## Document Notes

For more information, see the Vulkan Specification.

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

## Copyright

Copyright 2014-2026 The Khronos Group Inc.

SPDX-License-Identifier: CC-BY-4.0