## 38. 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 features structures for features promoted from extensions. At the same time, the extension’s original features 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 47. Extension Feature Aliases
Extension Feature(s)

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)

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)

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;

The VkPhysicalDeviceFeatures2 structure is defined as:

• sType is the type of this structure.

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

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

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

Valid Usage (Implicit)
• 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    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    sparseBinding;
VkBool32    sparseResidencyBuffer;
VkBool32    sparseResidencyImage2D;
VkBool32    sparseResidencyImage3D;
VkBool32    sparseResidency2Samples;
VkBool32    sparseResidency4Samples;
VkBool32    sparseResidency8Samples;
VkBool32    sparseResidency16Samples;
VkBool32    sparseResidencyAliased;
VkBool32    variableMultisampleRate;
VkBool32    inheritedQueries;
} VkPhysicalDeviceFeatures;

The members of the VkPhysicalDeviceFeatures structure describe the following features:

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

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

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

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

 Note If a SPIR-V OpLoad instruction loads a structure and the tail end of the structure is out of bounds, then all members of the structure are considered out of bounds even if the members at the end are not statically used.
• If robustBufferAccess2 is not enabled and any buffer access is determined to be out of bounds, then any other access of the same type (load, store, or atomic) to the same buffer that accesses an address less than 16 bytes away from the out of bounds address may also be considered out of bounds.

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

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

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

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

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

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

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

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

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

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

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

• 0.0 or 1.0, for floating-point components

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

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

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

• vertexBufferRangeSize, if bindingStride == 0; or

• (vertexBufferRangeSize - (vertexBufferRangeSize % bindingStride))

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

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

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

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

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

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

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

• If robustBufferAccess is not enabled, applications must not perform out of bounds accesses.

• 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 draw 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 color fragment output from the fragment shader with the maximum representable alpha value for fixed-point colors or 1.0 for floating-point colors. If this feature is not enabled, then the alphaToOneEnable member of the VkPipelineMultisampleStateCreateInfo structure must be set to VK_FALSE. Otherwise setting alphaToOneEnable to VK_TRUE will enable alpha-to-one behavior.

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

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

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

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

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

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

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

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

• VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK

• VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK

• VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK

• VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK

• VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK

• VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK

• VK_FORMAT_EAC_R11_UNORM_BLOCK

• VK_FORMAT_EAC_R11_SNORM_BLOCK

• VK_FORMAT_EAC_R11G11_UNORM_BLOCK

• VK_FORMAT_EAC_R11G11_SNORM_BLOCK

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

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

• VK_FORMAT_ASTC_4x4_UNORM_BLOCK

• VK_FORMAT_ASTC_4x4_SRGB_BLOCK

• VK_FORMAT_ASTC_5x4_UNORM_BLOCK

• VK_FORMAT_ASTC_5x4_SRGB_BLOCK

• VK_FORMAT_ASTC_5x5_UNORM_BLOCK

• VK_FORMAT_ASTC_5x5_SRGB_BLOCK

• VK_FORMAT_ASTC_6x5_UNORM_BLOCK

• VK_FORMAT_ASTC_6x5_SRGB_BLOCK

• VK_FORMAT_ASTC_6x6_UNORM_BLOCK

• VK_FORMAT_ASTC_6x6_SRGB_BLOCK

• VK_FORMAT_ASTC_8x5_UNORM_BLOCK

• VK_FORMAT_ASTC_8x5_SRGB_BLOCK

• VK_FORMAT_ASTC_8x6_UNORM_BLOCK

• VK_FORMAT_ASTC_8x6_SRGB_BLOCK

• VK_FORMAT_ASTC_8x8_UNORM_BLOCK

• VK_FORMAT_ASTC_8x8_SRGB_BLOCK

• VK_FORMAT_ASTC_10x5_UNORM_BLOCK

• VK_FORMAT_ASTC_10x5_SRGB_BLOCK

• VK_FORMAT_ASTC_10x6_UNORM_BLOCK

• VK_FORMAT_ASTC_10x6_SRGB_BLOCK

• VK_FORMAT_ASTC_10x8_UNORM_BLOCK

• VK_FORMAT_ASTC_10x8_SRGB_BLOCK

• VK_FORMAT_ASTC_10x10_UNORM_BLOCK

• VK_FORMAT_ASTC_10x10_SRGB_BLOCK

• VK_FORMAT_ASTC_12x10_UNORM_BLOCK

• VK_FORMAT_ASTC_12x10_SRGB_BLOCK

• VK_FORMAT_ASTC_12x12_UNORM_BLOCK

• VK_FORMAT_ASTC_12x12_SRGB_BLOCK

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

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

• VK_FORMAT_BC1_RGB_UNORM_BLOCK

• VK_FORMAT_BC1_RGB_SRGB_BLOCK

• VK_FORMAT_BC1_RGBA_UNORM_BLOCK

• VK_FORMAT_BC1_RGBA_SRGB_BLOCK

• VK_FORMAT_BC2_UNORM_BLOCK

• VK_FORMAT_BC2_SRGB_BLOCK

• VK_FORMAT_BC3_UNORM_BLOCK

• VK_FORMAT_BC3_SRGB_BLOCK

• VK_FORMAT_BC4_UNORM_BLOCK

• VK_FORMAT_BC4_SNORM_BLOCK

• VK_FORMAT_BC5_UNORM_BLOCK

• VK_FORMAT_BC5_SNORM_BLOCK

• VK_FORMAT_BC6H_UFLOAT_BLOCK

• VK_FORMAT_BC6H_SFLOAT_BLOCK

• VK_FORMAT_BC7_UNORM_BLOCK

• VK_FORMAT_BC7_SRGB_BLOCK

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

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

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

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

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

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

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

• VK_FORMAT_R16G16_SFLOAT

• VK_FORMAT_B10G11R11_UFLOAT_PACK32

• VK_FORMAT_R16_SFLOAT

• VK_FORMAT_R16G16B16A16_UNORM

• VK_FORMAT_A2B10G10R10_UNORM_PACK32

• VK_FORMAT_R16G16_UNORM

• VK_FORMAT_R8G8_UNORM

• VK_FORMAT_R16_UNORM

• VK_FORMAT_R8_UNORM

• VK_FORMAT_R16G16B16A16_SNORM

• VK_FORMAT_R16G16_SNORM

• VK_FORMAT_R8G8_SNORM

• VK_FORMAT_R16_SNORM

• VK_FORMAT_R8_SNORM

• VK_FORMAT_R16G16_SINT

• VK_FORMAT_R8G8_SINT

• VK_FORMAT_R16_SINT

• VK_FORMAT_R8_SINT

• VK_FORMAT_A2B10G10R10_UINT_PACK32

• VK_FORMAT_R16G16_UINT

• VK_FORMAT_R8G8_UINT

• VK_FORMAT_R16_UINT

• VK_FORMAT_R8_UINT

 Note shaderStorageImageExtendedFormats feature only adds a guarantee of format support, which is specified for the whole physical device. Therefore enabling or disabling the feature via vkCreateDevice has no practical effect. To query for additional properties, or if the feature is not supported, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats, as usual rules allow. VK_FORMAT_R32G32_UINT, VK_FORMAT_R32G32_SINT, and VK_FORMAT_R32G32_SFLOAT from StorageImageExtendedFormats SPIR-V capability, are already covered by core Vulkan mandatory format support.
• shaderStorageImageMultisample specifies whether multisampled storage images are supported. If this feature is not enabled, images that are created with a usage that includes VK_IMAGE_USAGE_STORAGE_BIT must be created with samples equal to VK_SAMPLE_COUNT_1_BIT. This also specifies whether shader modules can declare the StorageImageMultisample and ImageMSArray capabilities.

• shaderStorageImageReadWithoutFormat specifies whether storage images require a format qualifier to be specified when reading from storage images. If this feature is not enabled, the OpImageRead instruction must not have an OpTypeImage of Unknown. This also specifies whether shader modules can declare the StorageImageReadWithoutFormat capability.

• shaderStorageImageWriteWithoutFormat specifies whether storage images require a format qualifier to be specified when writing to storage images. If this feature is not enabled, the OpImageWrite instruction must not have an OpTypeImage of Unknown. This also specifies whether shader modules can declare the StorageImageWriteWithoutFormat capability.

• 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, 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 VkPhysicalDeviceVariablePointersFeatures structure is defined as:

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

or the equivalent

// Provided by VK_KHR_variable_pointers
typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;

The members of the VkPhysicalDeviceVariablePointersFeatures structure describe the following features:

• 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 VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceVariablePointersFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage
• If variablePointers is enabled then variablePointersStorageBuffer must also be enabled

Valid Usage (Implicit)
• 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;
} VkPhysicalDeviceMultiviewFeatures;

or the equivalent

// Provided by VK_KHR_multiview
typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;

The members of the VkPhysicalDeviceMultiviewFeatures structure describe the following features:

• 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 VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceMultiviewFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage
• If multiviewGeometryShader is enabled then multiview must also be enabled

• If multiviewTessellationShader is enabled then multiview must also be enabled

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES

To query support for atomic operations on floating-point numbers, call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDeviceShaderAtomicFloatFeaturesEXT structure included in the pNext chain of its pFeatures parameter.

The VkPhysicalDeviceShaderAtomicFloatFeaturesEXT structure is defined as:

// Provided by VK_EXT_shader_atomic_float
VkStructureType    sType;
void*              pNext;
VkBool32           sparseImageFloat32Atomics;
} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
• sType is the type of this structure.

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

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

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

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

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

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

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

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

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

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

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

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

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

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT

To query 64-bit atomic support for signed and unsigned integers call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDeviceShaderAtomicInt64Features structure included in the pNext chain of its pFeatures parameter.

The VkPhysicalDeviceShaderAtomicInt64Features structure is defined as:

typedef struct VkPhysicalDeviceShaderAtomicInt64Features {
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceShaderAtomicInt64Features;

or the equivalent

// Provided by VK_KHR_shader_atomic_int64
typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;
• sType is the type of this structure.

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

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

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

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES

To query 8-bit storage features additionally supported call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDevice8BitStorageFeatures structure included in the pNext chain of its pFeatures parameter. The VkPhysicalDevice8BitStorageFeatures structure can also be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which additional features are enabled in the device.

The VkPhysicalDevice8BitStorageFeatures structure is defined as:

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;
• sType is the type of this structure.

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

• storageBuffer8BitAccess indicates whether objects in the StorageBuffer 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 and in the StorageBuffer or PhysicalStorageBuffer storage class with the same 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.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES

To query 16-bit storage features additionally supported call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDevice16BitStorageFeatures structure included in the pNext chain of its pFeatures parameter. The VkPhysicalDevice16BitStorageFeatures structure can also be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which additional features are enabled in the device.

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;
• sType is the type of this structure.

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

• storageBuffer16BitAccess specifies whether objects in the StorageBuffer 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 and in the StorageBuffer or PhysicalStorageBuffer storage class with the same 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.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES

To query features additionally supported by the VK_KHR_shader_float16_int8 extension, call vkGetPhysicalDeviceFeatures2KHR with a VkPhysicalDeviceShaderFloat16Int8Features structure included in the pNext chain. The VkPhysicalDeviceShaderFloat16Int8Features structure can also be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which additional features are enabled in the device.

The VkPhysicalDeviceShaderFloat16Int8Features structure is defined as:

typedef struct VkPhysicalDeviceShaderFloat16Int8Features {
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceShaderFloat16Int8Features;

or the equivalent

// Provided by VK_KHR_shader_float16_int8
typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
• sType is the type of this structure.

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

• shaderFloat16 indicates whether 16-bit floats (halfs) are supported in shader code. This also indicates whether shader modules can declare the Float16 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the Float16 SPIR-V capability: Declaring and using 16-bit floats in the Private, Workgroup, 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, 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.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES

To query shader clock support, call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDeviceShaderClockFeaturesKHR structure included in the pNext chain of its pFeatures parameter.

The VkPhysicalDeviceShaderClockFeaturesKHR structure is defined as:

// Provided by VK_KHR_shader_clock
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceShaderClockFeaturesKHR;
• sType is the type of this structure.

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

• shaderSubgroupClock indicates whether shaders can perform Subgroup scoped clock reads.

• shaderDeviceClock indicates whether shaders can perform Device scoped clock reads.

If the VkPhysicalDeviceShaderClockFeaturesKHR structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceShaderClockFeaturesKHR can also be included in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)
• 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;

The members of the VkPhysicalDeviceSamplerYcbcrConversionFeatures structure describe the following feature:

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

Valid Usage (Implicit)
• 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;
• protectedMemory specifies whether protected memory is supported.

If the VkPhysicalDeviceProtectedMemoryFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with a value indicating whether the feature is supported.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES

The VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT structure is defined as:

// Provided by VK_EXT_blend_operation_advanced
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;

The members of the VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT structure describe the following features:

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

If the VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT

The VkPhysicalDeviceConditionalRenderingFeaturesEXT structure is defined as:

// Provided by VK_EXT_conditional_rendering
typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
VkStructureType    sType;
void*              pNext;
VkBool32           conditionalRendering;
VkBool32           inheritedConditionalRendering;
} VkPhysicalDeviceConditionalRenderingFeaturesEXT;
• sType is the type of this structure.

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

• conditionalRendering specifies whether conditional rendering is supported.

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

If the VkPhysicalDeviceConditionalRenderingFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating the implementation-dependent behavior. VkPhysicalDeviceConditionalRenderingFeaturesEXT can also be included in pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT

The VkPhysicalDeviceShaderDrawParametersFeatures structure is defined as:

// Provided by VK_VERSION_1_1
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceShaderDrawParametersFeatures;
• shaderDrawParameters specifies whether shader draw parameters are supported.

If the VkPhysicalDeviceShaderDrawParametersFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with a value indicating whether the feature is supported.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES

The VkPhysicalDeviceMeshShaderFeaturesNV structure is defined as:

// Provided by VK_NV_mesh_shader
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceMeshShaderFeaturesNV;
• taskShader indicates whether the task shader stage is supported.

• meshShader indicates whether the mesh shader stage is supported.

If the VkPhysicalDeviceMeshShaderFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with a value indicating whether the feature is supported. VkPhysicalDeviceMeshShaderFeaturesNV can also be included in pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV

The VkPhysicalDeviceDescriptorIndexingFeatures structure is defined as:

typedef struct VkPhysicalDeviceDescriptorIndexingFeatures {
VkStructureType    sType;
void*              pNext;
VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
VkBool32           descriptorBindingSampledImageUpdateAfterBind;
VkBool32           descriptorBindingStorageImageUpdateAfterBind;
VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
VkBool32           descriptorBindingUpdateUnusedWhilePending;
VkBool32           descriptorBindingPartiallyBound;
VkBool32           descriptorBindingVariableDescriptorCount;
VkBool32           runtimeDescriptorArray;
} VkPhysicalDeviceDescriptorIndexingFeatures;

or the equivalent

// Provided by VK_EXT_descriptor_indexing
typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT;

The members of the VkPhysicalDeviceDescriptorIndexingFeatures structure describe the following features:

• 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 VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceDescriptorIndexingFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES

The VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT structure is defined as:

// Provided by VK_EXT_vertex_attribute_divisor
typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
VkStructureType    sType;
void*              pNext;
VkBool32           vertexAttributeInstanceRateDivisor;
VkBool32           vertexAttributeInstanceRateZeroDivisor;
} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
• sType is the type of this structure.

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

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

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

If the VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating the implementation-dependent behavior. VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT can also be included in pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT

The VkPhysicalDeviceASTCDecodeFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceASTCDecodeFeaturesEXT structure describe the following features:

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

If the VkPhysicalDeviceASTCDecodeFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceASTCDecodeFeaturesEXT can also be included in the pNext chain of vkCreateDevice to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT

The VkPhysicalDeviceTransformFeedbackFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceTransformFeedbackFeaturesEXT structure describe the following features:

• 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 VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceTransformFeedbackFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT

To query memory model features additionally supported call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDeviceVulkanMemoryModelFeatures structure included in the pNext chain of its pFeatures parameter. The VkPhysicalDeviceVulkanMemoryModelFeatures structure can also be included in the pNext chain of a VkDeviceCreateInfo structure, in which case it controls which additional features are enabled in the device.

The VkPhysicalDeviceVulkanMemoryModelFeatures structure is defined as:

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;
• sType is the type of this structure.

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

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

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

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

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES

The VkPhysicalDeviceInlineUniformBlockFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceInlineUniformBlockFeaturesEXT structure describe the following features:

• inlineUniformBlock indicates whether the implementation supports inline uniform block descriptors. If this feature is not enabled, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT 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_EXT.

If the VkPhysicalDeviceInlineUniformBlockFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceInlineUniformBlockFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT

The VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV structure is defined as:

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

The members of the VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV structure describe the following features:

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

If the VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV

The VkPhysicalDeviceExclusiveScissorFeaturesNV structure is defined as:

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

The members of the VkPhysicalDeviceExclusiveScissorFeaturesNV structure describe the following features:

• exclusiveScissor indicates that the implementation supports the exclusive scissor test.

If the VkPhysicalDeviceExclusiveScissorFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceExclusiveScissorFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV

The VkPhysicalDeviceCornerSampledImageFeaturesNV structure is defined as:

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

The members of the VkPhysicalDeviceCornerSampledImageFeaturesNV structure describe the following features:

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

If the VkPhysicalDeviceCornerSampledImageFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceCornerSampledImageFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV

The VkPhysicalDeviceComputeShaderDerivativesFeaturesNV structure is defined as:

// Provided by VK_NV_compute_shader_derivatives
VkStructureType    sType;
void*              pNext;
VkBool32           computeDerivativeGroupLinear;
} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;

The members of the VkPhysicalDeviceComputeShaderDerivativesFeaturesNV structure describe the following features:

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

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

If the VkPhysicalDeviceComputeShaderDerivativesFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceComputeShaderDerivativesFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV

The VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV structure is defined as:

// Provided by VK_NV_fragment_shader_barycentric
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;

The members of the VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV structure describe the following features:

• fragmentShaderBarycentric indicates that the implementation supports the BaryCoordNV and BaryCoordNoPerspNV SPIR-V fragment shader built-ins and supports the PerVertexNV SPIR-V decoration on fragment shader input variables.

If the VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV

The VkPhysicalDeviceShaderImageFootprintFeaturesNV structure is defined as:

// Provided by VK_NV_shader_image_footprint
VkStructureType    sType;
void*              pNext;
VkBool32           imageFootprint;
} VkPhysicalDeviceShaderImageFootprintFeaturesNV;
• imageFootprint specifies whether the implementation supports the ImageFootprintNV SPIR-V capability.

If the VkPhysicalDeviceShaderImageFootprintFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceShaderImageFootprintFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV

The VkPhysicalDeviceShadingRateImageFeaturesNV structure is defined as:

// Provided by VK_NV_shading_rate_image
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceShadingRateImageFeaturesNV;

The members of the VkPhysicalDeviceShadingRateImageFeaturesNV structure describe the following features:

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

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

If the VkPhysicalDeviceShadingRateImageFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceShadingRateImageFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV

The VkPhysicalDeviceFragmentDensityMapFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceFragmentDensityMapFeaturesEXT structure describe the following features:

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

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

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

If the VkPhysicalDeviceFragmentDensityMapFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceFragmentDensityMapFeaturesEXT can also be included in pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT

The VkPhysicalDeviceFragmentDensityMap2FeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceFragmentDensityMap2FeaturesEXT structure describe the following features:

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

If the VkPhysicalDeviceFragmentDensityMap2FeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceFragmentDensityMap2FeaturesEXT can also be included in pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT

The VkPhysicalDeviceScalarBlockLayoutFeatures structure is defined as:

typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures {
VkStructureType    sType;
void*              pNext;
VkBool32           scalarBlockLayout;
} VkPhysicalDeviceScalarBlockLayoutFeatures;

or the equivalent

// Provided by VK_EXT_scalar_block_layout
typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;

The members of the VkPhysicalDeviceScalarBlockLayoutFeatures structure describe the following features:

• 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 VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceScalarBlockLayoutFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable this feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES

The VkPhysicalDeviceUniformBufferStandardLayoutFeatures structure is defined as:

typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
VkStructureType    sType;
void*              pNext;
VkBool32           uniformBufferStandardLayout;
} VkPhysicalDeviceUniformBufferStandardLayoutFeatures;

or the equivalent

// Provided by VK_KHR_uniform_buffer_standard_layout
typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;

The members of the VkPhysicalDeviceUniformBufferStandardLayoutFeatures structure describe the following features:

• 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 VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceUniformBufferStandardLayoutFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable this feature.

Valid Usage (Implicit)
• 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;

The members of the VkPhysicalDeviceDepthClipEnableFeaturesEXT structure describe the following features:

If the VkPhysicalDeviceDepthClipEnableFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceDepthClipEnableFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable this feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT

The VkPhysicalDeviceMemoryPriorityFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceMemoryPriorityFeaturesEXT structure describe the following features:

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

If the VkPhysicalDeviceMemoryPriorityFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceMemoryPriorityFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT

The VkPhysicalDeviceBufferDeviceAddressFeatures structure is defined as:

typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures {
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceBufferDeviceAddressFeatures;

or the equivalent

// Provided by VK_KHR_buffer_device_address
typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;

The members of the VkPhysicalDeviceBufferDeviceAddressFeatures structure describe the following features:

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

If the VkPhysicalDeviceBufferDeviceAddressFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceBufferDeviceAddressFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES

The VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure is defined as:

// Provided by VK_EXT_buffer_device_address
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;

The members of the VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure describe the following features:

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

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

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

If the VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceBufferDeviceAddressFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

 Note The VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure has the same members as the VkPhysicalDeviceBufferDeviceAddressFeatures structure, but the functionality indicated by the members is expressed differently. The features indicated by the VkPhysicalDeviceBufferDeviceAddressFeatures structure requires additional flags to be passed at memory allocation time, and the capture and replay mechanism is built around opaque capture addresses for buffer and memory objects.
Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT

The VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV structure is defined as:

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

The members of the VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV structure describe the following features:

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

If the VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV

The VkPhysicalDeviceImagelessFramebufferFeatures structure is defined as:

typedef struct VkPhysicalDeviceImagelessFramebufferFeatures {
VkStructureType    sType;
void*              pNext;
VkBool32           imagelessFramebuffer;
} VkPhysicalDeviceImagelessFramebufferFeatures;

or the equivalent

// Provided by VK_KHR_imageless_framebuffer
typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR;

The members of the VkPhysicalDeviceImagelessFramebufferFeatures structure describe the following features:

• 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 VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceImagelessFramebufferFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable this feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES

The VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT structure is defined as:

// Provided by VK_EXT_fragment_shader_interlock
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;

The members of the VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT structure describe the following features:

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

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

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

If the VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT

The VkPhysicalDeviceCooperativeMatrixFeaturesNV structure is defined as:

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

The members of the VkPhysicalDeviceCooperativeMatrixFeaturesNV structure describe the following features:

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

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

If the VkPhysicalDeviceCooperativeMatrixFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceCooperativeMatrixFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV

The VkPhysicalDeviceYcbcrImageArraysFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceYcbcrImageArraysFeaturesEXT structure describe the following features:

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

If the VkPhysicalDeviceYcbcrImageArraysFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceYcbcrImageArraysFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT

The VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures structure is defined as:

typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;

or the equivalent

// Provided by VK_KHR_shader_subgroup_extended_types
typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;

The members of the VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures structure describe the following features:

• sType is the type of this structure.

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

• shaderSubgroupExtendedTypes is a boolean that specifies 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 scopeif the implementation supports the types.

If the VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES

The VkPhysicalDeviceHostQueryResetFeatures structure is defined as:

typedef struct VkPhysicalDeviceHostQueryResetFeatures {
VkStructureType    sType;
void*              pNext;
VkBool32           hostQueryReset;
} VkPhysicalDeviceHostQueryResetFeatures;

or the equivalent

// Provided by VK_EXT_host_query_reset
typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT;

The members of the VkPhysicalDeviceHostQueryResetFeatures structure describe the following features:

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

If the VkPhysicalDeviceHostQueryResetFeatures structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceHostQueryResetFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES

The VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure is defined as:

// Provided by VK_INTEL_shader_integer_functions2
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;

The members of the VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure describe the following features:

• shaderIntegerFunctions2 indicates that the implementation supports the ShaderIntegerFunctions2INTEL SPIR-V capability.

If the VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL

The VkPhysicalDeviceCoverageReductionModeFeaturesNV structure is defined as:

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

The members of the VkPhysicalDeviceCoverageReductionModeFeaturesNV structure describe the following features:

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

If the VkPhysicalDeviceCoverageReductionModeFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceCoverageReductionModeFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV

The VkPhysicalDeviceTimelineSemaphoreFeatures structure is defined as:

typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures {
VkStructureType    sType;
void*              pNext;
VkBool32           timelineSemaphore;
} VkPhysicalDeviceTimelineSemaphoreFeatures;

or the equivalent

// Provided by VK_KHR_timeline_semaphore
typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;

The members of the VkPhysicalDeviceTimelineSemaphoreFeatures structure describe the following features:

• 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 VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceTimelineSemaphoreFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES

The VkPhysicalDeviceIndexTypeUint8FeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceIndexTypeUint8FeaturesEXT structure describe the following features:

• indexTypeUint8 indicates that VK_INDEX_TYPE_UINT8_EXT can be used with vkCmdBindIndexBuffer.

If the VkPhysicalDeviceIndexTypeUint8FeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceIndexTypeUint8FeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT

The VkPhysicalDeviceShaderSMBuiltinsFeaturesNV structure is defined as:

// Provided by VK_NV_shader_sm_builtins
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;

The members of the VkPhysicalDeviceShaderSMBuiltinsFeaturesNV structure describe the following features:

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

If the VkPhysicalDeviceShaderSMBuiltinsFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceShaderSMBuiltinsFeaturesNV can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV

The VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures structure is defined as:

typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
VkStructureType    sType;
void*              pNext;
VkBool32           separateDepthStencilLayouts;
} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;

or the equivalent

// Provided by VK_KHR_separate_depth_stencil_layouts
typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;

The members of the VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures structure describe the following features:

• 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 VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• 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;

The members of the VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR structure describe the following features:

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

If the VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR can also be included in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR

The VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT structure is defined as:

// Provided by VK_EXT_shader_demote_to_helper_invocation
VkStructureType    sType;
void*              pNext;
} VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;

The members of the VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT structure describe the following features:

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

If the VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT

The VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT structure describe the following features:

If the VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT

The VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT structure is defined as:

// Provided by VK_EXT_texture_compression_astc_hdr
typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
VkStructureType    sType;
void*              pNext;
VkBool32           textureCompressionASTC_HDR;
} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;

The members of the VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT structure describe the following features:

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

• VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT

• VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT

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 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported. VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT can also be included in the pNext chain of vkCreateDevice to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT

The VkPhysicalDeviceLineRasterizationFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceLineRasterizationFeaturesEXT structure describe the following features:

• rectangularLines indicates whether the implementation supports rectangular line rasterization.

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

• smoothLines indicates whether the implementation supports smooth line rasterization.

• stippledRectangularLines indicates whether the implementation supports stippled line rasterization with VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT lines, or with VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT lines if VkPhysicalDeviceLimits::strictLines is VK_TRUE.

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

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

If the VkPhysicalDeviceLineRasterizationFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceLineRasterizationFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT

The VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure describe the following features:

• subgroupSizeControl indicates whether the implementation supports controlling shader subgroup sizes via the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag and the VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure.

• computeFullSubgroups indicates whether the implementation supports requiring full subgroups in compute shaders via the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag.

If the VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceSubgroupSizeControlFeaturesEXT can also be included in the pNext chain of VkDeviceCreateInfo to enable the feature.

 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.
Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT

The VkPhysicalDeviceCoherentMemoryFeaturesAMD structure is defined as:

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

The members of the VkPhysicalDeviceCoherentMemoryFeaturesAMD structure describe the following features:

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD

The VkPhysicalDeviceRayTracingFeaturesKHR structure is defined as:

// Provided by VK_KHR_ray_tracing
typedef struct VkPhysicalDeviceRayTracingFeaturesKHR {
VkStructureType    sType;
void*              pNext;
VkBool32           rayTracing;
VkBool32           rayTracingAccelerationStructureCaptureReplay;
VkBool32           rayTracingIndirectTraceRays;
VkBool32           rayTracingIndirectAccelerationStructureBuild;
VkBool32           rayTracingHostAccelerationStructureCommands;
VkBool32           rayQuery;
VkBool32           rayTracingPrimitiveCulling;
} VkPhysicalDeviceRayTracingFeaturesKHR;

The members of the VkPhysicalDeviceRayTracingFeaturesKHR structure describe the following features:

• rayTracing indicates whether the implementation supports ray tracing functionality. See Ray Tracing.

• rayTracingShaderGroupHandleCaptureReplay indicates whether the implementation supports saving and reusing shader group handles, e.g. for trace capture and replay.

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

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

• rayTracingIndirectTraceRays indicates whether the implementation supports indirect trace ray commands, e.g. vkCmdTraceRaysIndirectKHR.

• rayTracingIndirectAccelerationStructureBuild indicates whether the implementation supports indirect acceleration structure build commands, e.g. vkCmdBuildAccelerationStructureIndirectKHR.

• rayTracingHostAccelerationStructureCommands indicates whether the implementation supports host side acceleration structure commands, e.g. vkBuildAccelerationStructureKHR, vkCopyAccelerationStructureKHR, vkCopyAccelerationStructureToMemoryKHR, vkCopyMemoryToAccelerationStructureKHR, vkWriteAccelerationStructuresPropertiesKHR.

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

• rayTracingPrimitiveCulling indicates whether the implementation supports primitive culling during ray traversal.

If the VkPhysicalDeviceRayTracingFeaturesKHR structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceRayTracingFeaturesKHR can also be used in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage
• If rayTracingShaderGroupHandleCaptureReplayMixed is VK_TRUE, rayTracingShaderGroupHandleCaptureReplay must also be VK_TRUE

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR

The VkPhysicalDeviceExtendedDynamicStateFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceExtendedDynamicStateFeaturesEXT structure describe the following features:

• extendedDynamicState indicates that the implementation supports the following dynamic states:

• VK_DYNAMIC_STATE_CULL_MODE_EXT

• VK_DYNAMIC_STATE_FRONT_FACE_EXT

• VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT

• VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT

• VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT

• VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT

• VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT

• VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT

• VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT

• VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT

• VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT

• VK_DYNAMIC_STATE_STENCIL_OP_EXT

If the VkPhysicalDeviceExtendedDynamicStateFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceExtendedDynamicStateFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT

The VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV structure is defined as:

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

The members of the VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV structure describe the following features:

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

If the VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV can also be used in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV

The VkPhysicalDeviceDiagnosticsConfigFeaturesNV structure is defined as:

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

The members of the VkPhysicalDeviceDiagnosticsConfigFeaturesNV structure describe the following features:

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

If the VkPhysicalDeviceDiagnosticsConfigFeaturesNV structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDeviceDiagnosticsConfigFeaturesNV can also be used in the pNext chain of VkDeviceCreateInfo to enable the feature.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV

The VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT structure is defined as:

// Provided by VK_EXT_pipeline_creation_cache_control
typedef struct VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT {
VkStructureType    sType;
void*              pNext;
VkBool32           pipelineCreationCacheControl;
} VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT;

The members of the VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT structure describe the following features:

• pipelineCreationCacheControl indicates that the implementation supports:

• The following can be used in Vk*PipelineCreateInfo::flags:

• VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT

• VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT

• The following can be used in VkPipelineCacheCreateInfo::flags:

• VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT

If the VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to enable features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT

The VkPhysicalDevicePrivateDataFeaturesEXT structure is defined as:

// Provided by VK_EXT_private_data
typedef struct VkPhysicalDevicePrivateDataFeaturesEXT {
VkStructureType    sType;
void*              pNext;
VkBool32           privateData;
} VkPhysicalDevicePrivateDataFeaturesEXT;

The members of the VkPhysicalDevicePrivateDataFeaturesEXT structure describe the following features:

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

If the VkPhysicalDevicePrivateDataFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported. VkPhysicalDevicePrivateDataFeaturesEXT can also be used in the pNext chain of VkDeviceCreateInfo to enable the features.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT

The VkPhysicalDeviceRobustness2FeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceRobustness2FeaturesEXT structure describe the following features:

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

• robustImageAccess2 indicates whether image accesses are tightly bounds-checked against the dimensions of the image view. Out of bounds image loads will return zero values, with (0,0,1) values inserted for missing G, B, or A components based on the format.

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

If the VkPhysicalDeviceRobustness2FeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether each feature is supported.

Valid Usage
Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT

The VkPhysicalDeviceImageRobustnessFeaturesEXT structure is defined as:

// Provided by VK_EXT_image_robustness
typedef struct VkPhysicalDeviceImageRobustnessFeaturesEXT {
VkStructureType    sType;
void*              pNext;
VkBool32           robustImageAccess;
} VkPhysicalDeviceImageRobustnessFeaturesEXT;

The members of the VkPhysicalDeviceImageRobustnessFeaturesEXT structure describe the following features:

• 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 VkPhysicalDeviceImageRobustnessFeaturesEXT structure is included in the pNext chain of VkPhysicalDeviceFeatures2, it is filled with values indicating whether the feature is supported.

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT

The VkPhysicalDeviceCustomBorderColorFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDeviceCustomBorderColorFeaturesEXT structure describe the following features:

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

• VK_BORDER_COLOR_FLOAT_CUSTOM_EXT

• VK_BORDER_COLOR_INT_CUSTOM_EXT

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

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT

To query supported performance counter query pool features, call vkGetPhysicalDeviceFeatures2 with a VkPhysicalDevicePerformanceQueryFeaturesKHR structure included in the pNext chain of its pFeatures parameter.

The VkPhysicalDevicePerformanceQueryFeaturesKHR structure is defined as:

// Provided by VK_KHR_performance_query
typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
VkStructureType    sType;
void*              pNext;
VkBool32           performanceCounterQueryPools;
VkBool32           performanceCounterMultipleQueryPools;
} VkPhysicalDevicePerformanceQueryFeaturesKHR;
• sType is the type of this structure.

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

• performanceCounterQueryPools indicates whether the implementation supports performance counter query pools.

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

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR

The VkPhysicalDevice4444FormatsFeaturesEXT structure is defined as:

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

The members of the VkPhysicalDevice4444FormatsFeaturesEXT structure describe the following features:

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

• VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT

• VK_FORMAT_FEATURE_BLIT_SRC_BIT

• VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT

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

• VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT

• VK_FORMAT_FEATURE_BLIT_SRC_BIT

• VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT

Valid Usage (Implicit)
• sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT

### 38.1. Feature Requirements

All Vulkan graphics implementations must support the following features:

All other features defined in the Specification are optional.