Author: The Khronos® Vulkan Working Group

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

The Khronos® Vulkan Working Group
version 1.3.227, 2022-09-08 16:48:57Z
from git branch: Git branch not available commit: Git commit not available

Loading… please wait.

Search:

## 41. Features

Features describe functionality which is not supported on all implementations. Features are properties of the physical device. Features are optional, and must be explicitly enabled before use. Support for features is reported and enabled on a per-feature basis.

| Note Features are reported via the basic VkPhysicalDeviceFeatures structure, as well as the extensible structure `VkPhysicalDeviceFeatures2`, which was added in the `VK_KHR_get_physical_device_properties2` extension and included in Vulkan 1.1. When new features are added in future Vulkan versions or extensions, each extension should introduce one new feature structure, if needed. This structure can be added to the `pNext` chain of the `VkPhysicalDeviceFeatures2` structure.

For convenience, new core versions of Vulkan may introduce new unified feature structures for features promoted from extensions. At the same time, the extension’s original feature structure (if any) is also promoted to the core API, and is an alias of the extension’s structure. This results in multiple names for the same feature: in the original extension’s feature structure and the promoted structure alias, in the unified feature structure. When a feature was implicitly supported and enabled in the extension, but an explicit name was added during promotion, then the extension itself acts as an alias for the feature as listed in the table below.

All aliases of the same feature in the core API must be reported consistently: either all must be reported as supported, or none of them. When a promoted extension is available, any corresponding feature aliases must be supported.

Table 51. Extension Feature Aliases
Extension | Feature(s)
--- | ---
`VK_KHR_shader_draw_parameters` | `shaderDrawParameters`
`VK_KHR_draw_indirect_count` | `drawIndirectCount`
`VK_KHR_sampler_mirror_clamp_to_edge` | `samplerMirrorClampToEdge`
`VK_EXT_descriptor_indexing` | `descriptorIndexing`
`VK_EXT_sampler_filter_minmax` | `samplerFilterMinmax`
`VK_EXT_shader_viewport_index_layer` | `shaderOutputViewportIndex`, `shaderOutputLayer`

To query supported features, call:

    // Provided by VK_VERSION_1_0
    void vkGetPhysicalDeviceFeatures(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceFeatures*                   pFeatures);

- `physicalDevice` is the physical device from which to query the supported features.

- `pFeatures` is a pointer to a VkPhysicalDeviceFeatures structure in which the physical device features are returned. For each feature, a value of `VK_TRUE` specifies that the feature is supported on this physical device, and `VK_FALSE` specifies that the feature is not supported.

Valid Usage (Implicit)

- VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter
  `physicalDevice` must be a valid VkPhysicalDevice handle

- VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter
  `pFeatures` must be a valid pointer to a VkPhysicalDeviceFeatures structure

Fine-grained features used by a logical device must be enabled at `VkDevice` creation time. If a feature is enabled that the physical device does not support, `VkDevice` creation will fail and return `VK_ERROR_FEATURE_NOT_PRESENT`.

The fine-grained features are enabled by passing a pointer to the `VkPhysicalDeviceFeatures` structure via the `pEnabledFeatures` member of the VkDeviceCreateInfo structure that is passed into the `vkCreateDevice` call. If a member of `pEnabledFeatures` is set to `VK_TRUE` or `VK_FALSE`, then the device will be created with the indicated feature enabled or disabled, respectively. Features can also be enabled by using the VkPhysicalDeviceFeatures2 structure.

If an application wishes to enable all features supported by a device, it can simply pass in the `VkPhysicalDeviceFeatures` structure that was previously returned by `vkGetPhysicalDeviceFeatures`. To disable an individual feature, the application can set the desired member to `VK_FALSE` in the same structure. Setting `pEnabledFeatures` to `NULL` and not including a VkPhysicalDeviceFeatures2 in the `pNext` chain of VkDeviceCreateInfo is equivalent to setting all members of the structure to `VK_FALSE`.

| Note Some features, such as `robustBufferAccess`, may incur a runtime performance cost. Application writers should carefully consider the implications of enabling all supported features.

To query supported features defined by the core or extensions, call:

    // Provided by VK_VERSION_1_1
    void vkGetPhysicalDeviceFeatures2(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceFeatures2*                  pFeatures);

or the equivalent command

    // Provided by VK_KHR_get_physical_device_properties2
    void vkGetPhysicalDeviceFeatures2KHR(
        VkPhysicalDevice                            physicalDevice,
        VkPhysicalDeviceFeatures2*                  pFeatures);

- `physicalDevice` is the physical device from which to query the supported features.

- `pFeatures` is a pointer to a VkPhysicalDeviceFeatures2 structure in which the physical device features are returned.

Each structure in `pFeatures` and its `pNext` chain contains members corresponding to fine-grained features. `vkGetPhysicalDeviceFeatures2` writes each member to a boolean value indicating whether that feature is supported.

Valid Usage (Implicit)

- VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter
  `physicalDevice` must be a valid VkPhysicalDevice handle

- VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter
  `pFeatures` must be a valid pointer to a VkPhysicalDeviceFeatures2 structure

The `VkPhysicalDeviceFeatures2` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceFeatures2 {
        VkStructureType             sType;
        void*                       pNext;
        VkPhysicalDeviceFeatures    features;
    } VkPhysicalDeviceFeatures2;

or the equivalent

    // Provided by VK_KHR_get_physical_device_properties2
    typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;

- `sType` is the type of this structure.

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

- `features` is a VkPhysicalDeviceFeatures structure describing the fine-grained features of the Vulkan 1.0 API.

The `pNext` chain of this structure is used to extend the structure with features defined by extensions. This structure can be used in vkGetPhysicalDeviceFeatures2 or can be included in the `pNext` chain of a VkDeviceCreateInfo structure, in which case it controls which features are enabled in the device in lieu of `pEnabledFeatures`.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFeatures2-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2`

The `VkPhysicalDeviceFeatures` structure is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkPhysicalDeviceFeatures {
        VkBool32    robustBufferAccess;
        VkBool32    fullDrawIndexUint32;
        VkBool32    imageCubeArray;
        VkBool32    independentBlend;
        VkBool32    geometryShader;
        VkBool32    tessellationShader;
        VkBool32    sampleRateShading;
        VkBool32    dualSrcBlend;
        VkBool32    logicOp;
        VkBool32    multiDrawIndirect;
        VkBool32    drawIndirectFirstInstance;
        VkBool32    depthClamp;
        VkBool32    depthBiasClamp;
        VkBool32    fillModeNonSolid;
        VkBool32    depthBounds;
        VkBool32    wideLines;
        VkBool32    largePoints;
        VkBool32    alphaToOne;
        VkBool32    multiViewport;
        VkBool32    samplerAnisotropy;
        VkBool32    textureCompressionETC2;
        VkBool32    textureCompressionASTC_LDR;
        VkBool32    textureCompressionBC;
        VkBool32    occlusionQueryPrecise;
        VkBool32    pipelineStatisticsQuery;
        VkBool32    vertexPipelineStoresAndAtomics;
        VkBool32    fragmentStoresAndAtomics;
        VkBool32    shaderTessellationAndGeometryPointSize;
        VkBool32    shaderImageGatherExtended;
        VkBool32    shaderStorageImageExtendedFormats;
        VkBool32    shaderStorageImageMultisample;
        VkBool32    shaderStorageImageReadWithoutFormat;
        VkBool32    shaderStorageImageWriteWithoutFormat;
        VkBool32    shaderUniformBufferArrayDynamicIndexing;
        VkBool32    shaderSampledImageArrayDynamicIndexing;
        VkBool32    shaderStorageBufferArrayDynamicIndexing;
        VkBool32    shaderStorageImageArrayDynamicIndexing;
        VkBool32    shaderClipDistance;
        VkBool32    shaderCullDistance;
        VkBool32    shaderFloat64;
        VkBool32    shaderInt64;
        VkBool32    shaderInt16;
        VkBool32    shaderResourceResidency;
        VkBool32    shaderResourceMinLod;
        VkBool32    sparseBinding;
        VkBool32    sparseResidencyBuffer;
        VkBool32    sparseResidencyImage2D;
        VkBool32    sparseResidencyImage3D;
        VkBool32    sparseResidency2Samples;
        VkBool32    sparseResidency4Samples;
        VkBool32    sparseResidency8Samples;
        VkBool32    sparseResidency16Samples;
        VkBool32    sparseResidencyAliased;
        VkBool32    variableMultisampleRate;
        VkBool32    inheritedQueries;
    } VkPhysicalDeviceFeatures;

This structure describes the following features:

- `robustBufferAccess` specifies that accesses to buffers are bounds-checked against the range of the buffer descriptor (as determined by `VkDescriptorBufferInfo`::`range`, VkBufferViewCreateInfo::`range`, or the size of the buffer). Out of bounds accesses must not cause application termination, and the effects of shader loads, stores, and atomics must conform to an implementation-dependent behavior as described below.

  - A buffer access is considered to be out of bounds if any of the following are true:

    - The pointer was formed by `OpImageTexelPointer` and the coordinate is less than zero or greater than or equal to the number of whole elements in the bound range.

    - The pointer was not formed by `OpImageTexelPointer` and the object pointed to is not wholly contained within the bound range. This includes accesses performed via variable pointers where the buffer descriptor being accessed cannot be statically determined. Uninitialized pointers and pointers equal to `OpConstantNull` are treated as pointing to a zero-sized object, so all accesses through such pointers are considered to be out of bounds. Buffer accesses through buffer device addresses are not bounds-checked. If the `cooperativeMatrixRobustBufferAccess` feature is not enabled, then accesses using `OpCooperativeMatrixLoadNV` and `OpCooperativeMatrixStoreNV` may not be bounds-checked.

      | Note If a SPIR-V `OpLoad` instruction loads a structure and the tail end of the structure is out of bounds, then all members of the structure are considered out of bounds even if the members at the end are not statically used.

    - If `robustBufferAccess2` is not enabled and any buffer access is determined to be out of bounds, then any other access of the same type (load, store, or atomic) to the same buffer that accesses an address less than 16 bytes away from the out of bounds address may also be considered out of bounds.

    - If the access is a load that reads from the same memory locations as a prior store in the same shader invocation, with no other intervening accesses to the same memory locations in that shader invocation, then the result of the load may be the value stored by the store instruction, even if the access is out of bounds. If the load is `Volatile`, then an out of bounds load must return the appropriate out of bounds value.

  - Accesses to descriptors written with a VK_NULL_HANDLE resource or view are not considered to be out of bounds. Instead, each type of descriptor access defines a specific behavior for accesses to a null descriptor.

  - Out-of-bounds buffer loads will return any of the following values:

    - If the access is to a uniform buffer and `robustBufferAccess2` is enabled, loads of offsets between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of robustUniformBufferAccessSizeAlignment bytes must return either zero values or the contents of the memory at the offset being loaded. Loads of offsets past the descriptor range rounded up to a multiple of robustUniformBufferAccessSizeAlignment bytes must return zero values.

    - If the access is to a storage buffer and `robustBufferAccess2` is enabled, loads of offsets between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of robustStorageBufferAccessSizeAlignment bytes must return either zero values or the contents of the memory at the offset being loaded. Loads of offsets past the descriptor range rounded up to a multiple of robustStorageBufferAccessSizeAlignment bytes must return zero values. Similarly, stores to addresses between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of robustStorageBufferAccessSizeAlignment bytes may be discarded.

    - Non-atomic accesses to storage buffers that are a multiple of 32 bits may be decomposed into 32-bit accesses that are individually bounds-checked.

    - If the access is to an index buffer and `robustBufferAccess2` is enabled, zero values must be returned.

    - If the access is to a uniform texel buffer or storage texel buffer and `robustBufferAccess2` is enabled, zero values must be returned, and then Conversion to RGBA is applied based on the buffer view’s format.

    - Values from anywhere within the memory range(s) bound to the buffer (possibly including bytes of memory past the end of the buffer, up to the end of the bound range).

    - Zero values, or (0,0,0,x) vectors for vector reads where x is a valid value represented in the type of the vector components and may be any of:

      - 0, 1, or the maximum representable positive integer value, for signed or unsigned integer components

      - 0.0 or 1.0, for floating-point components

  - Out-of-bounds writes may modify values within the memory range(s) bound to the buffer, but must not modify any other memory.

    - If `robustBufferAccess2` is enabled, out of bounds writes must not modify any memory.

  - Out-of-bounds atomics may modify values within the memory range(s) bound to the buffer, but must not modify any other memory, and return an undefined value.

    - If `robustBufferAccess2` is enabled, out of bounds atomics must not modify any memory, and return an undefined value.

  - If `robustBufferAccess2` is disabled, vertex input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than either:

    - `vertexBufferRangeSize`, if `bindingStride` == 0; or

    - (`vertexBufferRangeSize` - (`vertexBufferRangeSize` % `bindingStride`))

    where `vertexBufferRangeSize` is the byte size of the memory range bound to the vertex buffer binding and `bindingStride` is the byte stride of the corresponding vertex input binding. Further, if any vertex input attribute using a specific vertex input binding is out of bounds, then all vertex input attributes using that vertex input binding for that vertex shader invocation are considered out of bounds.

    - If a vertex input attribute is out of bounds, it will be assigned one of the following values:

      - Values from anywhere within the memory range(s) bound to the buffer, converted according to the format of the attribute.

      - Zero values, format converted according to the format of the attribute.

      - Zero values, or (0,0,0,x) vectors, as described above.

  - If `robustBufferAccess2` is enabled, vertex input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than the byte size of the memory range bound to the vertex buffer binding.

    - If a vertex input attribute is out of bounds, the raw data extracted are zero values, and missing G, B, or A components are filled with (0,0,1).

  - If `robustBufferAccess` is not enabled, applications must not perform out of bounds accesses except under the conditions enabled by the `pipelineRobustness` feature .

- `fullDrawIndexUint32` specifies the full 32-bit range of indices is supported for indexed draw calls when using a VkIndexType of `VK_INDEX_TYPE_UINT32`. `maxDrawIndexedIndexValue` is the maximum index value that may be used (aside from the primitive restart index, which is always 232-1 when the VkIndexType is `VK_INDEX_TYPE_UINT32`). If this feature is supported, `maxDrawIndexedIndexValue` must be 232-1; otherwise it must be no smaller than 224-1. See maxDrawIndexedIndexValue.

- `imageCubeArray` specifies whether image views with a VkImageViewType of `VK_IMAGE_VIEW_TYPE_CUBE_ARRAY` can be created, and that the corresponding `SampledCubeArray` and `ImageCubeArray` SPIR-V capabilities can be used in shader code.

- `independentBlend` specifies whether the `VkPipelineColorBlendAttachmentState` settings are controlled independently per-attachment. If this feature is not enabled, the `VkPipelineColorBlendAttachmentState` settings for all color attachments must be identical. Otherwise, a different `VkPipelineColorBlendAttachmentState` can be provided for each bound color attachment.

- `geometryShader` specifies whether geometry shaders are supported. If this feature is not enabled, the `VK_SHADER_STAGE_GEOMETRY_BIT` and `VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT` enum values must not be used. This also specifies whether shader modules can declare the `Geometry` capability.

- `tessellationShader` specifies whether tessellation control and evaluation shaders are supported. If this feature is not enabled, the `VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT`, `VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT`, `VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT`, `VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT`, and `VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO` enum values must not be used. This also specifies whether shader modules can declare the `Tessellation` capability.

- `sampleRateShading` specifies whether Sample Shading and multisample interpolation are supported. If this feature is not enabled, the `sampleShadingEnable` member of the VkPipelineMultisampleStateCreateInfo structure must be set to `VK_FALSE` and the `minSampleShading` member is ignored. This also specifies whether shader modules can declare the `SampleRateShading` capability.

- `dualSrcBlend` specifies whether blend operations which take two sources are supported. If this feature is not enabled, the `VK_BLEND_FACTOR_SRC1_COLOR`, `VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR`, `VK_BLEND_FACTOR_SRC1_ALPHA`, and `VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA` enum values must not be used as source or destination blending factors. See Dual-Source Blending.

- `logicOp` specifies whether logic operations are supported. If this feature is not enabled, the `logicOpEnable` member of the VkPipelineColorBlendStateCreateInfo structure must be set to `VK_FALSE`, and the `logicOp` member is ignored.

- `multiDrawIndirect` specifies whether multiple draw indirect is supported. If this feature is not enabled, the `drawCount` parameter to the `vkCmdDrawIndirect` and `vkCmdDrawIndexedIndirect` commands must be 0 or 1. The `maxDrawIndirectCount` member of the `VkPhysicalDeviceLimits` structure must also be 1 if this feature is not supported. See maxDrawIndirectCount.

- `drawIndirectFirstInstance` specifies whether indirect drawing calls support the `firstInstance` parameter. If this feature is not enabled, the `firstInstance` member of all `VkDrawIndirectCommand` and `VkDrawIndexedIndirectCommand` structures that are provided to the `vkCmdDrawIndirect` and `vkCmdDrawIndexedIndirect` commands must be 0.

- `depthClamp` specifies whether depth clamping is supported. If this feature is not enabled, the `depthClampEnable` member of the VkPipelineRasterizationStateCreateInfo structure must be set to `VK_FALSE`. Otherwise, setting `depthClampEnable` to `VK_TRUE` will enable depth clamping.

- `depthBiasClamp` specifies whether depth bias clamping is supported. If this feature is not enabled, the `depthBiasClamp` member of the VkPipelineRasterizationStateCreateInfo structure must be set to 0.0 unless the `VK_DYNAMIC_STATE_DEPTH_BIAS` dynamic state is enabled, and the `depthBiasClamp` parameter to `vkCmdSetDepthBias` must be set to 0.0.

- `fillModeNonSolid` specifies whether point and wireframe fill modes are supported. If this feature is not enabled, the `VK_POLYGON_MODE_POINT` and `VK_POLYGON_MODE_LINE` enum values must not be used.

- `depthBounds` specifies whether depth bounds tests are supported. If this feature is not enabled, the `depthBoundsTestEnable` member of the VkPipelineDepthStencilStateCreateInfo structure must be set to `VK_FALSE`. When `depthBoundsTestEnable` is set to `VK_FALSE`, the `minDepthBounds` and `maxDepthBounds` members of the VkPipelineDepthStencilStateCreateInfo structure are ignored.

- `wideLines` specifies whether lines with width other than 1.0 are supported. If this feature is not enabled, the `lineWidth` member of the VkPipelineRasterizationStateCreateInfo structure must be set to 1.0 unless the `VK_DYNAMIC_STATE_LINE_WIDTH` dynamic state is enabled, and the `lineWidth` parameter to `vkCmdSetLineWidth` must be set to 1.0. When this feature is supported, the range and granularity of supported line widths are indicated by the `lineWidthRange` and `lineWidthGranularity` members of the `VkPhysicalDeviceLimits` structure, respectively.

- `largePoints` specifies whether points with size greater than 1.0 are supported. If this feature is not enabled, only a point size of 1.0 written by a shader is supported. The range and granularity of supported point sizes are indicated by the `pointSizeRange` and `pointSizeGranularity` members of the `VkPhysicalDeviceLimits` structure, respectively.

- `alphaToOne` specifies whether the implementation is able to replace the alpha value of the fragment shader color output in the Multisample Coverage fragment operation. If this feature is not enabled, then the `alphaToOneEnable` member of the VkPipelineMultisampleStateCreateInfo structure must be set to `VK_FALSE`. Otherwise setting `alphaToOneEnable` to `VK_TRUE` will enable alpha-to-one behavior.

- `multiViewport` specifies whether more than one viewport is supported. If this feature is not enabled:

  - The `viewportCount` and `scissorCount` members of the VkPipelineViewportStateCreateInfo structure must be set to 1.

  - The `firstViewport` and `viewportCount` parameters to the `vkCmdSetViewport` command must be set to 0 and 1, respectively.

  - The `firstScissor` and `scissorCount` parameters to the `vkCmdSetScissor` command must be set to 0 and 1, respectively.

  - The `exclusiveScissorCount` member of the VkPipelineViewportExclusiveScissorStateCreateInfoNV structure must be set to 0 or 1.

  - The `firstExclusiveScissor` and `exclusiveScissorCount` parameters to the `vkCmdSetExclusiveScissorNV` command must be set to 0 and 1, respectively.

- `samplerAnisotropy` specifies whether anisotropic filtering is supported. If this feature is not enabled, the `anisotropyEnable` member of the VkSamplerCreateInfo structure must be `VK_FALSE`.

- `textureCompressionETC2` specifies whether all of the ETC2 and EAC compressed texture formats are supported. If this feature is enabled, then the `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`, `VK_FORMAT_FEATURE_BLIT_SRC_BIT` and `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT` features must be supported in `optimalTilingFeatures` for the following formats:

  - `VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK`

  - `VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK`

  - `VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK`

  - `VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK`

  - `VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK`

  - `VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK`

  - `VK_FORMAT_EAC_R11_UNORM_BLOCK`

  - `VK_FORMAT_EAC_R11_SNORM_BLOCK`

  - `VK_FORMAT_EAC_R11G11_UNORM_BLOCK`

  - `VK_FORMAT_EAC_R11G11_SNORM_BLOCK`

  To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.

- `textureCompressionASTC_LDR` specifies whether all of the ASTC LDR compressed texture formats are supported. If this feature is enabled, then the `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`, `VK_FORMAT_FEATURE_BLIT_SRC_BIT` and `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT` features must be supported in `optimalTilingFeatures` for the following formats:

  - `VK_FORMAT_ASTC_4x4_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_4x4_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_5x4_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_5x4_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_5x5_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_5x5_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_6x5_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_6x5_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_6x6_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_6x6_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_8x5_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_8x5_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_8x6_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_8x6_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_8x8_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_8x8_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_10x5_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_10x5_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_10x6_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_10x6_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_10x8_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_10x8_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_10x10_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_10x10_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_12x10_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_12x10_SRGB_BLOCK`

  - `VK_FORMAT_ASTC_12x12_UNORM_BLOCK`

  - `VK_FORMAT_ASTC_12x12_SRGB_BLOCK`

  To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.

- `textureCompressionBC` specifies whether all of the BC compressed texture formats are supported. If this feature is enabled, then the `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`, `VK_FORMAT_FEATURE_BLIT_SRC_BIT` and `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT` features must be supported in `optimalTilingFeatures` for the following formats:

  - `VK_FORMAT_BC1_RGB_UNORM_BLOCK`

  - `VK_FORMAT_BC1_RGB_SRGB_BLOCK`

  - `VK_FORMAT_BC1_RGBA_UNORM_BLOCK`

  - `VK_FORMAT_BC1_RGBA_SRGB_BLOCK`

  - `VK_FORMAT_BC2_UNORM_BLOCK`

  - `VK_FORMAT_BC2_SRGB_BLOCK`

  - `VK_FORMAT_BC3_UNORM_BLOCK`

  - `VK_FORMAT_BC3_SRGB_BLOCK`

  - `VK_FORMAT_BC4_UNORM_BLOCK`

  - `VK_FORMAT_BC4_SNORM_BLOCK`

  - `VK_FORMAT_BC5_UNORM_BLOCK`

  - `VK_FORMAT_BC5_SNORM_BLOCK`

  - `VK_FORMAT_BC6H_UFLOAT_BLOCK`

  - `VK_FORMAT_BC6H_SFLOAT_BLOCK`

  - `VK_FORMAT_BC7_UNORM_BLOCK`

  - `VK_FORMAT_BC7_SRGB_BLOCK`

  To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.

- `occlusionQueryPrecise` specifies whether occlusion queries returning actual sample counts are supported. Occlusion queries are created in a `VkQueryPool` by specifying the `queryType` of `VK_QUERY_TYPE_OCCLUSION` in the VkQueryPoolCreateInfo structure which is passed to `vkCreateQueryPool`. If this feature is enabled, queries of this type can enable `VK_QUERY_CONTROL_PRECISE_BIT` in the `flags` parameter to `vkCmdBeginQuery`. If this feature is not supported, the implementation supports only boolean occlusion queries. When any samples are passed, boolean queries will return a non-zero result value, otherwise a result value of zero is returned. When this feature is enabled and `VK_QUERY_CONTROL_PRECISE_BIT` is set, occlusion queries will report the actual number of samples passed.

- `pipelineStatisticsQuery` specifies whether the pipeline statistics queries are supported. If this feature is not enabled, queries of type `VK_QUERY_TYPE_PIPELINE_STATISTICS` cannot be created, and none of the VkQueryPipelineStatisticFlagBits bits can be set in the `pipelineStatistics` member of the VkQueryPoolCreateInfo structure.

- `vertexPipelineStoresAndAtomics` specifies whether storage buffers and images support stores and atomic operations in the vertex, tessellation, and geometry shader stages. If this feature is not enabled, all storage image, storage texel buffer, and storage buffer variables used by these stages in shader modules must be decorated with the `NonWritable` decoration (or the `readonly` memory qualifier in GLSL).

- `fragmentStoresAndAtomics` specifies whether storage buffers and images support stores and atomic operations in the fragment shader stage. If this feature is not enabled, all storage image, storage texel buffer, and storage buffer variables used by the fragment stage in shader modules must be decorated with the `NonWritable` decoration (or the `readonly` memory qualifier in GLSL).

- `shaderTessellationAndGeometryPointSize` specifies whether the `PointSize` built-in decoration is available in the tessellation control, tessellation evaluation, and geometry shader stages. If this feature is not enabled, members decorated with the `PointSize` built-in decoration must not be read from or written to and all points written from a tessellation or geometry shader will have a size of 1.0. This also specifies whether shader modules can declare the `TessellationPointSize` capability for tessellation control and evaluation shaders, or if the shader modules can declare the `GeometryPointSize` capability for geometry shaders. An implementation supporting this feature must also support one or both of the `tessellationShader` or `geometryShader` features.

- `shaderImageGatherExtended` specifies whether the extended set of image gather instructions are available in shader code. If this feature is not enabled, the `OpImage*Gather` instructions do not support the `Offset` and `ConstOffsets` operands. This also specifies whether shader modules can declare the `ImageGatherExtended` capability.

- `shaderStorageImageExtendedFormats` specifies whether all the “storage image extended formats” below are supported; if this feature is supported, then the `VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT` must be supported in `optimalTilingFeatures` for the following formats:

  - `VK_FORMAT_R16G16_SFLOAT`

  - `VK_FORMAT_B10G11R11_UFLOAT_PACK32`

  - `VK_FORMAT_R16_SFLOAT`

  - `VK_FORMAT_R16G16B16A16_UNORM`

  - `VK_FORMAT_A2B10G10R10_UNORM_PACK32`

  - `VK_FORMAT_R16G16_UNORM`

  - `VK_FORMAT_R8G8_UNORM`

  - `VK_FORMAT_R16_UNORM`

  - `VK_FORMAT_R8_UNORM`

  - `VK_FORMAT_R16G16B16A16_SNORM`

  - `VK_FORMAT_R16G16_SNORM`

  - `VK_FORMAT_R8G8_SNORM`

  - `VK_FORMAT_R16_SNORM`

  - `VK_FORMAT_R8_SNORM`

  - `VK_FORMAT_R16G16_SINT`

  - `VK_FORMAT_R8G8_SINT`

  - `VK_FORMAT_R16_SINT`

  - `VK_FORMAT_R8_SINT`

  - `VK_FORMAT_A2B10G10R10_UINT_PACK32`

  - `VK_FORMAT_R16G16_UINT`

  - `VK_FORMAT_R8G8_UINT`

  - `VK_FORMAT_R16_UINT`

  - `VK_FORMAT_R8_UINT`

  | Note `shaderStorageImageExtendedFormats` feature only adds a guarantee of format support, which is specified for the whole physical device. Therefore enabling or disabling the feature via vkCreateDevice has no practical effect. To query for additional properties, or if the feature is not supported, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats, as usual rules allow. `VK_FORMAT_R32G32_UINT`, `VK_FORMAT_R32G32_SINT`, and `VK_FORMAT_R32G32_SFLOAT` from `StorageImageExtendedFormats` SPIR-V capability, are already covered by core Vulkan mandatory format support.

- `shaderStorageImageMultisample` specifies whether multisampled storage images are supported. If this feature is not enabled, images that are created with a `usage` that includes `VK_IMAGE_USAGE_STORAGE_BIT` must be created with `samples` equal to `VK_SAMPLE_COUNT_1_BIT`. This also specifies whether shader modules can declare the `StorageImageMultisample` and `ImageMSArray` capabilities.

- `shaderStorageImageReadWithoutFormat` specifies whether storage images require a format qualifier to be specified when reading. `shaderStorageImageReadWithoutFormat` applies only to formats listed in the storage without format list.

- `shaderStorageImageWriteWithoutFormat` specifies whether storage images require a format qualifier to be specified when writing. `shaderStorageImageWriteWithoutFormat` applies only to formats listed in the storage without format list.

- `shaderUniformBufferArrayDynamicIndexing` specifies whether arrays of uniform buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` or `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the `UniformBufferArrayDynamicIndexing` capability.

- `shaderSampledImageArrayDynamicIndexing` specifies whether arrays of samplers or sampled images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_SAMPLER`, `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`, or `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the `SampledImageArrayDynamicIndexing` capability.

- `shaderStorageBufferArrayDynamicIndexing` specifies whether arrays of storage buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` or `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the `StorageBufferArrayDynamicIndexing` capability.

- `shaderStorageImageArrayDynamicIndexing` specifies whether arrays of storage images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the `StorageImageArrayDynamicIndexing` capability.

- `shaderClipDistance` specifies whether clip distances are supported in shader code. If this feature is not enabled, any members decorated with the `ClipDistance` built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare the `ClipDistance` capability.

- `shaderCullDistance` specifies whether cull distances are supported in shader code. If this feature is not enabled, any members decorated with the `CullDistance` built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare the `CullDistance` capability.

- `shaderFloat64` specifies whether 64-bit floats (doubles) are supported in shader code. If this feature is not enabled, 64-bit floating-point types must not be used in shader code. This also specifies whether shader modules can declare the `Float64` capability. Declaring and using 64-bit floats is enabled for all storage classes that SPIR-V allows with the `Float64` capability.

- `shaderInt64` specifies whether 64-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 64-bit integer types must not be used in shader code. This also specifies whether shader modules can declare the `Int64` capability. Declaring and using 64-bit integers is enabled for all storage classes that SPIR-V allows with the `Int64` capability.

- `shaderInt16` specifies whether 16-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 16-bit integer types must not be used in shader code. This also specifies whether shader modules can declare the `Int16` capability. However, this only enables a subset of the storage classes that SPIR-V allows for the `Int16` SPIR-V capability: Declaring and using 16-bit integers in the `Private`, `Workgroup` (for non-Block variables), and `Function` storage classes is enabled, while declaring them in the interface storage classes (e.g., `UniformConstant`, `Uniform`, `StorageBuffer`, `Input`, `Output`, and `PushConstant`) is not enabled.

- `shaderResourceResidency` specifies whether image operations that return resource residency information are supported in shader code. If this feature is not enabled, the `OpImageSparse*` instructions must not be used in shader code. This also specifies whether shader modules can declare the `SparseResidency` capability. The feature requires at least one of the `sparseResidency*` features to be supported.

- `shaderResourceMinLod` specifies whether image operations specifying the minimum resource LOD are supported in shader code. If this feature is not enabled, the `MinLod` image operand must not be used in shader code. This also specifies whether shader modules can declare the `MinLod` capability.

- `sparseBinding` specifies whether resource memory can be managed at opaque sparse block level instead of at the object level. If this feature is not enabled, resource memory must be bound only on a per-object basis using the `vkBindBufferMemory` and `vkBindImageMemory` commands. In this case, buffers and images must not be created with `VK_BUFFER_CREATE_SPARSE_BINDING_BIT` and `VK_IMAGE_CREATE_SPARSE_BINDING_BIT` set in the `flags` member of the VkBufferCreateInfo and VkImageCreateInfo structures, respectively. Otherwise resource memory can be managed as described in Sparse Resource Features.

- `sparseResidencyBuffer` specifies whether the device can access partially resident buffers. If this feature is not enabled, buffers must not be created with `VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT` set in the `flags` member of the VkBufferCreateInfo structure.

- `sparseResidencyImage2D` specifies whether the device can access partially resident 2D images with 1 sample per pixel. If this feature is not enabled, images with an `imageType` of `VK_IMAGE_TYPE_2D` and `samples` set to `VK_SAMPLE_COUNT_1_BIT` must not be created with `VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT` set in the `flags` member of the VkImageCreateInfo structure.

- `sparseResidencyImage3D` specifies whether the device can access partially resident 3D images. If this feature is not enabled, images with an `imageType` of `VK_IMAGE_TYPE_3D` must not be created with `VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT` set in the `flags` member of the VkImageCreateInfo structure.

- `sparseResidency2Samples` specifies whether the physical device can access partially resident 2D images with 2 samples per pixel. If this feature is not enabled, images with an `imageType` of `VK_IMAGE_TYPE_2D` and `samples` set to `VK_SAMPLE_COUNT_2_BIT` must not be created with `VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT` set in the `flags` member of the VkImageCreateInfo structure.

- `sparseResidency4Samples` specifies whether the physical device can access partially resident 2D images with 4 samples per pixel. If this feature is not enabled, images with an `imageType` of `VK_IMAGE_TYPE_2D` and `samples` set to `VK_SAMPLE_COUNT_4_BIT` must not be created with `VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT` set in the `flags` member of the VkImageCreateInfo structure.

- `sparseResidency8Samples` specifies whether the physical device can access partially resident 2D images with 8 samples per pixel. If this feature is not enabled, images with an `imageType` of `VK_IMAGE_TYPE_2D` and `samples` set to `VK_SAMPLE_COUNT_8_BIT` must not be created with `VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT` set in the `flags` member of the VkImageCreateInfo structure.

- `sparseResidency16Samples` specifies whether the physical device can access partially resident 2D images with 16 samples per pixel. If this feature is not enabled, images with an `imageType` of `VK_IMAGE_TYPE_2D` and `samples` set to `VK_SAMPLE_COUNT_16_BIT` must not be created with `VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT` set in the `flags` member of the VkImageCreateInfo structure.

- `sparseResidencyAliased` specifies whether the physical device can correctly access data aliased into multiple locations. If this feature is not enabled, the `VK_BUFFER_CREATE_SPARSE_ALIASED_BIT` and `VK_IMAGE_CREATE_SPARSE_ALIASED_BIT` enum values must not be used in `flags` members of the VkBufferCreateInfo and VkImageCreateInfo structures, respectively.

- `variableMultisampleRate` specifies whether all pipelines that will be bound to a command buffer during a subpass which uses no attachments must have the same value for VkPipelineMultisampleStateCreateInfo::`rasterizationSamples`. If set to `VK_TRUE`, the implementation supports variable multisample rates in a subpass which uses no attachments. If set to `VK_FALSE`, then all pipelines bound in such a subpass must have the same multisample rate. This has no effect in situations where a subpass uses any attachments.

- `inheritedQueries` specifies whether a secondary command buffer may be executed while a query is active.

The `VkPhysicalDeviceVulkan11Features` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceVulkan11Features {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           storageBuffer16BitAccess;
        VkBool32           uniformAndStorageBuffer16BitAccess;
        VkBool32           storagePushConstant16;
        VkBool32           storageInputOutput16;
        VkBool32           multiview;
        VkBool32           multiviewGeometryShader;
        VkBool32           multiviewTessellationShader;
        VkBool32           variablePointersStorageBuffer;
        VkBool32           variablePointers;
        VkBool32           protectedMemory;
        VkBool32           samplerYcbcrConversion;
        VkBool32           shaderDrawParameters;
    } VkPhysicalDeviceVulkan11Features;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `storageBuffer16BitAccess` specifies whether objects in the `StorageBuffer`, `ShaderRecordBufferKHR`, or `PhysicalStorageBuffer` storage class with the `Block` decoration can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the `StorageBuffer16BitAccess` capability.

- `uniformAndStorageBuffer16BitAccess` specifies whether objects in the `Uniform` storage class with the `Block` decoration can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the `UniformAndStorageBuffer16BitAccess` capability.

- `storagePushConstant16` specifies whether objects in the `PushConstant` storage class can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or floating-point members must not be used in such objects. This also specifies whether shader modules can declare the `StoragePushConstant16` capability.

- `storageInputOutput16` specifies whether objects in the `Input` and `Output` storage classes can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the `StorageInputOutput16` capability.

- `multiview` specifies whether the implementation supports multiview rendering within a render pass. If this feature is not enabled, the view mask of each subpass must always be zero.

- `multiviewGeometryShader` specifies whether the implementation supports multiview rendering within a render pass, with geometry shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must not include a geometry shader.

- `multiviewTessellationShader` specifies whether the implementation supports multiview rendering within a render pass, with tessellation shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must not include any tessellation shaders.

- `variablePointersStorageBuffer` specifies whether the implementation supports the SPIR-V `VariablePointersStorageBuffer` capability. When this feature is not enabled, shader modules must not declare the `SPV_KHR_variable_pointers` extension or the `VariablePointersStorageBuffer` capability.

- `variablePointers` specifies whether the implementation supports the SPIR-V `VariablePointers` capability. When this feature is not enabled, shader modules must not declare the `VariablePointers` capability.

- `protectedMemory` specifies whether protected memory is supported.

- `samplerYcbcrConversion` specifies whether the implementation supports sampler Y′CBCR conversion. If `samplerYcbcrConversion` is `VK_FALSE`, sampler Y′CBCR conversion is not supported, and samplers using sampler Y′CBCR conversion must not be used.

- `shaderDrawParameters` specifies whether the implementation supports the SPIR-V `DrawParameters` capability. When this feature is not enabled, shader modules must not declare the `SPV_KHR_shader_draw_parameters` extension or the `DrawParameters` capability.

If the `VkPhysicalDeviceVulkan11Features` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceVulkan11Features` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceVulkan11Features-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES`

The `VkPhysicalDeviceVulkan12Features` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceVulkan12Features {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           samplerMirrorClampToEdge;
        VkBool32           drawIndirectCount;
        VkBool32           storageBuffer8BitAccess;
        VkBool32           uniformAndStorageBuffer8BitAccess;
        VkBool32           storagePushConstant8;
        VkBool32           shaderBufferInt64Atomics;
        VkBool32           shaderSharedInt64Atomics;
        VkBool32           shaderFloat16;
        VkBool32           shaderInt8;
        VkBool32           descriptorIndexing;
        VkBool32           shaderInputAttachmentArrayDynamicIndexing;
        VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
        VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
        VkBool32           shaderUniformBufferArrayNonUniformIndexing;
        VkBool32           shaderSampledImageArrayNonUniformIndexing;
        VkBool32           shaderStorageBufferArrayNonUniformIndexing;
        VkBool32           shaderStorageImageArrayNonUniformIndexing;
        VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
        VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
        VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
        VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
        VkBool32           descriptorBindingSampledImageUpdateAfterBind;
        VkBool32           descriptorBindingStorageImageUpdateAfterBind;
        VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
        VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
        VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
        VkBool32           descriptorBindingUpdateUnusedWhilePending;
        VkBool32           descriptorBindingPartiallyBound;
        VkBool32           descriptorBindingVariableDescriptorCount;
        VkBool32           runtimeDescriptorArray;
        VkBool32           samplerFilterMinmax;
        VkBool32           scalarBlockLayout;
        VkBool32           imagelessFramebuffer;
        VkBool32           uniformBufferStandardLayout;
        VkBool32           shaderSubgroupExtendedTypes;
        VkBool32           separateDepthStencilLayouts;
        VkBool32           hostQueryReset;
        VkBool32           timelineSemaphore;
        VkBool32           bufferDeviceAddress;
        VkBool32           bufferDeviceAddressCaptureReplay;
        VkBool32           bufferDeviceAddressMultiDevice;
        VkBool32           vulkanMemoryModel;
        VkBool32           vulkanMemoryModelDeviceScope;
        VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
        VkBool32           shaderOutputViewportIndex;
        VkBool32           shaderOutputLayer;
        VkBool32           subgroupBroadcastDynamicId;
    } VkPhysicalDeviceVulkan12Features;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `samplerMirrorClampToEdge` indicates whether the implementation supports the `VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE` sampler address mode. If this feature is not enabled, the `VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE` sampler address mode must not be used.

- `drawIndirectCount` indicates whether the implementation supports the vkCmdDrawIndirectCount and vkCmdDrawIndexedIndirectCount functions. If this feature is not enabled, these functions must not be used.

- `storageBuffer8BitAccess` indicates whether objects in the `StorageBuffer`, `ShaderRecordBufferKHR`, or `PhysicalStorageBuffer` storage class with the `Block` decoration can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the `StorageBuffer8BitAccess` capability.

- `uniformAndStorageBuffer8BitAccess` indicates whether objects in the `Uniform` storage class with the `Block` decoration can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the `UniformAndStorageBuffer8BitAccess` capability.

- `storagePushConstant8` indicates whether objects in the `PushConstant` storage class can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the `StoragePushConstant8` capability.

- `shaderBufferInt64Atomics` indicates whether shaders can perform 64-bit unsigned and signed integer atomic operations on buffers.

- `shaderSharedInt64Atomics` indicates whether shaders can perform 64-bit unsigned and signed integer atomic operations on shared and payload memory.

- `shaderFloat16` indicates whether 16-bit floats (halfs) are supported in shader code. This also indicates whether shader modules can declare the `Float16` capability. However, this only enables a subset of the storage classes that SPIR-V allows for the `Float16` SPIR-V capability: Declaring and using 16-bit floats in the `Private`, `Workgroup` (for non-Block variables), and `Function` storage classes is enabled, while declaring them in the interface storage classes (e.g., `UniformConstant`, `Uniform`, `StorageBuffer`, `Input`, `Output`, and `PushConstant`) is not enabled.

- `shaderInt8` indicates whether 8-bit integers (signed and unsigned) are supported in shader code. This also indicates whether shader modules can declare the `Int8` capability. However, this only enables a subset of the storage classes that SPIR-V allows for the `Int8` SPIR-V capability: Declaring and using 8-bit integers in the `Private`, `Workgroup` (for non-Block variables), and `Function` storage classes is enabled, while declaring them in the interface storage classes (e.g., `UniformConstant`, `Uniform`, `StorageBuffer`, `Input`, `Output`, and `PushConstant`) is not enabled.

- `descriptorIndexing` indicates whether the implementation supports the minimum set of descriptor indexing features as described in the Feature Requirements section. Enabling the `descriptorIndexing` member when vkCreateDevice is called does not imply the other minimum descriptor indexing features are also enabled. Those other descriptor indexing features must be enabled individually as needed by the application.

- `shaderInputAttachmentArrayDynamicIndexing` indicates whether arrays of input attachments can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `InputAttachmentArrayDynamicIndexing` capability.

- `shaderUniformTexelBufferArrayDynamicIndexing` indicates whether arrays of uniform texel buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `UniformTexelBufferArrayDynamicIndexing` capability.

- `shaderStorageTexelBufferArrayDynamicIndexing` indicates whether arrays of storage texel buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `StorageTexelBufferArrayDynamicIndexing` capability.

- `shaderUniformBufferArrayNonUniformIndexing` indicates whether arrays of uniform buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` or `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `UniformBufferArrayNonUniformIndexing` capability.

- `shaderSampledImageArrayNonUniformIndexing` indicates whether arrays of samplers or sampled images can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_SAMPLER`, `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`, or `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `SampledImageArrayNonUniformIndexing` capability.

- `shaderStorageBufferArrayNonUniformIndexing` indicates whether arrays of storage buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` or `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `StorageBufferArrayNonUniformIndexing` capability.

- `shaderStorageImageArrayNonUniformIndexing` indicates whether arrays of storage images can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `StorageImageArrayNonUniformIndexing` capability.

- `shaderInputAttachmentArrayNonUniformIndexing` indicates whether arrays of input attachments can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `InputAttachmentArrayNonUniformIndexing` capability.

- `shaderUniformTexelBufferArrayNonUniformIndexing` indicates whether arrays of uniform texel buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `UniformTexelBufferArrayNonUniformIndexing` capability.

- `shaderStorageTexelBufferArrayNonUniformIndexing` indicates whether arrays of storage texel buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `StorageTexelBufferArrayNonUniformIndexing` capability.

- `descriptorBindingUniformBufferUpdateAfterBind` indicates whether the implementation supports updating uniform buffer descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER`.

- `descriptorBindingSampledImageUpdateAfterBind` indicates whether the implementation supports updating sampled image descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_SAMPLER`, `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`, or `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE`.

- `descriptorBindingStorageImageUpdateAfterBind` indicates whether the implementation supports updating storage image descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE`.

- `descriptorBindingStorageBufferUpdateAfterBind` indicates whether the implementation supports updating storage buffer descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER`.

- `descriptorBindingUniformTexelBufferUpdateAfterBind` indicates whether the implementation supports updating uniform texel buffer descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER`.

- `descriptorBindingStorageTexelBufferUpdateAfterBind` indicates whether the implementation supports updating storage texel buffer descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER`.

- `descriptorBindingUpdateUnusedWhilePending` indicates whether the implementation supports updating descriptors while the set is in use. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT` must not be used.

- `descriptorBindingPartiallyBound` indicates whether the implementation supports statically using a descriptor set binding in which some descriptors are not valid. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT` must not be used.

- `descriptorBindingVariableDescriptorCount` indicates whether the implementation supports descriptor sets with a variable-sized last binding. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT` must not be used.

- `runtimeDescriptorArray` indicates whether the implementation supports the SPIR-V `RuntimeDescriptorArray` capability. If this feature is not enabled, descriptors must not be declared in runtime arrays.

- `samplerFilterMinmax` indicates whether the implementation supports a minimum set of required formats supporting min/max filtering as defined by the `filterMinmaxSingleComponentFormats` property minimum requirements. If this feature is not enabled, then VkSamplerReductionModeCreateInfo must only use `VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE`.

- `scalarBlockLayout` indicates that the implementation supports the layout of resource blocks in shaders using scalar alignment.

- `imagelessFramebuffer` indicates that the implementation supports specifying the image view for attachments at render pass begin time via VkRenderPassAttachmentBeginInfo.

- `uniformBufferStandardLayout` indicates that the implementation supports the same layouts for uniform buffers as for storage and other kinds of buffers. See Standard Buffer Layout.

- `shaderSubgroupExtendedTypes` is a boolean specifying whether subgroup operations can use 8-bit integer, 16-bit integer, 64-bit integer, 16-bit floating-point, and vectors of these types in group operations with subgroup scope, if the implementation supports the types.

- `separateDepthStencilLayouts` indicates whether the implementation supports a `VkImageMemoryBarrier` for a depth/stencil image with only one of `VK_IMAGE_ASPECT_DEPTH_BIT` or `VK_IMAGE_ASPECT_STENCIL_BIT` set, and whether `VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL`, `VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL`, `VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL`, or `VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL` can be used.

- `hostQueryReset` indicates that the implementation supports resetting queries from the host with vkResetQueryPool.

- `timelineSemaphore` indicates whether semaphores created with a VkSemaphoreType of `VK_SEMAPHORE_TYPE_TIMELINE` are supported.

- `bufferDeviceAddress` indicates that the implementation supports accessing buffer memory in shaders as storage buffers via an address queried from vkGetBufferDeviceAddress.

- `bufferDeviceAddressCaptureReplay` indicates that the implementation supports saving and reusing buffer and device addresses, e.g. for trace capture and replay.

- `bufferDeviceAddressMultiDevice` indicates that the implementation supports the `bufferDeviceAddress` , `rayTracingPipeline` and `rayQuery` features for logical devices created with multiple physical devices. If this feature is not supported, buffer and acceleration structure addresses must not be queried on a logical device created with more than one physical device.

- `vulkanMemoryModel` indicates whether the Vulkan Memory Model is supported, as defined in Vulkan Memory Model. This also indicates whether shader modules can declare the `VulkanMemoryModel` capability.

- `vulkanMemoryModelDeviceScope` indicates whether the Vulkan Memory Model can use `Device` scope synchronization. This also indicates whether shader modules can declare the `VulkanMemoryModelDeviceScope` capability.

- `vulkanMemoryModelAvailabilityVisibilityChains` indicates whether the Vulkan Memory Model can use availability and visibility chains with more than one element.

- `shaderOutputViewportIndex` indicates whether the implementation supports the `ShaderViewportIndex` SPIR-V capability enabling variables decorated with the `ViewportIndex` built-in to be exported from mesh, vertex or tessellation evaluation shaders. If this feature is not enabled, the `ViewportIndex` built-in decoration must not be used on outputs in mesh, vertex or tessellation evaluation shaders.

- `shaderOutputLayer` indicates whether the implementation supports the `ShaderLayer` SPIR-V capability enabling variables decorated with the `Layer` built-in to be exported from mesh, vertex or tessellation evaluation shaders. If this feature is not enabled, the `Layer` built-in decoration must not be used on outputs in mesh, vertex or tessellation evaluation shaders.

- If `subgroupBroadcastDynamicId` is `VK_TRUE`, the “Id” operand of `OpGroupNonUniformBroadcast` can be dynamically uniform within a subgroup, and the “Index” operand of `OpGroupNonUniformQuadBroadcast` can be dynamically uniform within the derivative group. If it is `VK_FALSE`, these operands must be constants.

If the `VkPhysicalDeviceVulkan12Features` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceVulkan12Features` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceVulkan12Features-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES`

The `VkPhysicalDeviceVulkan13Features` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceVulkan13Features {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           robustImageAccess;
        VkBool32           inlineUniformBlock;
        VkBool32           descriptorBindingInlineUniformBlockUpdateAfterBind;
        VkBool32           pipelineCreationCacheControl;
        VkBool32           privateData;
        VkBool32           shaderDemoteToHelperInvocation;
        VkBool32           shaderTerminateInvocation;
        VkBool32           subgroupSizeControl;
        VkBool32           computeFullSubgroups;
        VkBool32           synchronization2;
        VkBool32           textureCompressionASTC_HDR;
        VkBool32           shaderZeroInitializeWorkgroupMemory;
        VkBool32           dynamicRendering;
        VkBool32           shaderIntegerDotProduct;
        VkBool32           maintenance4;
    } VkPhysicalDeviceVulkan13Features;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `robustImageAccess` indicates whether image accesses are tightly bounds-checked against the dimensions of the image view. Invalid texels resulting from out of bounds image loads will be replaced as described in Texel Replacement, with either (0,0,1) or (0,0,0) values inserted for missing G, B, or A components based on the format.

- `inlineUniformBlock` indicates whether the implementation supports inline uniform block descriptors. If this feature is not enabled, `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK` must not be used.

- `descriptorBindingInlineUniformBlockUpdateAfterBind` indicates whether the implementation supports updating inline uniform block descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK`.

- `pipelineCreationCacheControl` indicates that the implementation supports:

  - The following can be used in `Vk*PipelineCreateInfo`::`flags`:

    - `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT`

    - `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT`

  - The following can be used in VkPipelineCacheCreateInfo::`flags`:

    - `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT`

- `privateData` indicates whether the implementation supports private data. See Private Data.

- `shaderDemoteToHelperInvocation` indicates whether the implementation supports the SPIR-V `DemoteToHelperInvocationEXT` capability.

- `shaderTerminateInvocation` specifies whether the implementation supports SPIR-V modules that use the `SPV_KHR_terminate_invocation` extension.

- `subgroupSizeControl` indicates whether the implementation supports controlling shader subgroup sizes via the `VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT` flag and the VkPipelineShaderStageRequiredSubgroupSizeCreateInfo structure.

- `computeFullSubgroups` indicates whether the implementation supports requiring full subgroups in compute , mesh, or task shaders via the `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT` flag.

- `synchronization2` indicates whether the implementation supports the new set of synchronization commands introduced in `VK_KHR_synchronization2`.

- `textureCompressionASTC_HDR` indicates whether all of the ASTC HDR compressed texture formats are supported. If this feature is enabled, then the `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`, `VK_FORMAT_FEATURE_BLIT_SRC_BIT` and `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT` features must be supported in `optimalTilingFeatures` for the following formats:

  - `VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK`

  To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.

- `shaderZeroInitializeWorkgroupMemory` specifies whether the implementation supports initializing a variable in Workgroup storage class.

- `dynamicRendering` specifies that the implementation supports dynamic render pass instances using the vkCmdBeginRendering command.

- `shaderIntegerDotProduct` specifies whether shader modules can declare the `DotProductInputAllKHR`, `DotProductInput4x8BitKHR`, `DotProductInput4x8BitPackedKHR` and `DotProductKHR` capabilities.

- `maintenance4` indicates that the implementation supports the following:

  - The application may destroy a VkPipelineLayout object immediately after using it to create another object.

  - `LocalSizeId` can be used as an alternative to `LocalSize` to specify the local workgroup size with specialization constants.

  - Images created with identical creation parameters will always have the same alignment requirements.

  - The size memory requirement of a buffer or image is never greater than that of another buffer or image created with a greater or equal size.

  - Push constants do not have to be initialized before they are dynamically accessed.

  - The interface matching rules allow a larger output vector to match with a smaller input vector, with additional values being discarded.

If the `VkPhysicalDeviceVulkan13Features` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceVulkan13Features` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceVulkan13Features-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES`

The `VkPhysicalDeviceVariablePointersFeatures` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceVariablePointersFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           variablePointersStorageBuffer;
        VkBool32           variablePointers;
    } VkPhysicalDeviceVariablePointersFeatures;

    // Provided by VK_VERSION_1_1
    typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;

or the equivalent

    // Provided by VK_KHR_variable_pointers
    typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;

    // Provided by VK_KHR_variable_pointers
    typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `variablePointersStorageBuffer` specifies whether the implementation supports the SPIR-V `VariablePointersStorageBuffer` capability. When this feature is not enabled, shader modules must not declare the `SPV_KHR_variable_pointers` extension or the `VariablePointersStorageBuffer` capability.

- `variablePointers` specifies whether the implementation supports the SPIR-V `VariablePointers` capability. When this feature is not enabled, shader modules must not declare the `VariablePointers` capability.

If the `VkPhysicalDeviceVariablePointersFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceVariablePointersFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage

- VUID-VkPhysicalDeviceVariablePointersFeatures-variablePointers-01431
  If `variablePointers` is enabled then `variablePointersStorageBuffer` must also be enabled

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceVariablePointersFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES`

The `VkPhysicalDeviceMultiviewFeatures` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceMultiviewFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           multiview;
        VkBool32           multiviewGeometryShader;
        VkBool32           multiviewTessellationShader;
    } VkPhysicalDeviceMultiviewFeatures;

or the equivalent

    // Provided by VK_KHR_multiview
    typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `multiview` specifies whether the implementation supports multiview rendering within a render pass. If this feature is not enabled, the view mask of each subpass must always be zero.

- `multiviewGeometryShader` specifies whether the implementation supports multiview rendering within a render pass, with geometry shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must not include a geometry shader.

- `multiviewTessellationShader` specifies whether the implementation supports multiview rendering within a render pass, with tessellation shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must not include any tessellation shaders.

If the `VkPhysicalDeviceMultiviewFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceMultiviewFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage

- VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580
  If `multiviewGeometryShader` is enabled then `multiview` must also be enabled

- VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581
  If `multiviewTessellationShader` is enabled then `multiview` must also be enabled

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES`

The VkPhysicalDeviceShaderAtomicFloatFeaturesEXT structure is defined as:

    // Provided by VK_EXT_shader_atomic_float
    typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderBufferFloat32Atomics;
        VkBool32           shaderBufferFloat32AtomicAdd;
        VkBool32           shaderBufferFloat64Atomics;
        VkBool32           shaderBufferFloat64AtomicAdd;
        VkBool32           shaderSharedFloat32Atomics;
        VkBool32           shaderSharedFloat32AtomicAdd;
        VkBool32           shaderSharedFloat64Atomics;
        VkBool32           shaderSharedFloat64AtomicAdd;
        VkBool32           shaderImageFloat32Atomics;
        VkBool32           shaderImageFloat32AtomicAdd;
        VkBool32           sparseImageFloat32Atomics;
        VkBool32           sparseImageFloat32AtomicAdd;
    } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `shaderBufferFloat32Atomics` indicates whether shaders can perform 32-bit floating-point load, store and exchange atomic operations on storage buffers.

- `shaderBufferFloat32AtomicAdd` indicates whether shaders can perform 32-bit floating-point add atomic operations on storage buffers.

- `shaderBufferFloat64Atomics` indicates whether shaders can perform 64-bit floating-point load, store and exchange atomic operations on storage buffers.

- `shaderBufferFloat64AtomicAdd` indicates whether shaders can perform 64-bit floating-point add atomic operations on storage buffers.

- `shaderSharedFloat32Atomics` indicates whether shaders can perform 32-bit floating-point load, store and exchange atomic operations on shared and payload memory.

- `shaderSharedFloat32AtomicAdd` indicates whether shaders can perform 32-bit floating-point add atomic operations on shared and payload memory.

- `shaderSharedFloat64Atomics` indicates whether shaders can perform 64-bit floating-point load, store and exchange atomic operations on shared and payload memory.

- `shaderSharedFloat64AtomicAdd` indicates whether shaders can perform 64-bit floating-point add atomic operations on shared and payload memory.

- `shaderImageFloat32Atomics` indicates whether shaders can perform 32-bit floating-point load, store and exchange atomic image operations.

- `shaderImageFloat32AtomicAdd` indicates whether shaders can perform 32-bit floating-point add atomic image operations.

- `sparseImageFloat32Atomics` indicates whether 32-bit floating-point load, store and exchange atomic operations can be used on sparse images.

- `sparseImageFloat32AtomicAdd` indicates whether 32-bit floating-point add atomic operations can be used on sparse images.

If the `VkPhysicalDeviceShaderAtomicFloatFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderAtomicFloatFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderAtomicFloatFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT`

The VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT structure is defined as:

    // Provided by VK_EXT_shader_atomic_float2
    typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderBufferFloat16Atomics;
        VkBool32           shaderBufferFloat16AtomicAdd;
        VkBool32           shaderBufferFloat16AtomicMinMax;
        VkBool32           shaderBufferFloat32AtomicMinMax;
        VkBool32           shaderBufferFloat64AtomicMinMax;
        VkBool32           shaderSharedFloat16Atomics;
        VkBool32           shaderSharedFloat16AtomicAdd;
        VkBool32           shaderSharedFloat16AtomicMinMax;
        VkBool32           shaderSharedFloat32AtomicMinMax;
        VkBool32           shaderSharedFloat64AtomicMinMax;
        VkBool32           shaderImageFloat32AtomicMinMax;
        VkBool32           sparseImageFloat32AtomicMinMax;
    } VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `shaderBufferFloat16Atomics` indicates whether shaders can perform 16-bit floating-point load, store, and exchange atomic operations on storage buffers.

- `shaderBufferFloat16AtomicAdd` indicates whether shaders can perform 16-bit floating-point add atomic operations on storage buffers.

- `shaderBufferFloat16AtomicMinMax` indicates whether shaders can perform 16-bit floating-point min and max atomic operations on storage buffers.

- `shaderBufferFloat32AtomicMinMax` indicates whether shaders can perform 32-bit floating-point min and max atomic operations on storage buffers.

- `shaderBufferFloat64AtomicMinMax` indicates whether shaders can perform 64-bit floating-point min and max atomic operations on storage buffers.

- `shaderSharedFloat16Atomics` indicates whether shaders can perform 16-bit floating-point load, store and exchange atomic operations on shared and payload memory.

- `shaderSharedFloat16AtomicAdd` indicates whether shaders can perform 16-bit floating-point add atomic operations on shared and payload memory.

- `shaderSharedFloat16AtomicMinMax` indicates whether shaders can perform 16-bit floating-point min and max atomic operations on shared and payload memory.

- `shaderSharedFloat32AtomicMinMax` indicates whether shaders can perform 32-bit floating-point min and max atomic operations on shared and payload memory.

- `shaderSharedFloat64AtomicMinMax` indicates whether shaders can perform 64-bit floating-point min and max atomic operations on shared and payload memory.

- `shaderImageFloat32AtomicMinMax` indicates whether shaders can perform 32-bit floating-point min and max atomic image operations.

- `sparseImageFloat32AtomicMinMax` indicates whether 32-bit floating-point min and max atomic operations can be used on sparse images.

If the `VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT`

The VkPhysicalDeviceShaderAtomicInt64Features structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceShaderAtomicInt64Features {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderBufferInt64Atomics;
        VkBool32           shaderSharedInt64Atomics;
    } VkPhysicalDeviceShaderAtomicInt64Features;

or the equivalent

    // Provided by VK_KHR_shader_atomic_int64
    typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `shaderBufferInt64Atomics` indicates whether shaders can perform 64-bit unsigned and signed integer atomic operations on buffers.

- `shaderSharedInt64Atomics` indicates whether shaders can perform 64-bit unsigned and signed integer atomic operations on shared and payload memory.

If the `VkPhysicalDeviceShaderAtomicInt64Features` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderAtomicInt64Features` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderAtomicInt64Features-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES`

The VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT structure is defined as:

    // Provided by VK_EXT_shader_image_atomic_int64
    typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderImageInt64Atomics;
        VkBool32           sparseImageInt64Atomics;
    } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `shaderImageInt64Atomics` indicates whether shaders can support 64-bit unsigned and signed integer atomic operations on images.

- `sparseImageInt64Atomics` indicates whether 64-bit integer atomics can be used on sparse images.

If the `VkPhysicalDeviceShaderAtomicInt64FeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderAtomicInt64FeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT`

The VkPhysicalDevice8BitStorageFeatures structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDevice8BitStorageFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           storageBuffer8BitAccess;
        VkBool32           uniformAndStorageBuffer8BitAccess;
        VkBool32           storagePushConstant8;
    } VkPhysicalDevice8BitStorageFeatures;

or the equivalent

    // Provided by VK_KHR_8bit_storage
    typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `storageBuffer8BitAccess` indicates whether objects in the `StorageBuffer`, `ShaderRecordBufferKHR`, or `PhysicalStorageBuffer` storage class with the `Block` decoration can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the `StorageBuffer8BitAccess` capability.

- `uniformAndStorageBuffer8BitAccess` indicates whether objects in the `Uniform` storage class with the `Block` decoration can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the `UniformAndStorageBuffer8BitAccess` capability.

- `storagePushConstant8` indicates whether objects in the `PushConstant` storage class can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the `StoragePushConstant8` capability.

If the `VkPhysicalDevice8BitStorageFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevice8BitStorageFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevice8BitStorageFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES`

The VkPhysicalDevice16BitStorageFeatures structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDevice16BitStorageFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           storageBuffer16BitAccess;
        VkBool32           uniformAndStorageBuffer16BitAccess;
        VkBool32           storagePushConstant16;
        VkBool32           storageInputOutput16;
    } VkPhysicalDevice16BitStorageFeatures;

or the equivalent

    // Provided by VK_KHR_16bit_storage
    typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `storageBuffer16BitAccess` specifies whether objects in the `StorageBuffer`, `ShaderRecordBufferKHR`, or `PhysicalStorageBuffer` storage class with the `Block` decoration can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the `StorageBuffer16BitAccess` capability.

- `uniformAndStorageBuffer16BitAccess` specifies whether objects in the `Uniform` storage class with the `Block` decoration can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the `UniformAndStorageBuffer16BitAccess` capability.

- `storagePushConstant16` specifies whether objects in the `PushConstant` storage class can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or floating-point members must not be used in such objects. This also specifies whether shader modules can declare the `StoragePushConstant16` capability.

- `storageInputOutput16` specifies whether objects in the `Input` and `Output` storage classes can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also specifies whether shader modules can declare the `StorageInputOutput16` capability.

If the `VkPhysicalDevice16BitStorageFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevice16BitStorageFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES`

The `VkPhysicalDeviceShaderFloat16Int8Features` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceShaderFloat16Int8Features {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderFloat16;
        VkBool32           shaderInt8;
    } VkPhysicalDeviceShaderFloat16Int8Features;

or the equivalent

    // Provided by VK_KHR_shader_float16_int8
    typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;

    // Provided by VK_KHR_shader_float16_int8
    typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `shaderFloat16` indicates whether 16-bit floats (halfs) are supported in shader code. This also indicates whether shader modules can declare the `Float16` capability. However, this only enables a subset of the storage classes that SPIR-V allows for the `Float16` SPIR-V capability: Declaring and using 16-bit floats in the `Private`, `Workgroup` (for non-Block variables), and `Function` storage classes is enabled, while declaring them in the interface storage classes (e.g., `UniformConstant`, `Uniform`, `StorageBuffer`, `Input`, `Output`, and `PushConstant`) is not enabled.

- `shaderInt8` indicates whether 8-bit integers (signed and unsigned) are supported in shader code. This also indicates whether shader modules can declare the `Int8` capability. However, this only enables a subset of the storage classes that SPIR-V allows for the `Int8` SPIR-V capability: Declaring and using 8-bit integers in the `Private`, `Workgroup` (for non-Block variables), and `Function` storage classes is enabled, while declaring them in the interface storage classes (e.g., `UniformConstant`, `Uniform`, `StorageBuffer`, `Input`, `Output`, and `PushConstant`) is not enabled.

If the `VkPhysicalDeviceShaderFloat16Int8Features` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderFloat16Int8Features` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderFloat16Int8Features-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES`

The VkPhysicalDeviceShaderClockFeaturesKHR structure is defined as:

    // Provided by VK_KHR_shader_clock
    typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderSubgroupClock;
        VkBool32           shaderDeviceClock;
    } VkPhysicalDeviceShaderClockFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `shaderSubgroupClock` indicates whether shaders can perform `Subgroup` scoped clock reads.

- `shaderDeviceClock` indicates whether shaders can perform `Device` scoped clock reads.

If the `VkPhysicalDeviceShaderClockFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderClockFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderClockFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR`

The `VkPhysicalDeviceSamplerYcbcrConversionFeatures` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           samplerYcbcrConversion;
    } VkPhysicalDeviceSamplerYcbcrConversionFeatures;

or the equivalent

    // Provided by VK_KHR_sampler_ycbcr_conversion
    typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `samplerYcbcrConversion` specifies whether the implementation supports sampler Y′CBCR conversion. If `samplerYcbcrConversion` is `VK_FALSE`, sampler Y′CBCR conversion is not supported, and samplers using sampler Y′CBCR conversion must not be used.

If the `VkPhysicalDeviceSamplerYcbcrConversionFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceSamplerYcbcrConversionFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES`

The `VkPhysicalDeviceProtectedMemoryFeatures` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceProtectedMemoryFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           protectedMemory;
    } VkPhysicalDeviceProtectedMemoryFeatures;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `protectedMemory` specifies whether protected memory is supported.

If the `VkPhysicalDeviceProtectedMemoryFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceProtectedMemoryFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES`

The `VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_blend_operation_advanced
    typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           advancedBlendCoherentOperations;
    } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `advancedBlendCoherentOperations` specifies whether blending using advanced blend operations is guaranteed to execute atomically and in primitive order. If this is `VK_TRUE`, `VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT` is treated the same as `VK_ACCESS_COLOR_ATTACHMENT_READ_BIT`, and advanced blending needs no additional synchronization over basic blending. If this is `VK_FALSE`, then memory dependencies are required to guarantee order between two advanced blending operations that occur on the same sample.

If the `VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT`

The `VkPhysicalDeviceConditionalRenderingFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_conditional_rendering
    typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           conditionalRendering;
        VkBool32           inheritedConditionalRendering;
    } VkPhysicalDeviceConditionalRenderingFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `conditionalRendering` specifies whether conditional rendering is supported.

- `inheritedConditionalRendering` specifies whether a secondary command buffer can be executed while conditional rendering is active in the primary command buffer.

If the `VkPhysicalDeviceConditionalRenderingFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceConditionalRenderingFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceConditionalRenderingFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT`

The `VkPhysicalDeviceShaderDrawParametersFeatures` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceShaderDrawParametersFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderDrawParameters;
    } VkPhysicalDeviceShaderDrawParametersFeatures;

    // Provided by VK_VERSION_1_1
    typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderDrawParameters` specifies whether the implementation supports the SPIR-V `DrawParameters` capability. When this feature is not enabled, shader modules must not declare the `SPV_KHR_shader_draw_parameters` extension or the `DrawParameters` capability.

If the `VkPhysicalDeviceShaderDrawParametersFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderDrawParametersFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderDrawParametersFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES`

The `VkPhysicalDeviceMeshShaderFeaturesNV` structure is defined as:

    // Provided by VK_NV_mesh_shader
    typedef struct VkPhysicalDeviceMeshShaderFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           taskShader;
        VkBool32           meshShader;
    } VkPhysicalDeviceMeshShaderFeaturesNV;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `taskShader` specifies whether task shaders are supported. If this feature is not enabled, the `VK_SHADER_STAGE_TASK_BIT_NV` and `VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV` enum values must not be used.

- `meshShader` specifies whether mesh shaders are supported. If this feature is not enabled, the `VK_SHADER_STAGE_MESH_BIT_NV` and `VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV` enum values must not be used.

If the `VkPhysicalDeviceMeshShaderFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceMeshShaderFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMeshShaderFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV`

The `VkPhysicalDeviceMeshShaderFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_mesh_shader
    typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           taskShader;
        VkBool32           meshShader;
        VkBool32           multiviewMeshShader;
        VkBool32           primitiveFragmentShadingRateMeshShader;
        VkBool32           meshShaderQueries;
    } VkPhysicalDeviceMeshShaderFeaturesEXT;

- `sType` is the type of this structure.

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

- `taskShader` specifies whether task shaders are supported. If this feature is not enabled, the `VK_SHADER_STAGE_TASK_BIT_EXT` and `VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT` enum values must not be used.

- `meshShader` specifies whether mesh shaders are supported. If this feature is not enabled, the `VK_SHADER_STAGE_MESH_BIT_EXT` and `VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT` enum values must not be used.

- `multiviewMeshShader` specifies whether the implementation supports multiview rendering within a render pass, with mesh shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must not include a mesh shader.

- `primitiveFragmentShadingRateMeshShader` indicates that the implementation supports the primitive fragment shading rate in mesh shaders.

- `meshShaderQueries` indicates that the implementation supports creating query pools using the `VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT` query type and statistic queries containing the `VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT` and `VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT` flags

If the `VkPhysicalDeviceMeshShaderFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceMeshShaderFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

The corresponding features of the `VkPhysicalDeviceMeshShaderFeaturesNV` structure must match those in `VkPhysicalDeviceMeshShaderFeaturesEXT`.

Valid Usage

- VUID-VkPhysicalDeviceMeshShaderFeaturesEXT-multiviewMeshShader-07032
  If `multiviewMeshShader` is enabled then `VkPhysicalDeviceMultiviewFeaturesKHR`::`multiview` must also be enabled

- VUID-VkPhysicalDeviceMeshShaderFeaturesEXT-primitiveFragmentShadingRateMeshShader-07033
  If `primitiveFragmentShadingRateMeshShader` is enabled then `VkPhysicalDeviceFragmentShadingRateFeaturesKHR`::`primitiveFragmentShadingRate` must also be enabled

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMeshShaderFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT`

The `VkPhysicalDeviceDescriptorIndexingFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceDescriptorIndexingFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderInputAttachmentArrayDynamicIndexing;
        VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
        VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
        VkBool32           shaderUniformBufferArrayNonUniformIndexing;
        VkBool32           shaderSampledImageArrayNonUniformIndexing;
        VkBool32           shaderStorageBufferArrayNonUniformIndexing;
        VkBool32           shaderStorageImageArrayNonUniformIndexing;
        VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
        VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
        VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
        VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
        VkBool32           descriptorBindingSampledImageUpdateAfterBind;
        VkBool32           descriptorBindingStorageImageUpdateAfterBind;
        VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
        VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
        VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
        VkBool32           descriptorBindingUpdateUnusedWhilePending;
        VkBool32           descriptorBindingPartiallyBound;
        VkBool32           descriptorBindingVariableDescriptorCount;
        VkBool32           runtimeDescriptorArray;
    } VkPhysicalDeviceDescriptorIndexingFeatures;

or the equivalent

    // Provided by VK_EXT_descriptor_indexing
    typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `shaderInputAttachmentArrayDynamicIndexing` indicates whether arrays of input attachments can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `InputAttachmentArrayDynamicIndexing` capability.

- `shaderUniformTexelBufferArrayDynamicIndexing` indicates whether arrays of uniform texel buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `UniformTexelBufferArrayDynamicIndexing` capability.

- `shaderStorageTexelBufferArrayDynamicIndexing` indicates whether arrays of storage texel buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER` must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `StorageTexelBufferArrayDynamicIndexing` capability.

- `shaderUniformBufferArrayNonUniformIndexing` indicates whether arrays of uniform buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` or `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `UniformBufferArrayNonUniformIndexing` capability.

- `shaderSampledImageArrayNonUniformIndexing` indicates whether arrays of samplers or sampled images can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_SAMPLER`, `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`, or `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `SampledImageArrayNonUniformIndexing` capability.

- `shaderStorageBufferArrayNonUniformIndexing` indicates whether arrays of storage buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` or `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `StorageBufferArrayNonUniformIndexing` capability.

- `shaderStorageImageArrayNonUniformIndexing` indicates whether arrays of storage images can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `StorageImageArrayNonUniformIndexing` capability.

- `shaderInputAttachmentArrayNonUniformIndexing` indicates whether arrays of input attachments can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `InputAttachmentArrayNonUniformIndexing` capability.

- `shaderUniformTexelBufferArrayNonUniformIndexing` indicates whether arrays of uniform texel buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `UniformTexelBufferArrayNonUniformIndexing` capability.

- `shaderStorageTexelBufferArrayNonUniformIndexing` indicates whether arrays of storage texel buffers can be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER` must not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can declare the `StorageTexelBufferArrayNonUniformIndexing` capability.

- `descriptorBindingUniformBufferUpdateAfterBind` indicates whether the implementation supports updating uniform buffer descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER`.

- `descriptorBindingSampledImageUpdateAfterBind` indicates whether the implementation supports updating sampled image descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_SAMPLER`, `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`, or `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE`.

- `descriptorBindingStorageImageUpdateAfterBind` indicates whether the implementation supports updating storage image descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE`.

- `descriptorBindingStorageBufferUpdateAfterBind` indicates whether the implementation supports updating storage buffer descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER`.

- `descriptorBindingUniformTexelBufferUpdateAfterBind` indicates whether the implementation supports updating uniform texel buffer descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER`.

- `descriptorBindingStorageTexelBufferUpdateAfterBind` indicates whether the implementation supports updating storage texel buffer descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER`.

- `descriptorBindingUpdateUnusedWhilePending` indicates whether the implementation supports updating descriptors while the set is in use. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT` must not be used.

- `descriptorBindingPartiallyBound` indicates whether the implementation supports statically using a descriptor set binding in which some descriptors are not valid. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT` must not be used.

- `descriptorBindingVariableDescriptorCount` indicates whether the implementation supports descriptor sets with a variable-sized last binding. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT` must not be used.

- `runtimeDescriptorArray` indicates whether the implementation supports the SPIR-V `RuntimeDescriptorArray` capability. If this feature is not enabled, descriptors must not be declared in runtime arrays.

If the `VkPhysicalDeviceDescriptorIndexingFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceDescriptorIndexingFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDescriptorIndexingFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES`

The `VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_vertex_attribute_divisor
    typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           vertexAttributeInstanceRateDivisor;
        VkBool32           vertexAttributeInstanceRateZeroDivisor;
    } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `vertexAttributeInstanceRateDivisor` specifies whether vertex attribute fetching may be repeated in case of instanced rendering.

- `vertexAttributeInstanceRateZeroDivisor` specifies whether a zero value for `VkVertexInputBindingDivisorDescriptionEXT`::`divisor` is supported.

If the `VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT`

The `VkPhysicalDeviceASTCDecodeFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_astc_decode_mode
    typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           decodeModeSharedExponent;
    } VkPhysicalDeviceASTCDecodeFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `decodeModeSharedExponent` indicates whether the implementation supports decoding ASTC compressed formats to `VK_FORMAT_E5B9G9R9_UFLOAT_PACK32` internal precision.

If the `VkPhysicalDeviceASTCDecodeFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceASTCDecodeFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceASTCDecodeFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT`

The `VkPhysicalDeviceTransformFeedbackFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_transform_feedback
    typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           transformFeedback;
        VkBool32           geometryStreams;
    } VkPhysicalDeviceTransformFeedbackFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `transformFeedback` indicates whether the implementation supports transform feedback and shader modules can declare the `TransformFeedback` capability.

- `geometryStreams` indicates whether the implementation supports the `GeometryStreams` SPIR-V capability.

If the `VkPhysicalDeviceTransformFeedbackFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceTransformFeedbackFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceTransformFeedbackFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT`

The `VkPhysicalDeviceVulkanMemoryModelFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           vulkanMemoryModel;
        VkBool32           vulkanMemoryModelDeviceScope;
        VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
    } VkPhysicalDeviceVulkanMemoryModelFeatures;

or the equivalent

    // Provided by VK_KHR_vulkan_memory_model
    typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `vulkanMemoryModel` indicates whether the Vulkan Memory Model is supported, as defined in Vulkan Memory Model. This also indicates whether shader modules can declare the `VulkanMemoryModel` capability.

- `vulkanMemoryModelDeviceScope` indicates whether the Vulkan Memory Model can use `Device` scope synchronization. This also indicates whether shader modules can declare the `VulkanMemoryModelDeviceScope` capability.

- `vulkanMemoryModelAvailabilityVisibilityChains` indicates whether the Vulkan Memory Model can use availability and visibility chains with more than one element.

If the `VkPhysicalDeviceVulkanMemoryModelFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceVulkanMemoryModelFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceVulkanMemoryModelFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES`

The `VkPhysicalDeviceInlineUniformBlockFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceInlineUniformBlockFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           inlineUniformBlock;
        VkBool32           descriptorBindingInlineUniformBlockUpdateAfterBind;
    } VkPhysicalDeviceInlineUniformBlockFeatures;

or the equivalent

    // Provided by VK_EXT_inline_uniform_block
    typedef VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlineUniformBlockFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `inlineUniformBlock` indicates whether the implementation supports inline uniform block descriptors. If this feature is not enabled, `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK` must not be used.

- `descriptorBindingInlineUniformBlockUpdateAfterBind` indicates whether the implementation supports updating inline uniform block descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK`.

If the `VkPhysicalDeviceInlineUniformBlockFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceInlineUniformBlockFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceInlineUniformBlockFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES`

The `VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV` structure is defined as:

    // Provided by VK_NV_representative_fragment_test
    typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           representativeFragmentTest;
    } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `representativeFragmentTest` indicates whether the implementation supports the representative fragment test. See Representative Fragment Test.

If the `VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV`

The `VkPhysicalDeviceExclusiveScissorFeaturesNV` structure is defined as:

    // Provided by VK_NV_scissor_exclusive
    typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           exclusiveScissor;
    } VkPhysicalDeviceExclusiveScissorFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `exclusiveScissor` indicates that the implementation supports the exclusive scissor test.

See Exclusive Scissor Test for more information.

If the `VkPhysicalDeviceExclusiveScissorFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceExclusiveScissorFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceExclusiveScissorFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV`

The `VkPhysicalDeviceCornerSampledImageFeaturesNV` structure is defined as:

    // Provided by VK_NV_corner_sampled_image
    typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           cornerSampledImage;
    } VkPhysicalDeviceCornerSampledImageFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `cornerSampledImage` specifies whether images can be created with a VkImageCreateInfo::`flags` containing `VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV`. See Corner-Sampled Images.

If the `VkPhysicalDeviceCornerSampledImageFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceCornerSampledImageFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceCornerSampledImageFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV`

The `VkPhysicalDeviceComputeShaderDerivativesFeaturesNV` structure is defined as:

    // Provided by VK_NV_compute_shader_derivatives
    typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           computeDerivativeGroupQuads;
        VkBool32           computeDerivativeGroupLinear;
    } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `computeDerivativeGroupQuads` indicates that the implementation supports the `ComputeDerivativeGroupQuadsNV` SPIR-V capability.

- `computeDerivativeGroupLinear` indicates that the implementation supports the `ComputeDerivativeGroupLinearNV` SPIR-V capability.

See Quad shader scope for more information.

If the `VkPhysicalDeviceComputeShaderDerivativesFeaturesNVfeatures`. structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceComputeShaderDerivativesFeaturesNVfeatures`. can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceComputeShaderDerivativesFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV`

The `VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_fragment_shader_barycentric
    typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           fragmentShaderBarycentric;
    } VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR;

or the equivalent

    // Provided by VK_NV_fragment_shader_barycentric
    typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `fragmentShaderBarycentric` indicates that the implementation supports the `BaryCoordKHR` and `BaryCoordNoPerspKHR` SPIR-V fragment shader built-ins and supports the `PerVertexKHR` SPIR-V decoration on fragment shader input variables.

See Barycentric Interpolation for more information.

If the `VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR`

The `VkPhysicalDeviceShaderImageFootprintFeaturesNV` structure is defined as:

    // Provided by VK_NV_shader_image_footprint
    typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           imageFootprint;
    } VkPhysicalDeviceShaderImageFootprintFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `imageFootprint` specifies whether the implementation supports the `ImageFootprintNV` SPIR-V capability.

See Texel Footprint Evaluation for more information.

If the `VkPhysicalDeviceShaderImageFootprintFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderImageFootprintFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderImageFootprintFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV`

The `VkPhysicalDeviceShadingRateImageFeaturesNV` structure is defined as:

    // Provided by VK_NV_shading_rate_image
    typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shadingRateImage;
        VkBool32           shadingRateCoarseSampleOrder;
    } VkPhysicalDeviceShadingRateImageFeaturesNV;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `shadingRateImage` indicates that the implementation supports the use of a shading rate image to derive an effective shading rate for fragment processing. It also indicates that the implementation supports the `ShadingRateNV` SPIR-V execution mode.

- `shadingRateCoarseSampleOrder` indicates that the implementation supports a user-configurable ordering of coverage samples in fragments larger than one pixel.

See Shading Rate Image for more information.

If the `VkPhysicalDeviceShadingRateImageFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShadingRateImageFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShadingRateImageFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV`

The `VkPhysicalDeviceFragmentDensityMapFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_fragment_density_map
    typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           fragmentDensityMap;
        VkBool32           fragmentDensityMapDynamic;
        VkBool32           fragmentDensityMapNonSubsampledImages;
    } VkPhysicalDeviceFragmentDensityMapFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `fragmentDensityMap` specifies whether the implementation supports render passes with a fragment density map attachment. If this feature is not enabled and the `pNext` chain of VkRenderPassCreateInfo includes a VkRenderPassFragmentDensityMapCreateInfoEXT structure, `fragmentDensityMapAttachment` must be `VK_ATTACHMENT_UNUSED`.

- `fragmentDensityMapDynamic` specifies whether the implementation supports dynamic fragment density map image views. If this feature is not enabled, `VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT` must not be included in VkImageViewCreateInfo::`flags`.

- `fragmentDensityMapNonSubsampledImages` specifies whether the implementation supports regular non-subsampled image attachments with fragment density map render passes. If this feature is not enabled, render passes with a fragment density map attachment must only have subsampled attachments bound.

If the `VkPhysicalDeviceFragmentDensityMapFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceFragmentDensityMapFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentDensityMapFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT`

The `VkPhysicalDeviceFragmentDensityMap2FeaturesEXT` structure is defined as:

    // Provided by VK_EXT_fragment_density_map2
    typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           fragmentDensityMapDeferred;
    } VkPhysicalDeviceFragmentDensityMap2FeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `fragmentDensityMapDeferred` specifies whether the implementation supports deferred reads of fragment density map image views. If this feature is not enabled, `VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT` must not be included in `VkImageViewCreateInfo`::`flags`.

If the `VkPhysicalDeviceFragmentDensityMap2FeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceFragmentDensityMap2FeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentDensityMap2FeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT`

The `VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM` structure is defined as:

    // Provided by VK_QCOM_fragment_density_map_offset
    typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           fragmentDensityMapOffset;
    } VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `fragmentDensityMapOffsets` specifies whether the implementation supports fragment density map offsets

If the `VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM`

The `VkPhysicalDeviceInvocationMaskFeaturesHUAWEI` structure is defined as:

    // Provided by VK_HUAWEI_invocation_mask
    typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           invocationMask;
    } VkPhysicalDeviceInvocationMaskFeaturesHUAWEI;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `invocationMask` indicates that the implementation supports the use of an invocation mask image to optimize the ray dispatch.

If the `VkPhysicalDeviceInvocationMaskFeaturesHUAWEI` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceInvocationMaskFeaturesHUAWEI` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceInvocationMaskFeaturesHUAWEI-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI`

The `VkPhysicalDeviceScalarBlockLayoutFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           scalarBlockLayout;
    } VkPhysicalDeviceScalarBlockLayoutFeatures;

or the equivalent

    // Provided by VK_EXT_scalar_block_layout
    typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `scalarBlockLayout` indicates that the implementation supports the layout of resource blocks in shaders using scalar alignment.

If the `VkPhysicalDeviceScalarBlockLayoutFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceScalarBlockLayoutFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceScalarBlockLayoutFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES`

The `VkPhysicalDeviceUniformBufferStandardLayoutFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           uniformBufferStandardLayout;
    } VkPhysicalDeviceUniformBufferStandardLayoutFeatures;

or the equivalent

    // Provided by VK_KHR_uniform_buffer_standard_layout
    typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `uniformBufferStandardLayout` indicates that the implementation supports the same layouts for uniform buffers as for storage and other kinds of buffers. See Standard Buffer Layout.

If the `VkPhysicalDeviceUniformBufferStandardLayoutFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceUniformBufferStandardLayoutFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceUniformBufferStandardLayoutFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES`

The `VkPhysicalDeviceDepthClipEnableFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_depth_clip_enable
    typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           depthClipEnable;
    } VkPhysicalDeviceDepthClipEnableFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `depthClipEnable` indicates that the implementation supports setting the depth clipping operation explicitly via the VkPipelineRasterizationDepthClipStateCreateInfoEXT pipeline state. Otherwise depth clipping is only enabled when VkPipelineRasterizationStateCreateInfo::`depthClampEnable` is set to `VK_FALSE`.

If the `VkPhysicalDeviceDepthClipEnableFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceDepthClipEnableFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDepthClipEnableFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT`

The `VkPhysicalDeviceMemoryPriorityFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_memory_priority
    typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           memoryPriority;
    } VkPhysicalDeviceMemoryPriorityFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `memoryPriority` indicates that the implementation supports memory priorities specified at memory allocation time via VkMemoryPriorityAllocateInfoEXT.

If the `VkPhysicalDeviceMemoryPriorityFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceMemoryPriorityFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMemoryPriorityFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT`

The `VkPhysicalDeviceBufferDeviceAddressFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           bufferDeviceAddress;
        VkBool32           bufferDeviceAddressCaptureReplay;
        VkBool32           bufferDeviceAddressMultiDevice;
    } VkPhysicalDeviceBufferDeviceAddressFeatures;

or the equivalent

    // Provided by VK_KHR_buffer_device_address
    typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `bufferDeviceAddress` indicates that the implementation supports accessing buffer memory in shaders as storage buffers via an address queried from vkGetBufferDeviceAddress.

- `bufferDeviceAddressCaptureReplay` indicates that the implementation supports saving and reusing buffer and device addresses, e.g. for trace capture and replay.

- `bufferDeviceAddressMultiDevice` indicates that the implementation supports the `bufferDeviceAddress` , `rayTracingPipeline` and `rayQuery` features for logical devices created with multiple physical devices. If this feature is not supported, buffer and acceleration structure addresses must not be queried on a logical device created with more than one physical device.

| Note `bufferDeviceAddressMultiDevice` exists to allow certain legacy platforms to be able to support `bufferDeviceAddress` without needing to support shared GPU virtual addresses for multi-device configurations.

See vkGetBufferDeviceAddress for more information.

If the `VkPhysicalDeviceBufferDeviceAddressFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceBufferDeviceAddressFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceBufferDeviceAddressFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES`

The `VkPhysicalDeviceBufferDeviceAddressFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_buffer_device_address
    typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           bufferDeviceAddress;
        VkBool32           bufferDeviceAddressCaptureReplay;
        VkBool32           bufferDeviceAddressMultiDevice;
    } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;

    // Provided by VK_EXT_buffer_device_address
    typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `bufferDeviceAddress` indicates that the implementation supports accessing buffer memory in shaders as storage buffers via an address queried from vkGetBufferDeviceAddressEXT.

- `bufferDeviceAddressCaptureReplay` indicates that the implementation supports saving and reusing buffer addresses, e.g. for trace capture and replay.

- `bufferDeviceAddressMultiDevice` indicates that the implementation supports the `bufferDeviceAddress` feature for logical devices created with multiple physical devices. If this feature is not supported, buffer addresses must not be queried on a logical device created with more than one physical device.

If the `VkPhysicalDeviceBufferDeviceAddressFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceBufferDeviceAddressFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

| Note The `VkPhysicalDeviceBufferDeviceAddressFeaturesEXT` structure has the same members as the `VkPhysicalDeviceBufferDeviceAddressFeatures` structure, but the functionality indicated by the members is expressed differently. The features indicated by the `VkPhysicalDeviceBufferDeviceAddressFeatures` structure requires additional flags to be passed at memory allocation time, and the capture and replay mechanism is built around opaque capture addresses for buffer and memory objects.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceBufferDeviceAddressFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT`

The `VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV` structure is defined as:

    // Provided by VK_NV_dedicated_allocation_image_aliasing
    typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           dedicatedAllocationImageAliasing;
    } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `dedicatedAllocationImageAliasing` indicates that the implementation supports aliasing of compatible image objects on a dedicated allocation.

If the `VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV`

The `VkPhysicalDeviceImagelessFramebufferFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceImagelessFramebufferFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           imagelessFramebuffer;
    } VkPhysicalDeviceImagelessFramebufferFeatures;

or the equivalent

    // Provided by VK_KHR_imageless_framebuffer
    typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `imagelessFramebuffer` indicates that the implementation supports specifying the image view for attachments at render pass begin time via VkRenderPassAttachmentBeginInfo.

If the `VkPhysicalDeviceImagelessFramebufferFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceImagelessFramebufferFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceImagelessFramebufferFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES`

The `VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_fragment_shader_interlock
    typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           fragmentShaderSampleInterlock;
        VkBool32           fragmentShaderPixelInterlock;
        VkBool32           fragmentShaderShadingRateInterlock;
    } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `fragmentShaderSampleInterlock` indicates that the implementation supports the `FragmentShaderSampleInterlockEXT` SPIR-V capability.

- `fragmentShaderPixelInterlock` indicates that the implementation supports the `FragmentShaderPixelInterlockEXT` SPIR-V capability.

- `fragmentShaderShadingRateInterlock` indicates that the implementation supports the `FragmentShaderShadingRateInterlockEXT` SPIR-V capability.

If the `VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT`

The `VkPhysicalDeviceCooperativeMatrixFeaturesNV` structure is defined as:

    // Provided by VK_NV_cooperative_matrix
    typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           cooperativeMatrix;
        VkBool32           cooperativeMatrixRobustBufferAccess;
    } VkPhysicalDeviceCooperativeMatrixFeaturesNV;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `cooperativeMatrix` indicates that the implementation supports the `CooperativeMatrixNV` SPIR-V capability.

- `cooperativeMatrixRobustBufferAccess` indicates that the implementation supports robust buffer access for SPIR-V `OpCooperativeMatrixLoadNV` and `OpCooperativeMatrixStoreNV` instructions.

If the `VkPhysicalDeviceCooperativeMatrixFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceCooperativeMatrixFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceCooperativeMatrixFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV`

The `VkPhysicalDeviceYcbcrImageArraysFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_ycbcr_image_arrays
    typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           ycbcrImageArrays;
    } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `ycbcrImageArrays` indicates that the implementation supports creating images with a format that requires Y′CBCR conversion and has multiple array layers.

If the `VkPhysicalDeviceYcbcrImageArraysFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceYcbcrImageArraysFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceYcbcrImageArraysFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT`

The `VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderSubgroupExtendedTypes;
    } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;

or the equivalent

    // Provided by VK_KHR_shader_subgroup_extended_types
    typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderSubgroupExtendedTypes` is a boolean specifying whether subgroup operations can use 8-bit integer, 16-bit integer, 64-bit integer, 16-bit floating-point, and vectors of these types in group operations with subgroup scope, if the implementation supports the types.

If the `VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES`

The `VkPhysicalDeviceHostQueryResetFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceHostQueryResetFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           hostQueryReset;
    } VkPhysicalDeviceHostQueryResetFeatures;

or the equivalent

    // Provided by VK_EXT_host_query_reset
    typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `hostQueryReset` indicates that the implementation supports resetting queries from the host with vkResetQueryPool.

If the `VkPhysicalDeviceHostQueryResetFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceHostQueryResetFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceHostQueryResetFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES`

The `VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL` structure is defined as:

    // Provided by VK_INTEL_shader_integer_functions2
    typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderIntegerFunctions2;
    } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderIntegerFunctions2` indicates that the implementation supports the `IntegerFunctions2INTEL` SPIR-V capability.

If the `VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTELfeatures`. structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTELfeatures`. can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL`

The `VkPhysicalDeviceCoverageReductionModeFeaturesNV` structure is defined as:

    // Provided by VK_NV_coverage_reduction_mode
    typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           coverageReductionMode;
    } VkPhysicalDeviceCoverageReductionModeFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `coverageReductionMode` indicates whether the implementation supports coverage reduction modes. See Coverage Reduction.

If the `VkPhysicalDeviceCoverageReductionModeFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceCoverageReductionModeFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceCoverageReductionModeFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV`

The `VkPhysicalDeviceTimelineSemaphoreFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           timelineSemaphore;
    } VkPhysicalDeviceTimelineSemaphoreFeatures;

or the equivalent

    // Provided by VK_KHR_timeline_semaphore
    typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `timelineSemaphore` indicates whether semaphores created with a VkSemaphoreType of `VK_SEMAPHORE_TYPE_TIMELINE` are supported.

If the `VkPhysicalDeviceTimelineSemaphoreFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceTimelineSemaphoreFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceTimelineSemaphoreFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES`

The `VkPhysicalDeviceIndexTypeUint8FeaturesEXT` structure is defined as:

    // Provided by VK_EXT_index_type_uint8
    typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           indexTypeUint8;
    } VkPhysicalDeviceIndexTypeUint8FeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `indexTypeUint8` indicates that `VK_INDEX_TYPE_UINT8_EXT` can be used with vkCmdBindIndexBuffer.

If the `VkPhysicalDeviceIndexTypeUint8FeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceIndexTypeUint8FeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceIndexTypeUint8FeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT`

The `VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_primitive_topology_list_restart
    typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           primitiveTopologyListRestart;
        VkBool32           primitiveTopologyPatchListRestart;
    } VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `primitiveTopologyListRestart` indicates that list type primitives, `VK_PRIMITIVE_TOPOLOGY_POINT_LIST`, `VK_PRIMITIVE_TOPOLOGY_LINE_LIST`, `VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST`, `VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY` and `VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY`, can use the primitive restart index value in index buffers.

- `primitiveTopologyPatchListRestart` indicates that the `VK_PRIMITIVE_TOPOLOGY_PATCH_LIST` topology can use the primitive restart index value in index buffers.

If the `VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT`

The `VkPhysicalDeviceShaderSMBuiltinsFeaturesNV` structure is defined as:

    // Provided by VK_NV_shader_sm_builtins
    typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderSMBuiltins;
    } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderSMBuiltins` indicates whether the implementation supports the SPIR-V `ShaderSMBuiltinsNV` capability.

If the `VkPhysicalDeviceShaderSMBuiltinsFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderSMBuiltinsFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderSMBuiltinsFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV`

The `VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           separateDepthStencilLayouts;
    } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;

or the equivalent

    // Provided by VK_KHR_separate_depth_stencil_layouts
    typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `separateDepthStencilLayouts` indicates whether the implementation supports a `VkImageMemoryBarrier` for a depth/stencil image with only one of `VK_IMAGE_ASPECT_DEPTH_BIT` or `VK_IMAGE_ASPECT_STENCIL_BIT` set, and whether `VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL`, `VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL`, `VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL`, or `VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL` can be used.

If the `VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES`

The `VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_pipeline_executable_properties
    typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           pipelineExecutableInfo;
    } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `pipelineExecutableInfo` indicates that the implementation supports reporting properties and statistics about the pipeline executables associated with a compiled pipeline.

If the `VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR`

The `VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderDemoteToHelperInvocation;
    } VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures;

or the equivalent

    // Provided by VK_EXT_shader_demote_to_helper_invocation
    typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderDemoteToHelperInvocation` indicates whether the implementation supports the SPIR-V `DemoteToHelperInvocationEXT` capability.

If the `VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES`

The `VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_texel_buffer_alignment
    typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           texelBufferAlignment;
    } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `texelBufferAlignment` indicates whether the implementation uses more specific alignment requirements advertised in VkPhysicalDeviceTexelBufferAlignmentProperties rather than VkPhysicalDeviceLimits::`minTexelBufferOffsetAlignment`.

If the `VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT`

The `VkPhysicalDeviceTextureCompressionASTCHDRFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           textureCompressionASTC_HDR;
    } VkPhysicalDeviceTextureCompressionASTCHDRFeatures;

or the equivalent

    // Provided by VK_EXT_texture_compression_astc_hdr
    typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `textureCompressionASTC_HDR` indicates whether all of the ASTC HDR compressed texture formats are supported. If this feature is enabled, then the `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`, `VK_FORMAT_FEATURE_BLIT_SRC_BIT` and `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT` features must be supported in `optimalTilingFeatures` for the following formats:

  - `VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK`

  - `VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK`

  To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.

If the `VkPhysicalDeviceTextureCompressionASTCHDRFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceTextureCompressionASTCHDRFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceTextureCompressionASTCHDRFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES`

The `VkPhysicalDeviceLineRasterizationFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_line_rasterization
    typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           rectangularLines;
        VkBool32           bresenhamLines;
        VkBool32           smoothLines;
        VkBool32           stippledRectangularLines;
        VkBool32           stippledBresenhamLines;
        VkBool32           stippledSmoothLines;
    } VkPhysicalDeviceLineRasterizationFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `rectangularLines` indicates whether the implementation supports rectangular line rasterization.

- `bresenhamLines` indicates whether the implementation supports Bresenham-style line rasterization.

- `smoothLines` indicates whether the implementation supports smooth line rasterization.

- `stippledRectangularLines` indicates whether the implementation supports stippled line rasterization with `VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT` lines.

- `stippledBresenhamLines` indicates whether the implementation supports stippled line rasterization with `VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT` lines.

- `stippledSmoothLines` indicates whether the implementation supports stippled line rasterization with `VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT` lines.

If the `VkPhysicalDeviceLineRasterizationFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceLineRasterizationFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceLineRasterizationFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT`

The `VkPhysicalDeviceSubgroupSizeControlFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           subgroupSizeControl;
        VkBool32           computeFullSubgroups;
    } VkPhysicalDeviceSubgroupSizeControlFeatures;

or the equivalent

    // Provided by VK_EXT_subgroup_size_control
    typedef VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `subgroupSizeControl` indicates whether the implementation supports controlling shader subgroup sizes via the `VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT` flag and the VkPipelineShaderStageRequiredSubgroupSizeCreateInfo structure.

- `computeFullSubgroups` indicates whether the implementation supports requiring full subgroups in compute , mesh, or task shaders via the `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT` flag.

If the `VkPhysicalDeviceSubgroupSizeControlFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceSubgroupSizeControlFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

| Note The `VkPhysicalDeviceSubgroupSizeControlFeaturesEXT` structure was added in version 2 of the `VK_EXT_subgroup_size_control` extension. Version 1 implementations of this extension will not fill out the features structure but applications may assume that both `subgroupSizeControl` and `computeFullSubgroups` are supported if the extension is supported. (See also the Feature Requirements section.) Applications are advised to add a `VkPhysicalDeviceSubgroupSizeControlFeaturesEXT` structure to the `pNext` chain of VkDeviceCreateInfo to enable the features regardless of the version of the extension supported by the implementation. If the implementation only supports version 1, it will safely ignore the `VkPhysicalDeviceSubgroupSizeControlFeaturesEXT` structure. Vulkan 1.3 implementations always support the features structure.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSubgroupSizeControlFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES`

The `VkPhysicalDeviceCoherentMemoryFeaturesAMD` structure is defined as:

    // Provided by VK_AMD_device_coherent_memory
    typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           deviceCoherentMemory;
    } VkPhysicalDeviceCoherentMemoryFeaturesAMD;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `deviceCoherentMemory` indicates that the implementation supports device coherent memory.

If the `VkPhysicalDeviceCoherentMemoryFeaturesAMD` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceCoherentMemoryFeaturesAMD` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceCoherentMemoryFeaturesAMD-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD`

The `VkPhysicalDeviceAccelerationStructureFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_acceleration_structure
    typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           accelerationStructure;
        VkBool32           accelerationStructureCaptureReplay;
        VkBool32           accelerationStructureIndirectBuild;
        VkBool32           accelerationStructureHostCommands;
        VkBool32           descriptorBindingAccelerationStructureUpdateAfterBind;
    } VkPhysicalDeviceAccelerationStructureFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `accelerationStructure` indicates whether the implementation supports the acceleration structure functionality. See Acceleration Structures.

- `accelerationStructureCaptureReplay` indicates whether the implementation supports saving and reusing acceleration structure device addresses, e.g. for trace capture and replay.

- `accelerationStructureIndirectBuild` indicates whether the implementation supports indirect acceleration structure build commands, e.g. vkCmdBuildAccelerationStructuresIndirectKHR.

- `accelerationStructureHostCommands` indicates whether the implementation supports host side acceleration structure commands, e.g. vkBuildAccelerationStructuresKHR, vkCopyAccelerationStructureKHR, vkCopyAccelerationStructureToMemoryKHR, vkCopyMemoryToAccelerationStructureKHR, vkWriteAccelerationStructuresPropertiesKHR.

- `descriptorBindingAccelerationStructureUpdateAfterBind` indicates whether the implementation supports updating acceleration structure descriptors after a set is bound. If this feature is not enabled, `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` must not be used with `VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR`.

If the `VkPhysicalDeviceAccelerationStructureFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceAccelerationStructureFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceAccelerationStructureFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR`

The `VkPhysicalDeviceRayTracingPipelineFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_ray_tracing_pipeline
    typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           rayTracingPipeline;
        VkBool32           rayTracingPipelineShaderGroupHandleCaptureReplay;
        VkBool32           rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
        VkBool32           rayTracingPipelineTraceRaysIndirect;
        VkBool32           rayTraversalPrimitiveCulling;
    } VkPhysicalDeviceRayTracingPipelineFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `rayTracingPipeline` indicates whether the implementation supports the ray tracing pipeline functionality. See Ray Tracing.

- `rayTracingPipelineShaderGroupHandleCaptureReplay` indicates whether the implementation supports saving and reusing shader group handles, e.g. for trace capture and replay.

- `rayTracingPipelineShaderGroupHandleCaptureReplayMixed` indicates whether the implementation supports reuse of shader group handles being arbitrarily mixed with creation of non-reused shader group handles. If this is `VK_FALSE`, all reused shader group handles must be specified before any non-reused handles may be created.

- `rayTracingPipelineTraceRaysIndirect` indicates whether the implementation supports indirect ray tracing commands, e.g. vkCmdTraceRaysIndirectKHR.

- `rayTraversalPrimitiveCulling` indicates whether the implementation supports primitive culling during ray traversal.

If the `VkPhysicalDeviceRayTracingPipelineFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceRayTracingPipelineFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage

- VUID-VkPhysicalDeviceRayTracingPipelineFeaturesKHR-rayTracingPipelineShaderGroupHandleCaptureReplayMixed-03575
  If `rayTracingPipelineShaderGroupHandleCaptureReplayMixed` is `VK_TRUE`, `rayTracingPipelineShaderGroupHandleCaptureReplay` must also be `VK_TRUE`

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRayTracingPipelineFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR`

The `VkPhysicalDeviceRayQueryFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_ray_query
    typedef struct VkPhysicalDeviceRayQueryFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           rayQuery;
    } VkPhysicalDeviceRayQueryFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `rayQuery` indicates whether the implementation supports ray query (`OpRayQueryProceedKHR`) functionality.

If the `VkPhysicalDeviceRayQueryFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceRayQueryFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRayQueryFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR`

The `VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR` structure is defined as:

    // Provided by VK_KHR_ray_tracing_maintenance1
    typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           rayTracingMaintenance1;
        VkBool32           rayTracingPipelineTraceRaysIndirect2;
    } VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `rayTracingMaintenance1` indicates that the implementation supports the following:

  - The `CullMaskKHR` SPIR-V builtin using the `SPV_KHR_ray_cull_mask` SPIR-V extension.

  - Additional acceleration structure property queries: `VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR` and `VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR`.

  - A new access flag `VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR`.

  - A new pipeline stage flag bit `VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR`

- `rayTracingPipelineTraceRaysIndirect2` indicates whether the implementation supports the extended indirect ray tracing command vkCmdTraceRaysIndirect2KHR.

If the `VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR`

The `VkPhysicalDeviceExtendedDynamicStateFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_extended_dynamic_state
    typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           extendedDynamicState;
    } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `extendedDynamicState` indicates that the implementation supports the following dynamic states:

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

  - `VK_DYNAMIC_STATE_STENCIL_OP`

If the `VkPhysicalDeviceExtendedDynamicStateFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceExtendedDynamicStateFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceExtendedDynamicStateFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT`

The `VkPhysicalDeviceExtendedDynamicState2FeaturesEXT` structure is defined as:

    // Provided by VK_EXT_extended_dynamic_state2
    typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           extendedDynamicState2;
        VkBool32           extendedDynamicState2LogicOp;
        VkBool32           extendedDynamicState2PatchControlPoints;
    } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `extendedDynamicState2` indicates that the implementation supports the following dynamic states:

  - `VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE`

  - `VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE`

  - `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE`

- `extendedDynamicState2LogicOp` indicates that the implementation supports the following dynamic state:

  - `VK_DYNAMIC_STATE_LOGIC_OP_EXT`

- `extendedDynamicState2PatchControlPoints` indicates that the implementation supports the following dynamic state:

  - `VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT`

If the `VkPhysicalDeviceExtendedDynamicState2FeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceExtendedDynamicState2FeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceExtendedDynamicState2FeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT`

The `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV` structure is defined as:

    // Provided by VK_NV_device_generated_commands
    typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           deviceGeneratedCommands;
    } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `deviceGeneratedCommands` indicates whether the implementation supports functionality to generate commands on the device. See Device-Generated Commands.

If the `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV`

The `VkPhysicalDeviceDiagnosticsConfigFeaturesNV` structure is defined as:

    // Provided by VK_NV_device_diagnostics_config
    typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           diagnosticsConfig;
    } VkPhysicalDeviceDiagnosticsConfigFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `diagnosticsConfig` indicates whether the implementation supports the ability to configure diagnostic tools.

If the `VkPhysicalDeviceDiagnosticsConfigFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceDiagnosticsConfigFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDiagnosticsConfigFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV`

The `VkPhysicalDeviceDeviceMemoryReportFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_device_memory_report
    typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           deviceMemoryReport;
    } VkPhysicalDeviceDeviceMemoryReportFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `deviceMemoryReport` indicates whether the implementation supports the ability to register device memory report callbacks.

If the `VkPhysicalDeviceDeviceMemoryReportFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceDeviceMemoryReportFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDeviceMemoryReportFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT`

The `VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_global_priority
    typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           globalPriorityQuery;
    } VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR;

or the equivalent

    // Provided by VK_EXT_global_priority_query
    typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `globalPriorityQuery` indicates whether the implementation supports the ability to query global queue priorities.

If the `VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR`

The `VkPhysicalDevicePipelineCreationCacheControlFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           pipelineCreationCacheControl;
    } VkPhysicalDevicePipelineCreationCacheControlFeatures;

or the equivalent

    // Provided by VK_EXT_pipeline_creation_cache_control
    typedef VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `pipelineCreationCacheControl` indicates that the implementation supports:

  - The following can be used in `Vk*PipelineCreateInfo`::`flags`:

    - `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT`

    - `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT`

  - The following can be used in VkPipelineCacheCreateInfo::`flags`:

    - `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT`

If the `VkPhysicalDevicePipelineCreationCacheControlFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePipelineCreationCacheControlFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePipelineCreationCacheControlFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES`

The `VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderZeroInitializeWorkgroupMemory;
    } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;

or the equivalent

    // Provided by VK_KHR_zero_initialize_workgroup_memory
    typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderZeroInitializeWorkgroupMemory` specifies whether the implementation supports initializing a variable in Workgroup storage class.

If the `VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES`

The `VkPhysicalDevicePrivateDataFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDevicePrivateDataFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           privateData;
    } VkPhysicalDevicePrivateDataFeatures;

or the equivalent

    // Provided by VK_EXT_private_data
    typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `privateData` indicates whether the implementation supports private data. See Private Data.

If the `VkPhysicalDevicePrivateDataFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePrivateDataFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePrivateDataFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES`

The `VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_shader_subgroup_uniform_control_flow
    typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderSubgroupUniformControlFlow;
    } VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderSubgroupUniformControlFlow` specifies whether the implementation supports the shader execution mode `SubgroupUniformControlFlowKHR`

If the `VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR`

The `VkPhysicalDeviceRobustness2FeaturesEXT` structure is defined as:

    // Provided by VK_EXT_robustness2
    typedef struct VkPhysicalDeviceRobustness2FeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           robustBufferAccess2;
        VkBool32           robustImageAccess2;
        VkBool32           nullDescriptor;
    } VkPhysicalDeviceRobustness2FeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `robustBufferAccess2` indicates whether buffer accesses are tightly bounds-checked against the range of the descriptor. Uniform buffers must be bounds-checked to the range of the descriptor, where the range is rounded up to a multiple of robustUniformBufferAccessSizeAlignment. Storage buffers must be bounds-checked to the range of the descriptor, where the range is rounded up to a multiple of robustStorageBufferAccessSizeAlignment. Out of bounds buffer loads will return zero values, and image load, sample, and atomic operations from texel buffers will have (0,0,1) values inserted for missing G, B, or A components based on the format.

- `robustImageAccess2` indicates whether image accesses are tightly bounds-checked against the dimensions of the image view. Out of bounds image load, sample, and atomic operations from images will return zero values, with (0,0,1) values inserted for missing G, B, or A components based on the format.

- `nullDescriptor` indicates whether descriptors can be written with a VK_NULL_HANDLE resource or view, which are considered valid to access and act as if the descriptor were bound to nothing.

If the `VkPhysicalDeviceRobustness2FeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceRobustness2FeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage

- VUID-VkPhysicalDeviceRobustness2FeaturesEXT-robustBufferAccess2-04000
  If `robustBufferAccess2` is enabled then `robustBufferAccess` must also be enabled

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRobustness2FeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT`

The `VkPhysicalDeviceImageRobustnessFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceImageRobustnessFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           robustImageAccess;
    } VkPhysicalDeviceImageRobustnessFeatures;

or the equivalent

    // Provided by VK_EXT_image_robustness
    typedef VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `robustImageAccess` indicates whether image accesses are tightly bounds-checked against the dimensions of the image view. Invalid texels resulting from out of bounds image loads will be replaced as described in Texel Replacement, with either (0,0,1) or (0,0,0) values inserted for missing G, B, or A components based on the format.

If the `VkPhysicalDeviceImageRobustnessFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceImageRobustnessFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceImageRobustnessFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES`

The `VkPhysicalDeviceShaderTerminateInvocationFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderTerminateInvocation;
    } VkPhysicalDeviceShaderTerminateInvocationFeatures;

or the equivalent

    // Provided by VK_KHR_shader_terminate_invocation
    typedef VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderTerminateInvocation` specifies whether the implementation supports SPIR-V modules that use the `SPV_KHR_terminate_invocation` extension.

If the `VkPhysicalDeviceShaderTerminateInvocationFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderTerminateInvocationFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderTerminateInvocationFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES`

The `VkPhysicalDeviceCustomBorderColorFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_custom_border_color
    typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           customBorderColors;
        VkBool32           customBorderColorWithoutFormat;
    } VkPhysicalDeviceCustomBorderColorFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `customBorderColors` indicates that the implementation supports providing a `borderColor` value with one of the following values at sampler creation time:

  - `VK_BORDER_COLOR_FLOAT_CUSTOM_EXT`

  - `VK_BORDER_COLOR_INT_CUSTOM_EXT`

- `customBorderColorWithoutFormat` indicates that explicit formats are not required for custom border colors and the value of the `format` member of the VkSamplerCustomBorderColorCreateInfoEXT structure may be `VK_FORMAT_UNDEFINED`. If this feature bit is not set, applications must provide the VkFormat of the image view(s) being sampled by this sampler in the `format` member of the VkSamplerCustomBorderColorCreateInfoEXT structure.

If the `VkPhysicalDeviceCustomBorderColorFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceCustomBorderColorFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceCustomBorderColorFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT`

The `VkPhysicalDeviceBorderColorSwizzleFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_border_color_swizzle
    typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           borderColorSwizzle;
        VkBool32           borderColorSwizzleFromImage;
    } VkPhysicalDeviceBorderColorSwizzleFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `borderColorSwizzle` indicates that defined values are returned by sampled image operations when used with a sampler that uses a `VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK`, `VK_BORDER_COLOR_INT_OPAQUE_BLACK`, `VK_BORDER_COLOR_FLOAT_CUSTOM_EXT`, or `VK_BORDER_COLOR_INT_CUSTOM_EXT` `borderColor` and an image view that uses a non-identity component mapping, when either `borderColorSwizzleFromImage` is enabled or the VkSamplerBorderColorComponentMappingCreateInfoEXT is specified.

- `borderColorSwizzleFromImage` indicates that the implementation will return the correct border color values from sampled image operations under the conditions expressed above, without the application having to specify the border color component mapping when creating the sampler object. If this feature bit is not set, applications can chain a VkSamplerBorderColorComponentMappingCreateInfoEXT structure when creating samplers for use with image views that do not have an identity swizzle and, when those samplers are combined with image views using the same component mapping, sampled image operations that use opaque black or custom border colors will return the correct border color values.

If the `VkPhysicalDeviceBorderColorSwizzleFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceBorderColorSwizzleFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceBorderColorSwizzleFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT`

The `VkPhysicalDevicePortabilitySubsetFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_portability_subset
    typedef struct VkPhysicalDevicePortabilitySubsetFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           constantAlphaColorBlendFactors;
        VkBool32           events;
        VkBool32           imageViewFormatReinterpretation;
        VkBool32           imageViewFormatSwizzle;
        VkBool32           imageView2DOn3DImage;
        VkBool32           multisampleArrayImage;
        VkBool32           mutableComparisonSamplers;
        VkBool32           pointPolygons;
        VkBool32           samplerMipLodBias;
        VkBool32           separateStencilMaskRef;
        VkBool32           shaderSampleRateInterpolationFunctions;
        VkBool32           tessellationIsolines;
        VkBool32           tessellationPointMode;
        VkBool32           triangleFans;
        VkBool32           vertexAttributeAccessBeyondStride;
    } VkPhysicalDevicePortabilitySubsetFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `constantAlphaColorBlendFactors` indicates whether this implementation supports constant alpha Blend Factors used as source or destination color Blending.

- `events` indicates whether this implementation supports synchronization using Events.

- `imageViewFormatReinterpretation` indicates whether this implementation supports a `VkImageView` being created with a texel format containing a different number of components, or a different number of bits in each component, than the texel format of the underlying `VkImage`.

- `imageViewFormatSwizzle` indicates whether this implementation supports remapping format components using VkImageViewCreateInfo::`components`.

- `imageView2DOn3DImage` indicates whether this implementation supports a `VkImage` being created with the `VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT` flag set, permitting a 2D or 2D array image view to be created on a 3D `VkImage`.

- `multisampleArrayImage` indicates whether this implementation supports a `VkImage` being created as a 2D array with multiple samples per texel.

- `mutableComparisonSamplers` indicates whether this implementation allows descriptors with comparison samplers to be updated.

- `pointPolygons` indicates whether this implementation supports Rasterization using a point Polygon Mode.

- `samplerMipLodBias` indicates whether this implementation supports setting a mipmap LOD bias value when creating a sampler.

- `separateStencilMaskRef` indicates whether this implementation supports separate front and back Stencil Test reference values.

- `shaderSampleRateInterpolationFunctions` indicates whether this implementation supports fragment shaders which use the `InterpolationFunction` capability and the extended instructions `InterpolateAtCentroid`, `InterpolateAtOffset`, and `InterpolateAtSample` from the `GLSL.std.450` extended instruction set. This member is only meaningful if the `sampleRateShading` feature is supported.

- `tessellationIsolines` indicates whether this implementation supports isoline output from the Tessellation stage of a graphics pipeline. This member is only meaningful if `tessellationShader` are supported.

- `tessellationPointMode` indicates whether this implementation supports point output from the Tessellation stage of a graphics pipeline. This member is only meaningful if `tessellationShader` are supported.

- `triangleFans` indicates whether this implementation supports Triangle Fans primitive topology.

- `vertexAttributeAccessBeyondStride` indicates whether this implementation supports accessing a vertex input attribute beyond the stride of the corresponding vertex input binding.

If the `VkPhysicalDevicePortabilitySubsetFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePortabilitySubsetFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePortabilitySubsetFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR`

The `VkPhysicalDevicePerformanceQueryFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_performance_query
    typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           performanceCounterQueryPools;
        VkBool32           performanceCounterMultipleQueryPools;
    } VkPhysicalDevicePerformanceQueryFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `performanceCounterQueryPools` indicates whether the implementation supports performance counter query pools.

- `performanceCounterMultipleQueryPools` indicates whether the implementation supports using multiple performance query pools in a primary command buffer and secondary command buffers executed within it.

If the `VkPhysicalDevicePerformanceQueryFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePerformanceQueryFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePerformanceQueryFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR`

The `VkPhysicalDevice4444FormatsFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_4444_formats
    typedef struct VkPhysicalDevice4444FormatsFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           formatA4R4G4B4;
        VkBool32           formatA4B4G4R4;
    } VkPhysicalDevice4444FormatsFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `formatA4R4G4B4` indicates that the implementation must support using a VkFormat of `VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT` with at least the following VkFormatFeatureFlagBits:

  - `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`

  - `VK_FORMAT_FEATURE_BLIT_SRC_BIT`

  - `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`

- `formatA4B4G4R4` indicates that the implementation must support using a VkFormat of `VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT` with at least the following VkFormatFeatureFlagBits:

  - `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`

  - `VK_FORMAT_FEATURE_BLIT_SRC_BIT`

  - `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT`

If the `VkPhysicalDevice4444FormatsFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevice4444FormatsFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevice4444FormatsFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT`

| Note Although the formats defined by the `VK_EXT_4444_formats` extension were promoted to Vulkan 1.3 as optional formats, the VkPhysicalDevice4444FormatsFeaturesEXT structure was not promoted to Vulkan 1.3.

The `VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE` structure is defined as:

    // Provided by VK_VALVE_mutable_descriptor_type
    typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           mutableDescriptorType;
    } VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `mutableDescriptorType` indicates that the implementation must support using the VkDescriptorType of `VK_DESCRIPTOR_TYPE_MUTABLE_VALVE` with at least the following descriptor types, where any combination of the types must be supported:

  - `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE`

  - `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE`

  - `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER`

  - `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER`

  - `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER`

  - `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER`

- Additionally, `mutableDescriptorType` indicates that:

  - Non-uniform descriptor indexing must be supported if all descriptor types in a VkMutableDescriptorTypeListVALVE for `VK_DESCRIPTOR_TYPE_MUTABLE_VALVE` have the corresponding non-uniform indexing features enabled in VkPhysicalDeviceDescriptorIndexingFeatures.

  - `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT` with `descriptorType` of `VK_DESCRIPTOR_TYPE_MUTABLE_VALVE` relaxes the list of required descriptor types to the descriptor types which have the corresponding update-after-bind feature enabled in VkPhysicalDeviceDescriptorIndexingFeatures.

  - Dynamically uniform descriptor indexing must be supported if all descriptor types in a VkMutableDescriptorTypeListVALVE for `VK_DESCRIPTOR_TYPE_MUTABLE_VALVE` have the corresponding dynamic indexing features enabled.

  - `VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE` must be supported.

  - `VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE` must be supported.

If the `VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE`

The `VkPhysicalDeviceDepthClipControlFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_depth_clip_control
    typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           depthClipControl;
    } VkPhysicalDeviceDepthClipControlFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `depthClipControl` indicates that the implementation supports setting VkPipelineViewportDepthClipControlCreateInfoEXT::`negativeOneToOne` to `VK_TRUE`.

If the `VkPhysicalDeviceDepthClipControlFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceDepthClipControlFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDepthClipControlFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT`

The `VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_workgroup_memory_explicit_layout
    typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           workgroupMemoryExplicitLayout;
        VkBool32           workgroupMemoryExplicitLayoutScalarBlockLayout;
        VkBool32           workgroupMemoryExplicitLayout8BitAccess;
        VkBool32           workgroupMemoryExplicitLayout16BitAccess;
    } VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `workgroupMemoryExplicitLayout` indicates whether the implementation supports the SPIR-V `WorkgroupMemoryExplicitLayoutKHR` capability.

- `workgroupMemoryExplicitLayoutScalarBlockLayout` indicates whether the implementation supports scalar alignment for laying out Workgroup Blocks.

- `workgroupMemoryExplicitLayout8BitAccess` indicates whether objects in the `Workgroup` storage class with the `Block` decoration can have 8-bit integer members. If this feature is not enabled, 8-bit integer members must not be used in such objects. This also indicates whether shader modules can declare the `WorkgroupMemoryExplicitLayout8BitAccessKHR` capability.

- `workgroupMemoryExplicitLayout16BitAccess` indicates whether objects in the `Workgroup` storage class with the `Block` decoration can have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must not be used in such objects. This also indicates whether shader modules can declare the `WorkgroupMemoryExplicitLayout16BitAccessKHR` capability.

If the `VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR`

The `VkPhysicalDeviceSynchronization2Features` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceSynchronization2Features {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           synchronization2;
    } VkPhysicalDeviceSynchronization2Features;

or the equivalent

    // Provided by VK_KHR_synchronization2
    typedef VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2FeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `synchronization2` indicates whether the implementation supports the new set of synchronization commands introduced in `VK_KHR_synchronization2`.

If the `VkPhysicalDeviceSynchronization2Features` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceSynchronization2Features` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSynchronization2Features-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES`

The `VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_vertex_input_dynamic_state
    typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           vertexInputDynamicState;
    } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `vertexInputDynamicState` indicates that the implementation supports the following dynamic states:

  - `VK_DYNAMIC_STATE_VERTEX_INPUT_EXT`

If the `VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT`

The `VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_primitives_generated_query
    typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           primitivesGeneratedQuery;
        VkBool32           primitivesGeneratedQueryWithRasterizerDiscard;
        VkBool32           primitivesGeneratedQueryWithNonZeroStreams;
    } VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `primitivesGeneratedQuery` indicates whether the implementation supports the `VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT` query type.

- `primitivesGeneratedQueryWithRasterizerDiscard` indicates whether the implementation supports this query when rasterization discard is enabled.

- `primitivesGeneratedQueryWithNonZeroStreams` indicates whether the implementation supports this query with a non-zero index in vkCmdBeginQueryIndexedEXT.

If the `VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT`

The `VkPhysicalDeviceFragmentShadingRateFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_fragment_shading_rate
    typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           pipelineFragmentShadingRate;
        VkBool32           primitiveFragmentShadingRate;
        VkBool32           attachmentFragmentShadingRate;
    } VkPhysicalDeviceFragmentShadingRateFeaturesKHR;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `pipelineFragmentShadingRate` indicates that the implementation supports the pipeline fragment shading rate.

- `primitiveFragmentShadingRate` indicates that the implementation supports the primitive fragment shading rate.

- `attachmentFragmentShadingRate` indicates that the implementation supports the attachment fragment shading rate.

If the `VkPhysicalDeviceFragmentShadingRateFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceFragmentShadingRateFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentShadingRateFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR`

The `VkPhysicalDeviceLegacyDitheringFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_legacy_dithering
    typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           legacyDithering;
    } VkPhysicalDeviceLegacyDitheringFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `legacyDithering` indicates whether the implementation supports Legacy Dithering.

If the `VkPhysicalDeviceLegacyDitheringFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceLegacyDitheringFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceLegacyDitheringFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT`

The `VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV` structure is defined as:

    // Provided by VK_NV_fragment_shading_rate_enums
    typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           fragmentShadingRateEnums;
        VkBool32           supersampleFragmentShadingRates;
        VkBool32           noInvocationFragmentShadingRates;
    } VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `fragmentShadingRateEnums` indicates that the implementation supports specifying fragment shading rates using the `VkFragmentShadingRateNV` enumerated type.

- `supersampleFragmentShadingRates` indicates that the implementation supports fragment shading rate enum values indicating more than one invocation per fragment.

- `noInvocationFragmentShadingRates` indicates that the implementation supports a fragment shading rate enum value indicating that no fragment shaders should be invoked when that shading rate is used.

If the `VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV`

The `VkPhysicalDeviceInheritedViewportScissorFeaturesNV` structure is defined as:

    // Provided by VK_NV_inherited_viewport_scissor
    typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           inheritedViewportScissor2D;
    } VkPhysicalDeviceInheritedViewportScissorFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `inheritedViewportScissor2D` indicates whether secondary command buffers can inherit most of the dynamic state affected by `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT`, `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT`, `VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT`, `VK_DYNAMIC_STATE_VIEWPORT` or `VK_DYNAMIC_STATE_SCISSOR`, from a primary command buffer.

If the `VkPhysicalDeviceInheritedViewportScissorFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceInheritedViewportScissorFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceInheritedViewportScissorFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV`

The `VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_ycbcr_2plane_444_formats
    typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           ycbcr2plane444Formats;
    } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `ycbcr2plane444Formats` indicates that the implementation supports the following 2-plane 444 Y′CBCR formats:

  - `VK_FORMAT_G8_B8R8_2PLANE_444_UNORM`

  - `VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16`

  - `VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16`

  - `VK_FORMAT_G16_B16R16_2PLANE_444_UNORM`

If the `VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT`

| Note Although the formats defined by the `VK_EXT_ycbcr_2plane_444_formats` were promoted to Vulkan 1.3 as optional formats, the VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT structure was not promoted to Vulkan 1.3.

The `VkPhysicalDeviceColorWriteEnableFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_color_write_enable
    typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           colorWriteEnable;
    } VkPhysicalDeviceColorWriteEnableFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `colorWriteEnable` indicates that the implementation supports the dynamic state `VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT`.

If the `VkPhysicalDeviceColorWriteEnableFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceColorWriteEnableFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceColorWriteEnableFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT`

The `VkPhysicalDevicePipelinePropertiesFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_pipeline_properties
    typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           pipelinePropertiesIdentifier;
    } VkPhysicalDevicePipelinePropertiesFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `pipelinePropertiesIdentifier` indicates that the implementation supports querying a unique pipeline identifier.

If the `VkPhysicalDevicePipelinePropertiesFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePipelinePropertiesFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePipelinePropertiesFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT`

The `VkPhysicalDeviceProvokingVertexFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_provoking_vertex
    typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           provokingVertexLast;
        VkBool32           transformFeedbackPreservesProvokingVertex;
    } VkPhysicalDeviceProvokingVertexFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `provokingVertexLast` indicates whether the implementation supports the `VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT` provoking vertex mode for flat shading.

- `transformFeedbackPreservesProvokingVertex` indicates that the order of vertices within each primitive written by transform feedback will preserve the provoking vertex. This does not apply to triangle fan primitives when `transformFeedbackPreservesTriangleFanProvokingVertex` is `VK_FALSE`. `transformFeedbackPreservesProvokingVertex` must be `VK_FALSE` when the `VK_EXT_transform_feedback` extension is not supported.

If the `VkPhysicalDeviceProvokingVertexFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceProvokingVertexFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

When `VkPhysicalDeviceProvokingVertexFeaturesEXT` is in the `pNext` chain of VkDeviceCreateInfo but the `transformFeedback` feature is not enabled, the value of `transformFeedbackPreservesProvokingVertex` is ignored.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceProvokingVertexFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT`

The `VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_pageable_device_local_memory
    typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           pageableDeviceLocalMemory;
    } VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `pageableDeviceLocalMemory` indicates that the implementation supports pageable device-local memory and may transparently move device-local memory allocations to host-local memory to better share device-local memory with other applications.

If the `VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT`

The `VkPhysicalDeviceMultiDrawFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_multi_draw
    typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           multiDraw;
    } VkPhysicalDeviceMultiDrawFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `multiDraw` indicates that the implementation supports vkCmdDrawMultiEXT and vkCmdDrawMultiIndexedEXT.

If the `VkPhysicalDeviceMultiDrawFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceMultiDrawFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMultiDrawFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT`

The `VkPhysicalDeviceRayTracingMotionBlurFeaturesNV` structure is defined as:

    // Provided by VK_NV_ray_tracing_motion_blur
    typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           rayTracingMotionBlur;
        VkBool32           rayTracingMotionBlurPipelineTraceRaysIndirect;
    } VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `rayTracingMotionBlur` indicates whether the implementation supports the motion blur feature.

- `rayTracingMotionBlurPipelineTraceRaysIndirect` indicates whether the implementation supports indirect ray tracing commands with the motion blur feature enabled.

If the `VkPhysicalDeviceRayTracingMotionBlurFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceRayTracingMotionBlurFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRayTracingMotionBlurFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV`

The `VkPhysicalDeviceSubpassShadingFeaturesHUAWEI` structure is defined as:

    // Provided by VK_HUAWEI_subpass_shading
    typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           subpassShading;
    } VkPhysicalDeviceSubpassShadingFeaturesHUAWEI;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `subpassShading` specifies whether subpass shading is supported.

If the `VkPhysicalDeviceSubpassShadingFeaturesHUAWEI` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceSubpassShadingFeaturesHUAWEI` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSubpassShadingFeaturesHUAWEI-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI`

The `VkPhysicalDeviceExternalMemoryRDMAFeaturesNV` structure is defined as:

    // Provided by VK_NV_external_memory_rdma
    typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           externalMemoryRDMA;
    } VkPhysicalDeviceExternalMemoryRDMAFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `externalMemoryRDMA` indicates whether the implementation has support for the `VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV` memory property and the `VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV` external memory handle type.

If the `VkPhysicalDeviceExternalMemoryRDMAFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceExternalMemoryRDMAFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceExternalMemoryRDMAFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV`

The `VkPhysicalDevicePresentIdFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_present_id
    typedef struct VkPhysicalDevicePresentIdFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           presentId;
    } VkPhysicalDevicePresentIdFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `presentId` indicates that the implementation supports specifying present ID values in the `VkPresentIdKHR` extension to the `VkPresentInfoKHR` struct.

If the `VkPhysicalDevicePresentIdFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePresentIdFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePresentIdFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR`

The `VkPhysicalDevicePresentWaitFeaturesKHR` structure is defined as:

    // Provided by VK_KHR_present_wait
    typedef struct VkPhysicalDevicePresentWaitFeaturesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           presentWait;
    } VkPhysicalDevicePresentWaitFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `presentWait` indicates that the implementation supports `vkWaitForPresentKHR`.

If the `VkPhysicalDevicePresentWaitFeaturesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePresentWaitFeaturesKHR` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePresentWaitFeaturesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR`

The `VkPhysicalDeviceShaderIntegerDotProductFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderIntegerDotProduct;
    } VkPhysicalDeviceShaderIntegerDotProductFeatures;

or the equivalent

    // Provided by VK_KHR_shader_integer_dot_product
    typedef VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderIntegerDotProduct` specifies whether shader modules can declare the `DotProductInputAllKHR`, `DotProductInput4x8BitKHR`, `DotProductInput4x8BitPackedKHR` and `DotProductKHR` capabilities.

If the `VkPhysicalDeviceShaderIntegerDotProductFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderIntegerDotProductFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderIntegerDotProductFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES`

The `VkPhysicalDeviceMaintenance4Features` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceMaintenance4Features {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           maintenance4;
    } VkPhysicalDeviceMaintenance4Features;

or the equivalent

    // Provided by VK_KHR_maintenance4
    typedef VkPhysicalDeviceMaintenance4Features VkPhysicalDeviceMaintenance4FeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `maintenance4` indicates that the implementation supports the following:

  - The application may destroy a VkPipelineLayout object immediately after using it to create another object.

  - `LocalSizeId` can be used as an alternative to `LocalSize` to specify the local workgroup size with specialization constants.

  - Images created with identical creation parameters will always have the same alignment requirements.

  - The size memory requirement of a buffer or image is never greater than that of another buffer or image created with a greater or equal size.

  - Push constants do not have to be initialized before they are dynamically accessed.

  - The interface matching rules allow a larger output vector to match with a smaller input vector, with additional values being discarded.

If the `VkPhysicalDeviceMaintenance4Features` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceMaintenance4Features` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMaintenance4Features-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES`

The `VkPhysicalDeviceDynamicRenderingFeatures` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceDynamicRenderingFeatures {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           dynamicRendering;
    } VkPhysicalDeviceDynamicRenderingFeatures;

or the equivalent

    // Provided by VK_KHR_dynamic_rendering
    typedef VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeaturesKHR;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `dynamicRendering` specifies that the implementation supports dynamic render pass instances using the vkCmdBeginRendering command.

If the `VkPhysicalDeviceDynamicRenderingFeatures` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceDynamicRenderingFeatures` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDynamicRenderingFeatures-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES`

The `VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_rgba10x6_formats
    typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           formatRgba10x6WithoutYCbCrSampler;
    } VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `formatRgba10x6WithoutYCbCrSampler` indicates that `VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16` can be used with a `VkImageView` with `subresourceRange.aspectMask` equal to `VK_IMAGE_ASPECT_COLOR_BIT` without a sampler Y′CBCR conversion enabled.

If the `VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT`

The `VkPhysicalDevicePipelineRobustnessFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_pipeline_robustness
    typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           pipelineRobustness;
    } VkPhysicalDevicePipelineRobustnessFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `pipelineRobustness` indicates that robustness can be requested on a per-pipeline-stage granularity.

| Note Enabling `pipelineRobustness` may, on some platforms, incur a minor performance cost when `robustBufferAccess` is disabled, even for pipelines which do not make use of any robustness features. If robustness is not needed, `pipelineRobustness` should not be enabled by an application.

If the `VkPhysicalDevicePipelineRobustnessFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDevicePipelineRobustnessFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePipelineRobustnessFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT`

The `VkPhysicalDeviceImageViewMinLodFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_image_view_min_lod
    typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           minLod;
    } VkPhysicalDeviceImageViewMinLodFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `minLod` indicates whether the implementation supports clamping the minimum LOD value during Image Level(s) Selection, Texel Gathering and Integer Texel Coordinate Operations with a given VkImageView by VkImageViewMinLodCreateInfoEXT::`minLod`.

If the `VkPhysicalDeviceImageViewMinLodFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceImageViewMinLodFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceImageViewMinLodFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT`

The `VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_rasterization_order_attachment_access
    typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           rasterizationOrderColorAttachmentAccess;
        VkBool32           rasterizationOrderDepthAttachmentAccess;
        VkBool32           rasterizationOrderStencilAttachmentAccess;
    } VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;

or the equivalent

    // Provided by VK_ARM_rasterization_order_attachment_access
    typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `rasterizationOrderColorAttachmentAccess` indicates that rasterization order access to color and input attachments is supported by the implementation.

- `rasterizationOrderDepthAttachmentAccess` indicates that rasterization order access to the depth aspect of depth/stencil and input attachments is supported by the implementation.

- `rasterizationOrderStencilAttachmentAccess` indicates that rasterization order access to the stencil aspect of depth/stencil and input attachments is supported by the implementation.

If the `VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT`

The `VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_subpass_merge_feedback
    typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           subpassMergeFeedback;
    } VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `subpassMergeFeedback` indicates whether the implementation supports feedback of subpass merging.

If the `VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT`

The `VkPhysicalDeviceLinearColorAttachmentFeaturesNV` structure is defined as:

    // Provided by VK_NV_linear_color_attachment
    typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           linearColorAttachment;
    } VkPhysicalDeviceLinearColorAttachmentFeaturesNV;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `linearColorAttachment` indicates whether the implementation supports renderable Linear Color Attachment

If the `VkPhysicalDeviceLinearColorAttachmentFeaturesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceLinearColorAttachmentFeaturesNV` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceLinearColorAttachmentFeaturesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV`

The `VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_attachment_feedback_loop_layout
    typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           attachmentFeedbackLoopLayout;
    } VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `attachmentFeedbackLoopLayout` indicates whether the implementation supports using `VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT` image layout for images created with `VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT`.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT`

The `VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_graphics_pipeline_library
    typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           graphicsPipelineLibrary;
    } VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `graphicsPipelineLibrary` indicates that the implementation supports graphics pipeline libraries.

If the `VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT`

The `VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_multisampled_render_to_single_sampled
    typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           multisampledRenderToSingleSampled;
    } VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `multisampledRenderToSingleSampled` indicates that the implementation supports multisampled rendering to single-sampled render pass attachments.

If the `VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT`

The `VkPhysicalDeviceImage2DViewOf3DFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_image_2d_view_of_3d
    typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           image2DViewOf3D;
        VkBool32           sampler2DViewOf3D;
    } VkPhysicalDeviceImage2DViewOf3DFeaturesEXT;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `image2DViewOf3D` indicates that the implementation supports using a 2D view of a 3D image in a descriptor of type `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE` if the image is created using `VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT`.

- `sampler2DViewOf3D` indicates that the implementation supports using a 2D view of a 3D image in a descriptor of type `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE` or `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER` if the image is created using `VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT`.

If the `VkPhysicalDeviceImage2DViewOf3DFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceImage2DViewOf3DFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceImage2DViewOf3DFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT`

The `VkPhysicalDeviceImageCompressionControlFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_image_compression_control
    typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           imageCompressionControl;
    } VkPhysicalDeviceImageCompressionControlFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `imageCompressionControl` indicates that the implementation supports providing controls for image compression at image creation time.

If the `VkPhysicalDeviceImageCompressionControlFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceImageCompressionControlFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceImageCompressionControlFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT`

The `VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_image_compression_control_swapchain
    typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           imageCompressionControlSwapchain;
    } VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `imageCompressionControlSwapchain` indicates that the implementation supports controlling image controls per swapchain and querying image compression properties per surface.

If the `VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT`

The `VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD` structure is defined as:

    // Provided by VK_AMD_shader_early_and_late_fragment_tests
    typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderEarlyAndLateFragmentTests;
    } VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderEarlyAndLateFragmentTests` indicates whether the implementation supports the `EarlyAndLateFragmentTestsAMD` `Execution` `Mode`.

If the `VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD`

The `VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_non_seamless_cube_map
    typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           nonSeamlessCubeMap;
    } VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `nonSeamlessCubeMap` indicates that the implementation supports `VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT`.

If the `VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT`

The `VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_shader_module_identifier
    typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           shaderModuleIdentifier;
    } VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `shaderModuleIdentifier` indicates whether the implementation supports querying an identifier of a VkShaderModule or VkShaderModuleCreateInfo structure, and creating pipelines from identifiers only.

If the `VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT`

The `VkPhysicalDeviceTilePropertiesFeaturesQCOM` structure is defined as:

    // Provided by VK_QCOM_tile_properties
    typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           tileProperties;
    } VkPhysicalDeviceTilePropertiesFeaturesQCOM;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `tileProperties` indicates that the implementation supports queries for returning tile properties.

If the `VkPhysicalDeviceTilePropertiesFeaturesQCOM` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceTilePropertiesFeaturesQCOM` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceTilePropertiesFeaturesQCOM-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM`

The `VkPhysicalDeviceImageProcessingFeaturesQCOM` structure is defined as:

    // Provided by VK_QCOM_image_processing
    typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           textureSampleWeighted;
        VkBool32           textureBoxFilter;
        VkBool32           textureBlockMatch;
    } VkPhysicalDeviceImageProcessingFeaturesQCOM;

This structure describes the following features:

- `sType` is the type of this structure.

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

- `textureSampleWeighted` indicates that the implementation supports shader modules that declare the `TextureSampleWeightedQCOM` capability.

- `textureBoxFilter` indicates that the implementation supports shader modules that declare the `TextureBoxFilterQCOM` capability.

- `textureBlockMatch` indicates that the implementation supports shader modules that declare the `TextureBlockMatchQCOM` capability.

If the `VkPhysicalDeviceImageProcessingFeaturesQCOM` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceImageProcessingFeaturesQCOM` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceImageProcessingFeaturesQCOM-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM`

The `VkPhysicalDeviceDepthClampZeroOneFeaturesEXT` structure is defined as:

    // Provided by VK_EXT_depth_clamp_zero_one
    typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           depthClampZeroOne;
    } VkPhysicalDeviceDepthClampZeroOneFeaturesEXT;

This structure describes the following feature:

- `sType` is the type of this structure.

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

- `depthClampZeroOne` indicates that the implementation supports clamping the depth to a range of `0` to `1`.

If the `VkPhysicalDeviceDepthClampZeroOneFeaturesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceFeatures2 structure passed to vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. `VkPhysicalDeviceDepthClampZeroOneFeaturesEXT` can also be used in the `pNext` chain of VkDeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDepthClampZeroOneFeaturesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT`

### 41.1. Feature Requirements

All Vulkan graphics implementations must support the following features:

- `robustBufferAccess`, unless the `VK_KHR_portability_subset` extension is enabled.

- `multiview`, if Vulkan 1.1 is supported.

- `shaderDrawParameters`, if the `VK_KHR_shader_draw_parameters` extension is supported.

- `uniformBufferStandardLayout`, if Vulkan 1.2 or the `VK_KHR_uniform_buffer_standard_layout` extension is supported.

- `variablePointersStorageBuffer`, if the `VK_KHR_variable_pointers` extension is supported.

- `storageBuffer8BitAccess`, if the `VK_KHR_8bit_storage` extension is supported.

- `storageBuffer8BitAccess`, if `uniformAndStorageBuffer8BitAccess` is enabled.

- If the `descriptorIndexing` feature is supported, or if the `VK_EXT_descriptor_indexing` extension is supported:

  - `shaderSampledImageArrayDynamicIndexing`

  - `shaderStorageBufferArrayDynamicIndexing`

  - `shaderUniformTexelBufferArrayDynamicIndexing`

  - `shaderStorageTexelBufferArrayDynamicIndexing`

  - `shaderSampledImageArrayNonUniformIndexing`

  - `shaderStorageBufferArrayNonUniformIndexing`

  - `shaderUniformTexelBufferArrayNonUniformIndexing`

  - `descriptorBindingSampledImageUpdateAfterBind`

  - `descriptorBindingStorageImageUpdateAfterBind`

  - `descriptorBindingStorageBufferUpdateAfterBind` (see also `robustBufferAccessUpdateAfterBind`)

  - `descriptorBindingUniformTexelBufferUpdateAfterBind` (see also `robustBufferAccessUpdateAfterBind`)

  - `descriptorBindingStorageTexelBufferUpdateAfterBind` (see also `robustBufferAccessUpdateAfterBind`)

  - `descriptorBindingUpdateUnusedWhilePending`

  - `descriptorBindingPartiallyBound`

  - `runtimeDescriptorArray`

- If Vulkan 1.3 is supported:

  - `vulkanMemoryModel`

  - `vulkanMemoryModelDeviceScope`

- `inlineUniformBlock`, if Vulkan 1.3 or the `VK_EXT_inline_uniform_block` extension is supported.

- `descriptorBindingInlineUniformBlockUpdateAfterBind`, if Vulkan 1.3 or the `VK_EXT_inline_uniform_block` extension is supported; and if the `descriptorIndexing` feature is supported, or the `VK_EXT_descriptor_indexing` extension is supported.

- `scalarBlockLayout`, if the `VK_EXT_scalar_block_layout` extension is supported.

- `subgroupBroadcastDynamicId`, if Vulkan 1.2 is supported.

- `samplerMirrorClampToEdge`, if the `VK_KHR_sampler_mirror_clamp_to_edge` extension is supported.

- `drawIndirectCount`, if the `VK_KHR_draw_indirect_count` extension is supported.

- `samplerFilterMinmax`, if the `VK_EXT_sampler_filter_minmax` extension is supported.

- `shaderOutputViewportIndex`, if the `VK_EXT_shader_viewport_index_layer` extension is supported.

- `shaderOutputLayer`, if the `VK_EXT_shader_viewport_index_layer` extension is supported.

- `subgroupSizeControl`, if Vulkan 1.3 or the `VK_EXT_subgroup_size_control` extension is supported.

- `computeFullSubgroups`, if Vulkan 1.3 or the `VK_EXT_subgroup_size_control` extension is supported.

- `deviceMemoryReport`, if the `VK_EXT_device_memory_report` extension is supported.

- `globalPriorityQuery`, if the `VK_EXT_global_priority_query` extension is supported.

- `globalPriorityQuery`, if the `VK_KHR_global_priority` extension is supported.

- `imagelessFramebuffer`, if Vulkan 1.2 or the `VK_KHR_imageless_framebuffer` extension is supported.

- `separateDepthStencilLayouts`, if Vulkan 1.2 or the `VK_KHR_separate_depth_stencil_layouts` extension is supported.

- `hostQueryReset`, if Vulkan 1.2 or the `VK_EXT_host_query_reset` extension is supported.

- `timelineSemaphore`, if Vulkan 1.2 or the `VK_KHR_timeline_semaphore` extension is supported.

- If the `VK_KHR_acceleration_structure` extension is supported:

  - `accelerationStructure`

  - All the features required by the `descriptorIndexing` feature if Vulkan 1.2 is supported, or the `VK_EXT_descriptor_indexing` extension.

  - `descriptorBindingAccelerationStructureUpdateAfterBind`

  - `bufferDeviceAddress` from Vulkan 1.2 or the `VK_KHR_buffer_device_address` extension.

- If the `VK_KHR_ray_tracing_pipeline` extension is supported:

  - `rayTracingPipeline`

  - `rayTracingPipelineTraceRaysIndirect`

  - `rayTraversalPrimitiveCulling`, if `rayQuery` is supported

  - the `VK_KHR_pipeline_library` extension must be supported.

- `rayQuery`, if the `VK_KHR_ray_query` extension is supported.

- `pipelineCreationCacheControl`, if Vulkan 1.3 or the `VK_EXT_pipeline_creation_cache_control` extension is supported.

- `shaderSubgroupExtendedTypes`, if Vulkan 1.2 or the `VK_KHR_shader_subgroup_extended_types` extension is supported.

- `samplerYcbcrConversion`, if the `VK_KHR_sampler_ycbcr_conversion` extension is supported.

- `pipelineExecutableInfo`, if the `VK_KHR_pipeline_executable_properties` extension is supported.

- `textureCompressionASTC_HDR`, if the `VK_EXT_texture_compression_astc_hdr` extension is supported.

- `depthClipEnable`, if the `VK_EXT_depth_clip_enable` extension is supported.

- `memoryPriority`, if the `VK_EXT_memory_priority` extension is supported.

- `ycbcrImageArrays`, if the `VK_EXT_ycbcr_image_arrays` extension is supported.

- `indexTypeUint8`, if the `VK_EXT_index_type_uint8` extension is supported.

- `primitiveTopologyListRestart`, if the `VK_EXT_primitive_topology_list_restart` extension is supported.

- `shaderDemoteToHelperInvocation`, if Vulkan 1.3 or the `VK_EXT_shader_demote_to_helper_invocation` extension is supported.

- `texelBufferAlignment`, if Vulkan 1.3 or the `VK_EXT_texel_buffer_alignment` extension is supported.

- `vulkanMemoryModel`, if the `VK_KHR_vulkan_memory_model` extension is supported.

- `bufferDeviceAddress`, if Vulkan 1.3 or the `VK_KHR_buffer_device_address` extension is supported.

- `performanceCounterQueryPools`, if the `VK_KHR_performance_query` extension is supported.

- `transformFeedback`, if the `VK_EXT_transform_feedback` extension is supported.

- `conditionalRendering`, if the `VK_EXT_conditional_rendering` extension is supported.

- `vertexAttributeInstanceRateDivisor`, if the `VK_EXT_vertex_attribute_divisor` extension is supported.

- `fragmentDensityMap`, if the `VK_EXT_fragment_density_map` extension is supported.

- `shaderSubgroupClock`, if the `VK_KHR_shader_clock` extension is supported.

- `shaderBufferInt64Atomics`, if the `VK_KHR_shader_atomic_int64` extension is supported.

- `shaderInt64`, if the `shaderSharedInt64Atomics` or `shaderBufferInt64Atomics` features are supported.

- `shaderFloat16` or `shaderInt8`, if the `VK_KHR_shader_float16_int8` extension is supported.

- `fragmentShaderSampleInterlock` or `fragmentShaderPixelInterlock` or `fragmentShaderShadingRateInterlock`, if the `VK_EXT_fragment_shader_interlock` extension is supported.

- `rectangularLines` or `bresenhamLines` or `smoothLines` or `stippledRectangularLines` or `stippledBresenhamLines` or `stippledSmoothLines`, if the `VK_EXT_line_rasterization` extension is supported.

- `storageBuffer16BitAccess`, if the `VK_KHR_16bit_storage` extension is supported.

- `storageBuffer16BitAccess`, if `uniformAndStorageBuffer16BitAccess` is enabled.

- `robustImageAccess`, if Vulkan 1.3 or the `VK_EXT_image_robustness` extension is supported.

- `formatA4R4G4B4`, if the `VK_EXT_4444_formats` extension is supported.

- `mutableDescriptorType`, if the `VK_VALVE_mutable_descriptor_type` extension is supported.

- `shaderInt64` and `shaderImageInt64Atomics`, if the `VK_EXT_shader_image_atomic_int64` extension is supported.

- `shaderImageInt64Atomics`, if the `sparseImageInt64Atomics` feature is supported.

- `shaderImageFloat32Atomics`, if the `sparseImageFloat32Atomics` feature is supported.

- `shaderImageFloat32AtomicAdd`, if the `sparseImageFloat32AtomicAdd` feature is supported.

- `primitivesGeneratedQuery`, if the `VK_EXT_primitives_generated_query` extension is supported.

- `pipelineFragmentShadingRate`, if the `VK_KHR_fragment_shading_rate` extension is supported.

- `legacyDithering`, if the `VK_EXT_legacy_dithering` extension is supported.

- `shaderTerminateInvocation` if Vulkan 1.3 or the `VK_KHR_shader_terminate_invocation` extension is supported.

- `shaderZeroInitializeWorkgroupMemory`, if Vulkan 1.3 or the `VK_KHR_zero_initialize_workgroup_memory` extension is supported.

- `workgroupMemoryExplicitLayout`, if the `VK_KHR_workgroup_memory_explicit_layout` extension is supported.

- `vertexInputDynamicState`, if the `VK_EXT_vertex_input_dynamic_state` extension is supported.

- `synchronization2` if Vulkan 1.3 or the `VK_KHR_synchronization2` extension is supported.

- `provokingVertexLast`, if the `VK_EXT_provoking_vertex` extension is supported.

- `shaderSubgroupUniformControlFlow`, if the `VK_KHR_shader_subgroup_uniform_control_flow` extension is supported.

- `borderColorSwizzle` if the `VK_EXT_border_color_swizzle` extension is supported.

- `multiDraw`, if the `VK_EXT_multi_draw` extension is supported.

- `shaderImageFloat32AtomicMinMax`, if the `sparseImageFloat32AtomicMinMax` feature is supported.

- `presentId`, if the `VK_KHR_present_id` extension is supported.

- `presentWait`, if the `VK_KHR_present_wait` extension is supported.

- `shaderIntegerDotProduct` if Vulkan 1.3 or the `VK_KHR_shader_integer_dot_product` extension is supported.

- `maintenance4`, if Vulkan 1.3 or the `VK_KHR_maintenance4` extension is supported.

- `image2DViewOf3D`, if the `VK_EXT_image_2d_view_of_3d` extension is supported.

- `privateData`, if Vulkan 1.3 or the `VK_EXT_private_data` extension is supported.

- `extendedDynamicState`, if the `VK_EXT_extended_dynamic_state` extension is supported.

- `extendedDynamicState2`, if the `VK_EXT_extended_dynamic_state2` extension is supported.

- `depthClipControl`, if the `VK_EXT_depth_clip_control` extension is supported.

- `minLod`, if the `VK_EXT_image_view_min_lod` extension is supported.

- `linearColorAttachment`, if the `VK_NV_linear_color_attachment` extension is supported.

- `graphicsPipelineLibrary`, if the `VK_EXT_graphics_pipeline_library` extension is supported.

- `dynamicRendering`, if Vulkan 1.3 or the `VK_KHR_dynamic_rendering` extension is supported.

- `taskShader` and `meshShader`, if the `VK_EXT_mesh_shader` extension is supported.

- `primitiveFragmentShadingRate` if `primitiveFragmentShadingRateMeshShader` feature is supported.

- `subpassMergeFeedback`, if the `VK_EXT_subpass_merge_feedback` extension is supported.

- `rayTracingMaintenance1`, if the `VK_KHR_ray_tracing_maintenance1` extension is supported.

- `colorWriteEnable`, if the `VK_EXT_color_write_enable` extension is supported.

- `multisampledRenderToSingleSampled`, if the `VK_EXT_multisampled_render_to_single_sampled` extension is supported.

- `imageCompressionControl`, if the `VK_EXT_image_compression_control` extension is supported.

- `imageCompressionControlSwapchain`, if the `VK_EXT_image_compression_control_swapchain` extension is supported.

- `shaderEarlyAndLateFragmentTests`, if the `VK_AMD_shader_early_and_late_fragment_tests` extension is supported.

- `nonSeamlessCubeMap`, if the `VK_EXT_non_seamless_cube_map` extension is supported.

- `shaderModuleIdentifier`, if `VK_EXT_shader_module_identifier` extension is supported.

- `pipelineRobustness`, if the `VK_EXT_pipeline_robustness` extension is supported.

- `textureSampleWeighted`, `TextureBlockMatch`, and `TextureBoxFilter` if `VK_QCOM_image_processing` extension is supported.

- `tileProperties` if `VK_QCOM_tile_properties` extension is supported.

- `attachmentFeedbackLoopLayout`, if the `VK_EXT_attachment_feedback_loop_layout` extension is supported.

- `depthClampZeroOne`, if the `VK_EXT_depth_clamp_zero_one` extension is supported.

All other features defined in the Specification are optional.

### 41.2. Profile Features

#### 41.2.1. Roadmap 2022

Implementations that claim support for the Roadmap 2022 profile must support the following features:

- `fullDrawIndexUint32`

- `imageCubeArray`

- `independentBlend`

- `sampleRateShading`

- `drawIndirectFirstInstance`

- `depthClamp`

- `depthBiasClamp`

- `samplerAnisotropy`

- `occlusionQueryPrecise`

- `fragmentStoresAndAtomics`

- `shaderStorageImageExtendedFormats`

- `shaderUniformBufferArrayDynamicIndexing`

- `shaderSampledImageArrayDynamicIndexing`

- `shaderStorageBufferArrayDynamicIndexing`

- `shaderStorageImageArrayDynamicIndexing`

- `samplerYcbcrConversion`

- `samplerMirrorClampToEdge`

- `descriptorIndexing`

- `shaderUniformTexelBufferArrayDynamicIndexing`

- `shaderStorageTexelBufferArrayDynamicIndexing`

- `shaderUniformBufferArrayNonUniformIndexing`

- `shaderSampledImageArrayNonUniformIndexing`

- `shaderStorageBufferArrayNonUniformIndexing`

- `shaderStorageImageArrayNonUniformIndexing`

- `shaderUniformTexelBufferArrayNonUniformIndexing`

- `shaderStorageTexelBufferArrayNonUniformIndexing`

- `descriptorBindingSampledImageUpdateAfterBind`

- `descriptorBindingStorageImageUpdateAfterBind`

- `descriptorBindingStorageBufferUpdateAfterBind`

- `descriptorBindingUniformTexelBufferUpdateAfterBind`

- `descriptorBindingStorageTexelBufferUpdateAfterBind`

- `descriptorBindingUpdateUnusedWhilePending`

- `descriptorBindingPartiallyBound`

- `descriptorBindingVariableDescriptorCount`

- `runtimeDescriptorArray`

- `scalarBlockLayout`