Vulkan Logo

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

    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 a VkStructureType value identifying 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 on 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 VkPhysicalDeviceCooperativeMatrixFeaturesKHR::cooperativeMatrixRobustBufferAccess feature is not enabled, then accesses using OpCooperativeMatrixLoadKHR and OpCooperativeMatrixStoreKHR 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 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.

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

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

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

      • 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 robustBufferAccess is not enabled, applications must not perform out of bounds accesses .

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

    • 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 and storage texel buffers 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 and storage texel buffers 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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 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 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 vertex or tessellation evaluation shaders. If this feature is not enabled, the ViewportIndex built-in decoration must not be used on outputs in 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 vertex or tessellation evaluation shaders. If this feature is not enabled, the Layer built-in decoration must not be used on outputs in 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 a VkStructureType value identifying 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 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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 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 a VkStructureType value identifying 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 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 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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    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 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 a VkStructureType value identifying 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 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;

    This structure describes the following features:

    • sType is a VkStructureType value identifying 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 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR structure is defined as:

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

    This structure describes the following features:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • vertexAttributeInstanceRateDivisor specifies whether vertex attribute fetching may be repeated in the case of instanced rendering.

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

    If the VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR 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. VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR

    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 a VkStructureType value identifying 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 a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • vulkanMemoryModel 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;

    This structure describes the following features:

    • sType is a VkStructureType value identifying 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 VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR structure is defined as:

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

    This structure describes the following feature:

    • sType is a VkStructureType value identifying 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 VkPhysicalDeviceScalarBlockLayoutFeatures structure is defined as:

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

    This structure describes the following feature:

    • sType is a VkStructureType value identifying 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 a VkStructureType value identifying 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:

    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 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 a VkStructureType value identifying 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 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 a VkStructureType value identifying 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 VkPhysicalDeviceCooperativeMatrixFeaturesKHR structure is defined as:

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

    This structure describes the following features:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • cooperativeMatrix indicates that the implementation supports the CooperativeMatrixKHR SPIR-V capability.

    • cooperativeMatrixRobustBufferAccess indicates that the implementation supports robust buffer access for SPIR-V OpCooperativeMatrixLoadKHR and OpCooperativeMatrixStoreKHR instructions.

    If the VkPhysicalDeviceCooperativeMatrixFeaturesKHR 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. VkPhysicalDeviceCooperativeMatrixFeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceCooperativeMatrixFeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR

    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 a VkStructureType value identifying 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;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying 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 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 a VkStructureType value identifying 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 VkPhysicalDeviceIndexTypeUint8FeaturesKHR structure is defined as:

    // Provided by VK_KHR_index_type_uint8
typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           indexTypeUint8;
} VkPhysicalDeviceIndexTypeUint8FeaturesKHR;

    This structure describes the following feature:

    If the VkPhysicalDeviceIndexTypeUint8FeaturesKHR 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. VkPhysicalDeviceIndexTypeUint8FeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceIndexTypeUint8FeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR

    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 a VkStructureType value identifying 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 a VkStructureType value identifying 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;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying 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 VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT structure is defined as:

    // Provided by VK_EXT_attachment_feedback_loop_dynamic_state
typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           attachmentFeedbackLoopDynamicState;
} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;

    This structure describes the following features:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • attachmentFeedbackLoopDynamicState specifies whether dynamic feedback loops are supported.

    If the VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT 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. VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_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;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying 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 VkPhysicalDeviceLineRasterizationFeaturesKHR structure is defined as:

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

    This structure describes the following features:

    If the VkPhysicalDeviceLineRasterizationFeaturesKHR 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. VkPhysicalDeviceLineRasterizationFeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceLineRasterizationFeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR

    The VkPhysicalDeviceSubgroupSizeControlFeatures structure is defined as:

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

    This structure describes the following features:

    • sType is a VkStructureType value identifying 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 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 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:

    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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 VkPhysicalDeviceVideoMaintenance1FeaturesKHR structure is defined as:

    // Provided by VK_KHR_video_maintenance1
typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           videoMaintenance1;
} VkPhysicalDeviceVideoMaintenance1FeaturesKHR;

    This structure describes the following features:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • videoMaintenance1 indicates that the implementation supports the following:

      • The new buffer creation flag VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR.

      • The new image creation flag VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR.

      • The new video session creation flag VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR.

    If the VkPhysicalDeviceVideoMaintenance1FeaturesKHR 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. VkPhysicalDeviceVideoMaintenance1FeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceVideoMaintenance1FeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR

    The VkPhysicalDeviceExtendedDynamicState3FeaturesEXT structure is defined as:

    // Provided by VK_EXT_extended_dynamic_state3
typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           extendedDynamicState3TessellationDomainOrigin;
    VkBool32           extendedDynamicState3DepthClampEnable;
    VkBool32           extendedDynamicState3PolygonMode;
    VkBool32           extendedDynamicState3RasterizationSamples;
    VkBool32           extendedDynamicState3SampleMask;
    VkBool32           extendedDynamicState3AlphaToCoverageEnable;
    VkBool32           extendedDynamicState3AlphaToOneEnable;
    VkBool32           extendedDynamicState3LogicOpEnable;
    VkBool32           extendedDynamicState3ColorBlendEnable;
    VkBool32           extendedDynamicState3ColorBlendEquation;
    VkBool32           extendedDynamicState3ColorWriteMask;
    VkBool32           extendedDynamicState3RasterizationStream;
    VkBool32           extendedDynamicState3ConservativeRasterizationMode;
    VkBool32           extendedDynamicState3ExtraPrimitiveOverestimationSize;
    VkBool32           extendedDynamicState3DepthClipEnable;
    VkBool32           extendedDynamicState3SampleLocationsEnable;
    VkBool32           extendedDynamicState3ColorBlendAdvanced;
    VkBool32           extendedDynamicState3ProvokingVertexMode;
    VkBool32           extendedDynamicState3LineRasterizationMode;
    VkBool32           extendedDynamicState3LineStippleEnable;
    VkBool32           extendedDynamicState3DepthClipNegativeOneToOne;
    VkBool32           extendedDynamicState3ViewportWScalingEnable;
    VkBool32           extendedDynamicState3ViewportSwizzle;
    VkBool32           extendedDynamicState3CoverageToColorEnable;
    VkBool32           extendedDynamicState3CoverageToColorLocation;
    VkBool32           extendedDynamicState3CoverageModulationMode;
    VkBool32           extendedDynamicState3CoverageModulationTableEnable;
    VkBool32           extendedDynamicState3CoverageModulationTable;
    VkBool32           extendedDynamicState3CoverageReductionMode;
    VkBool32           extendedDynamicState3RepresentativeFragmentTestEnable;
    VkBool32           extendedDynamicState3ShadingRateImageEnable;
} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;

    This structure describes the following features:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • extendedDynamicState3TessellationDomainOrigin indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT

    • extendedDynamicState3DepthClampEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT

    • extendedDynamicState3PolygonMode indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_POLYGON_MODE_EXT

    • extendedDynamicState3RasterizationSamples indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT

    • extendedDynamicState3SampleMask indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_SAMPLE_MASK_EXT

    • extendedDynamicState3AlphaToCoverageEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT

    • extendedDynamicState3AlphaToOneEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT

    • extendedDynamicState3LogicOpEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT

    • extendedDynamicState3ColorBlendEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT

    • extendedDynamicState3ColorBlendEquation indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT

    • extendedDynamicState3ColorWriteMask indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT

    • extendedDynamicState3RasterizationStream indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT

    • extendedDynamicState3ConservativeRasterizationMode indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT

    • extendedDynamicState3ExtraPrimitiveOverestimationSize indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT

    • extendedDynamicState3DepthClipEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT

    • extendedDynamicState3SampleLocationsEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT

    • extendedDynamicState3ColorBlendAdvanced indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT

    • extendedDynamicState3ProvokingVertexMode indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT

    • extendedDynamicState3LineRasterizationMode indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT

    • extendedDynamicState3LineStippleEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT

    • extendedDynamicState3DepthClipNegativeOneToOne indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT

    • extendedDynamicState3ViewportWScalingEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV

    • extendedDynamicState3ViewportSwizzle indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV

    • extendedDynamicState3CoverageToColorEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV

    • extendedDynamicState3CoverageToColorLocation indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV

    • extendedDynamicState3CoverageModulationMode indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV

    • extendedDynamicState3CoverageModulationTableEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV

    • extendedDynamicState3CoverageModulationTable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV

    • extendedDynamicState3CoverageReductionMode indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV

    • extendedDynamicState3RepresentativeFragmentTestEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV

    • extendedDynamicState3ShadingRateImageEnable indicates that the implementation supports the following dynamic state:

      • VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV

    If the VkPhysicalDeviceExtendedDynamicState3FeaturesEXT 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. VkPhysicalDeviceExtendedDynamicState3FeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceExtendedDynamicState3FeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT

    The VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR structure is defined as:

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

    This structure describes the following feature:

    • sType is a VkStructureType value identifying 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;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying 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 a VkStructureType value identifying 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;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying 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 a VkStructureType value identifying 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

    nullDescriptor support requires the VK_EXT_robustness2 extension.

    The VkPhysicalDeviceImageRobustnessFeatures structure is defined as:

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

    This structure describes the following feature:

    • sType is a VkStructureType value identifying 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 a VkStructureType value identifying 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 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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 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:

    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 VkPhysicalDeviceOpacityMicromapFeaturesEXT structure is defined as:

    // Provided by VK_EXT_opacity_micromap
typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           micromap;
    VkBool32           micromapCaptureReplay;
    VkBool32           micromapHostCommands;
} VkPhysicalDeviceOpacityMicromapFeaturesEXT;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • micromap indicates whether the implementation supports the micromap array feature.

    • micromapCaptureReplay indicates whether the implementation supports capture and replay of addresses for micromap arrays.

    • micromapHostCommands indicates whether the implementation supports host side micromap array commands.

    If the VkPhysicalDeviceOpacityMicromapFeaturesEXT 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. VkPhysicalDeviceOpacityMicromapFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceOpacityMicromapFeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT

    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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 VkPhysicalDeviceHostImageCopyFeaturesEXT structure is defined as:

    // Provided by VK_EXT_host_image_copy
typedef struct VkPhysicalDeviceHostImageCopyFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           hostImageCopy;
} VkPhysicalDeviceHostImageCopyFeaturesEXT;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • hostImageCopy indicates that the implementation supports copying from host memory to images using the vkCopyMemoryToImageEXT command, copying from images to host memory using the vkCopyImageToMemoryEXT command, and copying between images using the vkCopyImageToImageEXT command.

    If the VkPhysicalDeviceHostImageCopyFeaturesEXT 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. VkPhysicalDeviceHostImageCopyFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceHostImageCopyFeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT

    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 a VkStructureType value identifying 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 a VkStructureType value identifying 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 VkPhysicalDeviceMaintenance5FeaturesKHR structure is defined as:

    // Provided by VK_KHR_maintenance5
typedef struct VkPhysicalDeviceMaintenance5FeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           maintenance5;
} VkPhysicalDeviceMaintenance5FeaturesKHR;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • maintenance5 indicates that the implementation supports the following:

      • The ability to expose support for the optional format VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR.

      • The ability to expose support for the optional format VK_FORMAT_A8_UNORM_KHR.

      • A property to indicate that multisample coverage operations are performed after sample counting in EarlyFragmentTests mode.

      • Creating a VkBufferView with a subset of the associated VkBuffer usage using VkBufferUsageFlags2CreateInfoKHR.

      • A new function vkCmdBindIndexBuffer2KHR, allowing a range of memory to be bound as an index buffer.

      • vkGetDeviceProcAddr will return NULL for function pointers of core functions for versions higher than the version requested by the application.

      • vkCmdBindVertexBuffers2 supports using VK_WHOLE_SIZE in the pSizes parameter.

      • If PointSize is not written, a default value of 1.0 is used for the size of points.

      • VkShaderModuleCreateInfo can be added as a chained structure to pipeline creation via VkPipelineShaderStageCreateInfo, rather than having to create a shader module.

      • A function vkGetRenderingAreaGranularityKHR to query the optimal render area for a dynamic rendering instance.

      • A property to indicate that depth/stencil texturing operations with VK_COMPONENT_SWIZZLE_ONE have defined behavior.

      • vkGetDeviceImageSubresourceLayoutKHR allows an application to perform a vkGetImageSubresourceLayout query without having to create an image.

      • VK_REMAINING_ARRAY_LAYERS as the layerCount member of VkImageSubresourceLayers.

      • A property to indicate whether PointSize controls the final rasterization of polygons if polygon mode is VK_POLYGON_MODE_POINT.

      • Two properties to indicate the non-strict line rasterization algorithm used.

      • Two new flags words VkPipelineCreateFlagBits2KHR and VkBufferUsageFlagBits2KHR.

      • Physical-device-level functions can now be called with any value in the valid range for a type beyond the defined enumerants, such that applications can avoid checking individual features, extensions, or versions before querying supported properties of a particular enumerant.

      • Copies between images of any type are allowed, with 1D images treated as 2D images with a height of 1.

    If the VkPhysicalDeviceMaintenance5FeaturesKHR 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. VkPhysicalDeviceMaintenance5FeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceMaintenance5FeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR

    The VkPhysicalDeviceMaintenance6FeaturesKHR structure is defined as:

    // Provided by VK_KHR_maintenance6
typedef struct VkPhysicalDeviceMaintenance6FeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           maintenance6;
} VkPhysicalDeviceMaintenance6FeaturesKHR;

    This structure describes the following feature:

    If the VkPhysicalDeviceMaintenance6FeaturesKHR 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. VkPhysicalDeviceMaintenance6FeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceMaintenance6FeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR

    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 a VkStructureType value identifying 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 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 a VkStructureType value identifying 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 VkPhysicalDeviceNestedCommandBufferFeaturesEXT structure is defined as:

    // Provided by VK_EXT_nested_command_buffer
typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           nestedCommandBuffer;
    VkBool32           nestedCommandBufferRendering;
    VkBool32           nestedCommandBufferSimultaneousUse;
} VkPhysicalDeviceNestedCommandBufferFeaturesEXT;

    This structure describes the following features:

    • nestedCommandBuffer indicates the implementation supports nested command buffers, which allows Secondary Command Buffers to execute other Secondary Command Buffers.

    • nestedCommandBufferRendering indicates that it is valid to call vkCmdExecuteCommands inside a Secondary Command Buffer recorded with VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT.

    • nestedCommandBufferSimultaneousUse indicates that the implementation supports nested command buffers with command buffers that are recorded with VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT.

    If the VkPhysicalDeviceNestedCommandBufferFeaturesEXT 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. VkPhysicalDeviceNestedCommandBufferFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceNestedCommandBufferFeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT

    The VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR structure is defined as:

    // Provided by VK_KHR_ray_tracing_position_fetch
typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           rayTracingPositionFetch;
} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • rayTracingPositionFetch indicates that the implementation supports fetching the object space vertex positions of a hit triangle.

    If the VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR 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. VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR

    The VkPhysicalDeviceShaderFloatControls2FeaturesKHR structure is defined as:

    // Provided by VK_KHR_shader_float_controls2
typedef struct VkPhysicalDeviceShaderFloatControls2FeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderFloatControls2;
} VkPhysicalDeviceShaderFloatControls2FeaturesKHR;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • shaderFloatControls2 specifies whether shader modules can declare the FloatControls2 capability.

    If the VkPhysicalDeviceShaderFloatControls2FeaturesKHR 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. VkPhysicalDeviceShaderFloatControls2FeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceShaderFloatControls2FeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR

    The VkPhysicalDeviceShaderTileImageFeaturesEXT structure is defined as:

    // Provided by VK_EXT_shader_tile_image
typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderTileImageColorReadAccess;
    VkBool32           shaderTileImageDepthReadAccess;
    VkBool32           shaderTileImageStencilReadAccess;
} VkPhysicalDeviceShaderTileImageFeaturesEXT;

    The members of the VkPhysicalDeviceShaderTileImageFeaturesEXT structure describe the following features:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • shaderTileImageColorReadAccess indicates that the implementation supports the TileImageColorReadAccessEXT SPIR-V capability.

    • shaderTileImageDepthReadAccess indicates that the implementation supports the TileImageDepthReadAccessEXT SPIR-V capability.

    • shaderTileImageStencilReadAccess indicates that the implementation supports the TileImageStencilReadAccessEXT SPIR-V capability.

    If the VkPhysicalDeviceShaderTileImageFeaturesEXT 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. VkPhysicalDeviceShaderTileImageFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceShaderTileImageFeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT

    The VkPhysicalDeviceDepthBiasControlFeaturesEXT structure is defined as:

    // Provided by VK_EXT_depth_bias_control
typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           depthBiasControl;
    VkBool32           leastRepresentableValueForceUnormRepresentation;
    VkBool32           floatRepresentation;
    VkBool32           depthBiasExact;
} VkPhysicalDeviceDepthBiasControlFeaturesEXT;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • depthBiasControl indicates whether the implementation supports the vkCmdSetDepthBias2EXT command and the VkDepthBiasRepresentationInfoEXT structure.

    • leastRepresentableValueForceUnormRepresentation indicates whether the implementation supports using the VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT depth bias representation.

    • floatRepresentation indicates whether the implementation supports using the VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT depth bias representation.

    • depthBiasExact indicates whether the implementation supports forcing depth bias to not be scaled to ensure a minimum resolvable difference using VkDepthBiasRepresentationInfoEXT::depthBiasExact.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceDepthBiasControlFeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT

    The VkPhysicalDeviceShaderObjectFeaturesEXT structure is defined as:

    // Provided by VK_EXT_shader_object
typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderObject;
} VkPhysicalDeviceShaderObjectFeaturesEXT;

    This structure describes the following feature:

    • shaderObject indicates whether the implementation supports shader objects.

    If the VkPhysicalDeviceShaderObjectFeaturesEXT 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. VkPhysicalDeviceShaderObjectFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceShaderObjectFeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT

    The VkPhysicalDeviceFrameBoundaryFeaturesEXT structure is defined as:

    // Provided by VK_EXT_frame_boundary
typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           frameBoundary;
} VkPhysicalDeviceFrameBoundaryFeaturesEXT;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • frameBoundary indicates whether the implementation supports frame boundary information.

    If the VkPhysicalDeviceFrameBoundaryFeaturesEXT 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. VkPhysicalDeviceFrameBoundaryFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceFrameBoundaryFeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT

    The VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT structure is defined as:

    // Provided by VK_EXT_dynamic_rendering_unused_attachments
typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           dynamicRenderingUnusedAttachments;
} VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;

    This structure describes the following feature:

    If the VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT 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. VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT

    The VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR structure is defined as:

    // Provided by VK_KHR_shader_maximal_reconvergence
typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderMaximalReconvergence;
} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • shaderMaximalReconvergence specifies whether the implementation supports the shader execution mode MaximallyReconvergesKHR

    If the VkPhysicalDevicePrivateDataFeaturesEXT 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. VkPhysicalDevicePrivateDataFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR

    The VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR structure is defined as:

    // Provided by VK_KHR_shader_subgroup_rotate
typedef struct VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderSubgroupRotate;
    VkBool32           shaderSubgroupRotateClustered;
} VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR;

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • shaderSubgroupRotate specifies whether shader modules can declare the GroupNonUniformRotateKHR capability.

    • shaderSubgroupRotateClustered specifies whether shader modules can use the ClusterSize operand to OpGroupNonUniformRotateKHR.

    If the VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR 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. VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR

    The VkPhysicalDeviceShaderExpectAssumeFeaturesKHR structure is defined as:

    // Provided by VK_KHR_shader_expect_assume
typedef struct VkPhysicalDeviceShaderExpectAssumeFeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderExpectAssume;
} VkPhysicalDeviceShaderExpectAssumeFeaturesKHR;

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • shaderExpectAssume specifies whether shader modules can declare the ExpectAssumeKHR capability.

    If the VkPhysicalDeviceShaderExpectAssumeFeaturesKHR 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. VkPhysicalDeviceShaderExpectAssumeFeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceShaderExpectAssumeFeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR

    The VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR structure is defined as:

    // Provided by VK_KHR_dynamic_rendering_local_read
typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           dynamicRenderingLocalRead;
} VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;

    This structure describes the following feature:

    • sType is a VkStructureType value identifying this structure.

    • pNext is NULL or a pointer to a structure extending this structure.

    • dynamicRenderingLocalRead specifies that the implementation supports local reads inside dynamic render pass instances using the vkCmdBeginRendering command.

    If the VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR 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. VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR

    The VkPhysicalDeviceShaderQuadControlFeaturesKHR structure is defined as:

    // Provided by VK_KHR_shader_quad_control
typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderQuadControl;
} VkPhysicalDeviceShaderQuadControlFeaturesKHR;

    This structure describes the following features:

    • shaderQuadControl indicates whether the implementation supports shaders with the QuadControlKHR capability.

    If the VkPhysicalDeviceShaderQuadControlFeaturesKHR 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. VkPhysicalDeviceShaderQuadControlFeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to selectively enable these features.

    Valid Usage (Implicit)

    • VUID-VkPhysicalDeviceShaderQuadControlFeaturesKHR-sType-sType
      sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR

    39.1. Feature Requirements

    All Vulkan graphics implementations must support the following features:

    All other features defined in the Specification are optional.

    39.2. Profile Features

    39.2.1. Roadmap 2022

    Implementations that claim support for the Roadmap 2022 profile must support the following features:

    39.2.2. Roadmap 2024

    Implementations that claim support for the Roadmap 2024 profile must support the following features: