Author: The Khronos® Vulkan Working Group

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

The Khronos® Vulkan Working Group
version 1.3.255, 2023-06-26 13:15:51Z
from git branch: Git branch not available commit: Git commit not available

Loading… please wait.

Search:

## 46. Limits

Limits are implementation-dependent minimums, maximums, and other device characteristics that an application may need to be aware of.

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

The `VkPhysicalDeviceLimits` structure is defined as:

    // Provided by VK_VERSION_1_0
    typedef struct VkPhysicalDeviceLimits {
        uint32_t              maxImageDimension1D;
        uint32_t              maxImageDimension2D;
        uint32_t              maxImageDimension3D;
        uint32_t              maxImageDimensionCube;
        uint32_t              maxImageArrayLayers;
        uint32_t              maxTexelBufferElements;
        uint32_t              maxUniformBufferRange;
        uint32_t              maxStorageBufferRange;
        uint32_t              maxPushConstantsSize;
        uint32_t              maxMemoryAllocationCount;
        uint32_t              maxSamplerAllocationCount;
        VkDeviceSize          bufferImageGranularity;
        VkDeviceSize          sparseAddressSpaceSize;
        uint32_t              maxBoundDescriptorSets;
        uint32_t              maxPerStageDescriptorSamplers;
        uint32_t              maxPerStageDescriptorUniformBuffers;
        uint32_t              maxPerStageDescriptorStorageBuffers;
        uint32_t              maxPerStageDescriptorSampledImages;
        uint32_t              maxPerStageDescriptorStorageImages;
        uint32_t              maxPerStageDescriptorInputAttachments;
        uint32_t              maxPerStageResources;
        uint32_t              maxDescriptorSetSamplers;
        uint32_t              maxDescriptorSetUniformBuffers;
        uint32_t              maxDescriptorSetUniformBuffersDynamic;
        uint32_t              maxDescriptorSetStorageBuffers;
        uint32_t              maxDescriptorSetStorageBuffersDynamic;
        uint32_t              maxDescriptorSetSampledImages;
        uint32_t              maxDescriptorSetStorageImages;
        uint32_t              maxDescriptorSetInputAttachments;
        uint32_t              maxVertexInputAttributes;
        uint32_t              maxVertexInputBindings;
        uint32_t              maxVertexInputAttributeOffset;
        uint32_t              maxVertexInputBindingStride;
        uint32_t              maxVertexOutputComponents;
        uint32_t              maxTessellationGenerationLevel;
        uint32_t              maxTessellationPatchSize;
        uint32_t              maxTessellationControlPerVertexInputComponents;
        uint32_t              maxTessellationControlPerVertexOutputComponents;
        uint32_t              maxTessellationControlPerPatchOutputComponents;
        uint32_t              maxTessellationControlTotalOutputComponents;
        uint32_t              maxTessellationEvaluationInputComponents;
        uint32_t              maxTessellationEvaluationOutputComponents;
        uint32_t              maxGeometryShaderInvocations;
        uint32_t              maxGeometryInputComponents;
        uint32_t              maxGeometryOutputComponents;
        uint32_t              maxGeometryOutputVertices;
        uint32_t              maxGeometryTotalOutputComponents;
        uint32_t              maxFragmentInputComponents;
        uint32_t              maxFragmentOutputAttachments;
        uint32_t              maxFragmentDualSrcAttachments;
        uint32_t              maxFragmentCombinedOutputResources;
        uint32_t              maxComputeSharedMemorySize;
        uint32_t              maxComputeWorkGroupCount[3];
        uint32_t              maxComputeWorkGroupInvocations;
        uint32_t              maxComputeWorkGroupSize[3];
        uint32_t              subPixelPrecisionBits;
        uint32_t              subTexelPrecisionBits;
        uint32_t              mipmapPrecisionBits;
        uint32_t              maxDrawIndexedIndexValue;
        uint32_t              maxDrawIndirectCount;
        float                 maxSamplerLodBias;
        float                 maxSamplerAnisotropy;
        uint32_t              maxViewports;
        uint32_t              maxViewportDimensions[2];
        float                 viewportBoundsRange[2];
        uint32_t              viewportSubPixelBits;
        size_t                minMemoryMapAlignment;
        VkDeviceSize          minTexelBufferOffsetAlignment;
        VkDeviceSize          minUniformBufferOffsetAlignment;
        VkDeviceSize          minStorageBufferOffsetAlignment;
        int32_t               minTexelOffset;
        uint32_t              maxTexelOffset;
        int32_t               minTexelGatherOffset;
        uint32_t              maxTexelGatherOffset;
        float                 minInterpolationOffset;
        float                 maxInterpolationOffset;
        uint32_t              subPixelInterpolationOffsetBits;
        uint32_t              maxFramebufferWidth;
        uint32_t              maxFramebufferHeight;
        uint32_t              maxFramebufferLayers;
        VkSampleCountFlags    framebufferColorSampleCounts;
        VkSampleCountFlags    framebufferDepthSampleCounts;
        VkSampleCountFlags    framebufferStencilSampleCounts;
        VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
        uint32_t              maxColorAttachments;
        VkSampleCountFlags    sampledImageColorSampleCounts;
        VkSampleCountFlags    sampledImageIntegerSampleCounts;
        VkSampleCountFlags    sampledImageDepthSampleCounts;
        VkSampleCountFlags    sampledImageStencilSampleCounts;
        VkSampleCountFlags    storageImageSampleCounts;
        uint32_t              maxSampleMaskWords;
        VkBool32              timestampComputeAndGraphics;
        float                 timestampPeriod;
        uint32_t              maxClipDistances;
        uint32_t              maxCullDistances;
        uint32_t              maxCombinedClipAndCullDistances;
        uint32_t              discreteQueuePriorities;
        float                 pointSizeRange[2];
        float                 lineWidthRange[2];
        float                 pointSizeGranularity;
        float                 lineWidthGranularity;
        VkBool32              strictLines;
        VkBool32              standardSampleLocations;
        VkDeviceSize          optimalBufferCopyOffsetAlignment;
        VkDeviceSize          optimalBufferCopyRowPitchAlignment;
        VkDeviceSize          nonCoherentAtomSize;
    } VkPhysicalDeviceLimits;

The `VkPhysicalDeviceLimits` are properties of the physical device. These are available in the `limits` member of the VkPhysicalDeviceProperties structure which is returned from vkGetPhysicalDeviceProperties.

- `maxImageDimension1D` is the largest dimension (`width`) that is guaranteed to be supported for all images created with an `imageType` of `VK_IMAGE_TYPE_1D`. Some combinations of image parameters (format, usage, etc.) may allow support for larger dimensions, which can be queried using vkGetPhysicalDeviceImageFormatProperties.

- `maxImageDimension2D` is the largest dimension (`width` or `height`) that is guaranteed to be supported for all images created with an `imageType` of `VK_IMAGE_TYPE_2D` and without `VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT` set in `flags`. Some combinations of image parameters (format, usage, etc.) may allow support for larger dimensions, which can be queried using vkGetPhysicalDeviceImageFormatProperties.

- `maxImageDimension3D` is the largest dimension (`width`, `height`, or `depth`) that is guaranteed to be supported for all images created with an `imageType` of `VK_IMAGE_TYPE_3D`. Some combinations of image parameters (format, usage, etc.) may allow support for larger dimensions, which can be queried using vkGetPhysicalDeviceImageFormatProperties.

- `maxImageDimensionCube` is the largest dimension (`width` or `height`) that is guaranteed to be supported for all images created with an `imageType` of `VK_IMAGE_TYPE_2D` and with `VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT` set in `flags`. Some combinations of image parameters (format, usage, etc.) may allow support for larger dimensions, which can be queried using vkGetPhysicalDeviceImageFormatProperties.

- `maxImageArrayLayers` is the maximum number of layers (`arrayLayers`) for an image.

- `maxTexelBufferElements` is the maximum number of addressable texels for a buffer view created on a buffer which was created with the `VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT` or `VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT` set in the `usage` member of the VkBufferCreateInfo structure.

- `maxUniformBufferRange` is the maximum value that can be specified in the `range` member of a VkDescriptorBufferInfo structure passed to vkUpdateDescriptorSets for descriptors of type `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` or `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC`.

- `maxStorageBufferRange` is the maximum value that can be specified in the `range` member of a VkDescriptorBufferInfo structure passed to vkUpdateDescriptorSets for descriptors of type `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` or `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`.

- `maxPushConstantsSize` is the maximum size, in bytes, of the pool of push constant memory. For each of the push constant ranges indicated by the `pPushConstantRanges` member of the VkPipelineLayoutCreateInfo structure, (`offset` + `size`) must be less than or equal to this limit.

- `maxMemoryAllocationCount` is the maximum number of device memory allocations, as created by vkAllocateMemory, which can simultaneously exist.

- `maxSamplerAllocationCount` is the maximum number of sampler objects, as created by vkCreateSampler, which can simultaneously exist on a device.

- `bufferImageGranularity` is the granularity, in bytes, at which buffer or linear image resources, and optimal image resources can be bound to adjacent offsets in the same `VkDeviceMemory` object without aliasing. See Buffer-Image Granularity for more details.

- `sparseAddressSpaceSize` is the total amount of address space available, in bytes, for sparse memory resources. This is an upper bound on the sum of the sizes of all sparse resources, regardless of whether any memory is bound to them.

- `maxBoundDescriptorSets` is the maximum number of descriptor sets that can be simultaneously used by a pipeline. All `DescriptorSet` decorations in shader modules must have a value less than `maxBoundDescriptorSets`. See Descriptor Sets.

- `maxPerStageDescriptorSamplers` is the maximum number of samplers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_SAMPLER` or `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. A descriptor is accessible to a shader stage when the `stageFlags` member of the `VkDescriptorSetLayoutBinding` structure has the bit for that shader stage set. See Sampler and Combined Image Sampler.

- `maxPerStageDescriptorUniformBuffers` is the maximum number of uniform buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` or `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. A descriptor is accessible to a shader stage when the `stageFlags` member of the `VkDescriptorSetLayoutBinding` structure has the bit for that shader stage set. See Uniform Buffer and Dynamic Uniform Buffer.

- `maxPerStageDescriptorStorageBuffers` is the maximum number of storage buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` or `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the `stageFlags` member of the `VkDescriptorSetLayoutBinding` structure has the bit for that shader stage set. See Storage Buffer and Dynamic Storage Buffer.

- `maxPerStageDescriptorSampledImages` is the maximum number of sampled images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`, `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE`, or `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the `stageFlags` member of the `VkDescriptorSetLayoutBinding` structure has the bit for that shader stage set. See Combined Image Sampler, Sampled Image, and Uniform Texel Buffer.

- `maxPerStageDescriptorStorageImages` is the maximum number of storage images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE`, or `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the `stageFlags` member of the `VkDescriptorSetLayoutBinding` structure has the bit for that shader stage set. See Storage Image, and Storage Texel Buffer.

- `maxPerStageDescriptorInputAttachments` is the maximum number of input attachments that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the `stageFlags` member of the `VkDescriptorSetLayoutBinding` structure has the bit for that shader stage set. These are only supported for the fragment stage. See Input Attachment.

- `maxPerStageResources` is the maximum number of resources that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`, `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE`, `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE`, `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER`, `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER`, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER`, `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER`, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC`, `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, or `VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. For the fragment shader stage the framebuffer color attachments also count against this limit.

- `maxDescriptorSetSamplers` is the maximum number of samplers that can be included in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_SAMPLER` or `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. See Sampler and Combined Image Sampler.

- `maxDescriptorSetUniformBuffers` is the maximum number of uniform buffers that can be included in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` or `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. See Uniform Buffer and Dynamic Uniform Buffer.

- `maxDescriptorSetUniformBuffersDynamic` is the maximum number of dynamic uniform buffers that can be included in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. See Dynamic Uniform Buffer.

- `maxDescriptorSetStorageBuffers` is the maximum number of storage buffers that can be included in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` or `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. See Storage Buffer and Dynamic Storage Buffer.

- `maxDescriptorSetStorageBuffersDynamic` is the maximum number of dynamic storage buffers that can be included in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. See Dynamic Storage Buffer.

- `maxDescriptorSetSampledImages` is the maximum number of sampled images that can be included in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER`, `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE`, or `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. See Combined Image Sampler, Sampled Image, and Uniform Texel Buffer.

- `maxDescriptorSetStorageImages` is the maximum number of storage images that can be included in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE`, or `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. See Storage Image, and Storage Texel Buffer.

- `maxDescriptorSetInputAttachments` is the maximum number of input attachments that can be included in a pipeline layout. Descriptors with a type of `VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT` count against this limit. Only descriptors in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit. See Input Attachment.

- `maxVertexInputAttributes` is the maximum number of vertex input attributes that can be specified for a graphics pipeline. These are described in the array of `VkVertexInputAttributeDescription` structures that are provided at graphics pipeline creation time via the `pVertexAttributeDescriptions` member of the VkPipelineVertexInputStateCreateInfo structure. See Vertex Attributes and Vertex Input Description.

- `maxVertexInputBindings` is the maximum number of vertex buffers that can be specified for providing vertex attributes to a graphics pipeline. These are described in the array of `VkVertexInputBindingDescription` structures that are provided at graphics pipeline creation time via the `pVertexBindingDescriptions` member of the VkPipelineVertexInputStateCreateInfo structure. The `binding` member of `VkVertexInputBindingDescription` must be less than this limit. See Vertex Input Description.

- `maxVertexInputAttributeOffset` is the maximum vertex input attribute offset that can be added to the vertex input binding stride. The `offset` member of the `VkVertexInputAttributeDescription` structure must be less than or equal to this limit. See Vertex Input Description.

- `maxVertexInputBindingStride` is the maximum vertex input binding stride that can be specified in a vertex input binding. The `stride` member of the `VkVertexInputBindingDescription` structure must be less than or equal to this limit. See Vertex Input Description.

- `maxVertexOutputComponents` is the maximum number of components of output variables which can be output by a vertex shader. See Vertex Shaders.

- `maxTessellationGenerationLevel` is the maximum tessellation generation level supported by the fixed-function tessellation primitive generator. See Tessellation.

- `maxTessellationPatchSize` is the maximum patch size, in vertices, of patches that can be processed by the tessellation control shader and tessellation primitive generator. The `patchControlPoints` member of the VkPipelineTessellationStateCreateInfo structure specified at pipeline creation time and the value provided in the `OutputVertices` execution mode of shader modules must be less than or equal to this limit. See Tessellation.

- `maxTessellationControlPerVertexInputComponents` is the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation control shader stage.

- `maxTessellationControlPerVertexOutputComponents` is the maximum number of components of per-vertex output variables which can be output from the tessellation control shader stage.

- `maxTessellationControlPerPatchOutputComponents` is the maximum number of components of per-patch output variables which can be output from the tessellation control shader stage.

- `maxTessellationControlTotalOutputComponents` is the maximum total number of components of per-vertex and per-patch output variables which can be output from the tessellation control shader stage.

- `maxTessellationEvaluationInputComponents` is the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation evaluation shader stage.

- `maxTessellationEvaluationOutputComponents` is the maximum number of components of per-vertex output variables which can be output from the tessellation evaluation shader stage.

- `maxGeometryShaderInvocations` is the maximum invocation count supported for instanced geometry shaders. The value provided in the `Invocations` execution mode of shader modules must be less than or equal to this limit. See Geometry Shading.

- `maxGeometryInputComponents` is the maximum number of components of input variables which can be provided as inputs to the geometry shader stage.

- `maxGeometryOutputComponents` is the maximum number of components of output variables which can be output from the geometry shader stage.

- `maxGeometryOutputVertices` is the maximum number of vertices which can be emitted by any geometry shader.

- `maxGeometryTotalOutputComponents` is the maximum total number of components of output variables, across all emitted vertices, which can be output from the geometry shader stage.

- `maxFragmentInputComponents` is the maximum number of components of input variables which can be provided as inputs to the fragment shader stage.

- `maxFragmentOutputAttachments` is the maximum number of output attachments which can be written to by the fragment shader stage.

- `maxFragmentDualSrcAttachments` is the maximum number of output attachments which can be written to by the fragment shader stage when blending is enabled and one of the dual source blend modes is in use. See Dual-Source Blending and `dualSrcBlend`.

- `maxFragmentCombinedOutputResources` is the total number of storage buffers, storage images, and output `Location` decorated color attachments (described in Fragment Output Interface) which can be used in the fragment shader stage.

- `maxComputeSharedMemorySize` is the maximum total storage size, in bytes, available for variables declared with the `Workgroup` storage class in shader modules (or with the `shared` storage qualifier in GLSL) in the compute shader stage.

- `maxComputeWorkGroupCount`[3] is the maximum number of local workgroups that can be dispatched by a single dispatching command. These three values represent the maximum number of local workgroups for the X, Y, and Z dimensions, respectively. The workgroup count parameters to the dispatching commands must be less than or equal to the corresponding limit. See Dispatching Commands.

- `maxComputeWorkGroupInvocations` is the maximum total number of compute shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode in shader modules or by the object decorated by the `WorkgroupSize` decoration, must be less than or equal to this limit.

- `maxComputeWorkGroupSize`[3] is the maximum size of a local compute workgroup, per dimension. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The `x`, `y`, and `z` sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode or by the object decorated by the `WorkgroupSize` decoration in shader modules, must be less than or equal to the corresponding limit.

- `subPixelPrecisionBits` is the number of bits of subpixel precision in framebuffer coordinates xf and yf. See Rasterization.

- `subTexelPrecisionBits` is the number of bits of precision in the division along an axis of an image used for minification and magnification filters. 2`subTexelPrecisionBits` is the actual number of divisions along each axis of the image represented. Sub-texel values calculated during image sampling will snap to these locations when generating the filtered results.

- `mipmapPrecisionBits` is the number of bits of division that the LOD calculation for mipmap fetching get snapped to when determining the contribution from each mip level to the mip filtered results. 2`mipmapPrecisionBits` is the actual number of divisions.

- `maxDrawIndexedIndexValue` is the maximum index value that can be used for indexed draw calls when using 32-bit indices. This excludes the primitive restart index value of 0xFFFFFFFF. See `fullDrawIndexUint32`.

- `maxDrawIndirectCount` is the maximum draw count that is supported for indirect drawing calls. See `multiDrawIndirect`.

- `maxSamplerLodBias` is the maximum absolute sampler LOD bias. The sum of the `mipLodBias` member of the VkSamplerCreateInfo structure and the `Bias` operand of image sampling operations in shader modules (or 0 if no `Bias` operand is provided to an image sampling operation) are clamped to the range [-`maxSamplerLodBias`,+`maxSamplerLodBias`]. See [samplers-mipLodBias].

- `maxSamplerAnisotropy` is the maximum degree of sampler anisotropy. The maximum degree of anisotropic filtering used for an image sampling operation is the minimum of the `maxAnisotropy` member of the VkSamplerCreateInfo structure and this limit. See [samplers-maxAnisotropy].

- `maxViewports` is the maximum number of active viewports. The `viewportCount` member of the VkPipelineViewportStateCreateInfo structure that is provided at pipeline creation must be less than or equal to this limit.

- `maxViewportDimensions`[2] are the maximum viewport dimensions in the X (width) and Y (height) dimensions, respectively. The maximum viewport dimensions must be greater than or equal to the largest image which can be created and used as a framebuffer attachment. See Controlling the Viewport.

- `viewportBoundsRange`[2] is the [minimum, maximum] range that the corners of a viewport must be contained in. This range must be at least [-2 × `size`, 2 × `size` - 1], where `size` = max(`maxViewportDimensions`[0], `maxViewportDimensions`[1]). See Controlling the Viewport.

  | Note The intent of the `viewportBoundsRange` limit is to allow a maximum sized viewport to be arbitrarily shifted relative to the output target as long as at least some portion intersects. This would give a bounds limit of [-`size` + 1, 2 × `size` - 1] which would allow all possible non-empty-set intersections of the output target and the viewport. Since these numbers are typically powers of two, picking the signed number range using the smallest possible number of bits ends up with the specified range.

- `viewportSubPixelBits` is the number of bits of subpixel precision for viewport bounds. The subpixel precision that floating-point viewport bounds are interpreted at is given by this limit.

- `minMemoryMapAlignment` is the minimum required alignment, in bytes, of host visible memory allocations within the host address space. When mapping a memory allocation with vkMapMemory, subtracting `offset` bytes from the returned pointer will always produce an integer multiple of this limit. See Host Access to Device Memory Objects. The value must be a power of two.

- `minTexelBufferOffsetAlignment` is the minimum required alignment, in bytes, for the `offset` member of the VkBufferViewCreateInfo structure for texel buffers. The value must be a power of two. If `texelBufferAlignment` is enabled, this limit is equivalent to the maximum of the `uniformTexelBufferOffsetAlignmentBytes` and `storageTexelBufferOffsetAlignmentBytes` members of VkPhysicalDeviceTexelBufferAlignmentProperties, but smaller alignment is optionally allowed by `storageTexelBufferOffsetSingleTexelAlignment` and `uniformTexelBufferOffsetSingleTexelAlignment`. If `texelBufferAlignment` is not enabled, VkBufferViewCreateInfo::`offset` must be a multiple of this value.

- `minUniformBufferOffsetAlignment` is the minimum required alignment, in bytes, for the `offset` member of the `VkDescriptorBufferInfo` structure for uniform buffers. When a descriptor of type `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` or `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` is updated, the `offset` must be an integer multiple of this limit. Similarly, dynamic offsets for uniform buffers must be multiples of this limit. The value must be a power of two.

- `minStorageBufferOffsetAlignment` is the minimum required alignment, in bytes, for the `offset` member of the `VkDescriptorBufferInfo` structure for storage buffers. When a descriptor of type `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` or `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC` is updated, the `offset` must be an integer multiple of this limit. Similarly, dynamic offsets for storage buffers must be multiples of this limit. The value must be a power of two.

- `minTexelOffset` is the minimum offset value for the `ConstOffset` image operand of any of the `OpImageSample*` or `OpImageFetch*` image instructions.

- `maxTexelOffset` is the maximum offset value for the `ConstOffset` image operand of any of the `OpImageSample*` or `OpImageFetch*` image instructions.

- `minTexelGatherOffset` is the minimum offset value for the `Offset`, `ConstOffset`, or `ConstOffsets` image operands of any of the `OpImage*Gather` image instructions.

- `maxTexelGatherOffset` is the maximum offset value for the `Offset`, `ConstOffset`, or `ConstOffsets` image operands of any of the `OpImage*Gather` image instructions.

- `minInterpolationOffset` is the base minimum (inclusive) negative offset value for the `Offset` operand of the `InterpolateAtOffset` extended instruction.

- `maxInterpolationOffset` is the base maximum (inclusive) positive offset value for the `Offset` operand of the `InterpolateAtOffset` extended instruction.

- `subPixelInterpolationOffsetBits` is the number of fractional bits that the `x` and `y` offsets to the `InterpolateAtOffset` extended instruction may be rounded to as fixed-point values.

- `maxFramebufferWidth` is the maximum width for a framebuffer. The `width` member of the VkFramebufferCreateInfo structure must be less than or equal to this limit.

- `maxFramebufferHeight` is the maximum height for a framebuffer. The `height` member of the VkFramebufferCreateInfo structure must be less than or equal to this limit.

- `maxFramebufferLayers` is the maximum layer count for a layered framebuffer. The `layers` member of the VkFramebufferCreateInfo structure must be less than or equal to this limit.

- `framebufferColorSampleCounts` is a bitmask1 of VkSampleCountFlagBits indicating the color sample counts that are supported for all framebuffer color attachments with floating- or fixed-point formats. For color attachments with integer formats, see `framebufferIntegerColorSampleCounts`.

- `framebufferDepthSampleCounts` is a bitmask1 of VkSampleCountFlagBits indicating the supported depth sample counts for all framebuffer depth/stencil attachments, when the format includes a depth component.

- `framebufferStencilSampleCounts` is a bitmask1 of VkSampleCountFlagBits indicating the supported stencil sample counts for all framebuffer depth/stencil attachments, when the format includes a stencil component.

- `framebufferNoAttachmentsSampleCounts` is a bitmask1 of VkSampleCountFlagBits indicating the supported sample counts for a subpass which uses no attachments.

- `maxColorAttachments` is the maximum number of color attachments that can be used by a subpass in a render pass. The `colorAttachmentCount` member of the `VkSubpassDescription` or `VkSubpassDescription2` structure must be less than or equal to this limit.

- `sampledImageColorSampleCounts` is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with `VK_IMAGE_TILING_OPTIMAL`, `usage` containing `VK_IMAGE_USAGE_SAMPLED_BIT`, and a non-integer color format.

- `sampledImageIntegerSampleCounts` is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with `VK_IMAGE_TILING_OPTIMAL`, `usage` containing `VK_IMAGE_USAGE_SAMPLED_BIT`, and an integer color format.

- `sampledImageDepthSampleCounts` is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with `VK_IMAGE_TILING_OPTIMAL`, `usage` containing `VK_IMAGE_USAGE_SAMPLED_BIT`, and a depth format.

- `sampledImageStencilSampleCounts` is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with `VK_IMAGE_TILING_OPTIMAL`, `usage` containing `VK_IMAGE_USAGE_SAMPLED_BIT`, and a stencil format.

- `storageImageSampleCounts` is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with `VK_IMAGE_TILING_OPTIMAL`, and `usage` containing `VK_IMAGE_USAGE_STORAGE_BIT`.

- `maxSampleMaskWords` is the maximum number of array elements of a variable decorated with the `SampleMask` built-in decoration.

- `timestampComputeAndGraphics` specifies support for timestamps on all graphics and compute queues. If this limit is set to `VK_TRUE`, all queues that advertise the `VK_QUEUE_GRAPHICS_BIT` or `VK_QUEUE_COMPUTE_BIT` in the `VkQueueFamilyProperties`::`queueFlags` support `VkQueueFamilyProperties`::`timestampValidBits` of at least 36. See Timestamp Queries.

- `timestampPeriod` is the number of nanoseconds required for a timestamp query to be incremented by 1. See Timestamp Queries.

- `maxClipDistances` is the maximum number of clip distances that can be used in a single shader stage. The size of any array declared with the `ClipDistance` built-in decoration in a shader module must be less than or equal to this limit.

- `maxCullDistances` is the maximum number of cull distances that can be used in a single shader stage. The size of any array declared with the `CullDistance` built-in decoration in a shader module must be less than or equal to this limit.

- `maxCombinedClipAndCullDistances` is the maximum combined number of clip and cull distances that can be used in a single shader stage. The sum of the sizes of any pair of arrays declared with the `ClipDistance` and `CullDistance` built-in decoration used by a single shader stage in a shader module must be less than or equal to this limit.

- `discreteQueuePriorities` is the number of discrete priorities that can be assigned to a queue based on the value of each member of VkDeviceQueueCreateInfo::`pQueuePriorities`. This must be at least 2, and levels must be spread evenly over the range, with at least one level at 1.0, and another at 0.0. See Queue Priority.

- `pointSizeRange`[2] is the range [`minimum`,`maximum`] of supported sizes for points. Values written to variables decorated with the `PointSize` built-in decoration are clamped to this range.

- `lineWidthRange`[2] is the range [`minimum`,`maximum`] of supported widths for lines. Values specified by the `lineWidth` member of the VkPipelineRasterizationStateCreateInfo or the `lineWidth` parameter to `vkCmdSetLineWidth` are clamped to this range.

- `pointSizeGranularity` is the granularity of supported point sizes. Not all point sizes in the range defined by `pointSizeRange` are supported. This limit specifies the granularity (or increment) between successive supported point sizes.

- `lineWidthGranularity` is the granularity of supported line widths. Not all line widths in the range defined by `lineWidthRange` are supported. This limit specifies the granularity (or increment) between successive supported line widths.

- `strictLines` specifies whether lines are rasterized according to the preferred method of rasterization. If set to `VK_FALSE`, lines may be rasterized under a relaxed set of rules. If set to `VK_TRUE`, lines are rasterized as per the strict definition. See Basic Line Segment Rasterization.

- `standardSampleLocations` specifies whether rasterization uses the standard sample locations as documented in Multisampling. If set to `VK_TRUE`, the implementation uses the documented sample locations. If set to `VK_FALSE`, the implementation may use different sample locations.

- `optimalBufferCopyOffsetAlignment` is the optimal buffer offset alignment in bytes for vkCmdCopyBufferToImage2, vkCmdCopyBufferToImage, vkCmdCopyImageToBuffer2, and vkCmdCopyImageToBuffer. The per texel alignment requirements are enforced, but applications should use the optimal alignment for optimal performance and power use. The value must be a power of two.

- `optimalBufferCopyRowPitchAlignment` is the optimal buffer row pitch alignment in bytes for vkCmdCopyBufferToImage2, vkCmdCopyBufferToImage, vkCmdCopyImageToBuffer2, and vkCmdCopyImageToBuffer. Row pitch is the number of bytes between texels with the same X coordinate in adjacent rows (Y coordinates differ by one). The per texel alignment requirements are enforced, but applications should use the optimal alignment for optimal performance and power use. The value must be a power of two.

- `nonCoherentAtomSize` is the size and alignment in bytes that bounds concurrent access to host-mapped device memory. The value must be a power of two.

  1

    For all bitmasks of VkSampleCountFlagBits, the sample count limits defined above represent the minimum supported sample counts for each image type. Individual images may support additional sample counts, which are queried using vkGetPhysicalDeviceImageFormatProperties as described in Supported Sample Counts.

Bits which may be set in the sample count limits returned by VkPhysicalDeviceLimits, as well as in other queries and structures representing image sample counts, are:

    // Provided by VK_VERSION_1_0
    typedef enum VkSampleCountFlagBits {
        VK_SAMPLE_COUNT_1_BIT = 0x00000001,
        VK_SAMPLE_COUNT_2_BIT = 0x00000002,
        VK_SAMPLE_COUNT_4_BIT = 0x00000004,
        VK_SAMPLE_COUNT_8_BIT = 0x00000008,
        VK_SAMPLE_COUNT_16_BIT = 0x00000010,
        VK_SAMPLE_COUNT_32_BIT = 0x00000020,
        VK_SAMPLE_COUNT_64_BIT = 0x00000040,
    } VkSampleCountFlagBits;

- `VK_SAMPLE_COUNT_1_BIT` specifies an image with one sample per pixel.

- `VK_SAMPLE_COUNT_2_BIT` specifies an image with 2 samples per pixel.

- `VK_SAMPLE_COUNT_4_BIT` specifies an image with 4 samples per pixel.

- `VK_SAMPLE_COUNT_8_BIT` specifies an image with 8 samples per pixel.

- `VK_SAMPLE_COUNT_16_BIT` specifies an image with 16 samples per pixel.

- `VK_SAMPLE_COUNT_32_BIT` specifies an image with 32 samples per pixel.

- `VK_SAMPLE_COUNT_64_BIT` specifies an image with 64 samples per pixel.

    // Provided by VK_VERSION_1_0
    typedef VkFlags VkSampleCountFlags;

`VkSampleCountFlags` is a bitmask type for setting a mask of zero or more VkSampleCountFlagBits.

The `VkPhysicalDevicePushDescriptorPropertiesKHR` structure is defined as:

    // Provided by VK_KHR_push_descriptor
    typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxPushDescriptors;
    } VkPhysicalDevicePushDescriptorPropertiesKHR;

- `sType` is the type of this structure.

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

- `maxPushDescriptors` is the maximum number of descriptors that can be used in a descriptor set layout created with `VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR` set.

If the `VkPhysicalDevicePushDescriptorPropertiesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePushDescriptorPropertiesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR`

The `VkPhysicalDeviceMultiviewProperties` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceMultiviewProperties {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxMultiviewViewCount;
        uint32_t           maxMultiviewInstanceIndex;
    } VkPhysicalDeviceMultiviewProperties;

or the equivalent

    // Provided by VK_KHR_multiview
    typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;

- `sType` is the type of this structure.

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

- `maxMultiviewViewCount` is one greater than the maximum view index that can be used in a subpass.

- `maxMultiviewInstanceIndex` is the maximum valid value of instance index allowed to be generated by a drawing command recorded within a subpass of a multiview render pass instance.

If the `VkPhysicalDeviceMultiviewProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMultiviewProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES`

The `VkPhysicalDeviceFloatControlsProperties` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceFloatControlsProperties {
        VkStructureType                      sType;
        void*                                pNext;
        VkShaderFloatControlsIndependence    denormBehaviorIndependence;
        VkShaderFloatControlsIndependence    roundingModeIndependence;
        VkBool32                             shaderSignedZeroInfNanPreserveFloat16;
        VkBool32                             shaderSignedZeroInfNanPreserveFloat32;
        VkBool32                             shaderSignedZeroInfNanPreserveFloat64;
        VkBool32                             shaderDenormPreserveFloat16;
        VkBool32                             shaderDenormPreserveFloat32;
        VkBool32                             shaderDenormPreserveFloat64;
        VkBool32                             shaderDenormFlushToZeroFloat16;
        VkBool32                             shaderDenormFlushToZeroFloat32;
        VkBool32                             shaderDenormFlushToZeroFloat64;
        VkBool32                             shaderRoundingModeRTEFloat16;
        VkBool32                             shaderRoundingModeRTEFloat32;
        VkBool32                             shaderRoundingModeRTEFloat64;
        VkBool32                             shaderRoundingModeRTZFloat16;
        VkBool32                             shaderRoundingModeRTZFloat32;
        VkBool32                             shaderRoundingModeRTZFloat64;
    } VkPhysicalDeviceFloatControlsProperties;

or the equivalent

    // Provided by VK_KHR_shader_float_controls
    typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR;

- `sType` is the type of this structure.

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

- `denormBehaviorIndependence` is a VkShaderFloatControlsIndependence value indicating whether, and how, denorm behavior can be set independently for different bit widths.

- `roundingModeIndependence` is a VkShaderFloatControlsIndependence value indicating whether, and how, rounding modes can be set independently for different bit widths.

- `shaderSignedZeroInfNanPreserveFloat16` is a boolean value indicating whether sign of a zero, Nans and ±∞ can be preserved in 16-bit floating-point computations. It also indicates whether the `SignedZeroInfNanPreserve` execution mode can be used for 16-bit floating-point types.

- `shaderSignedZeroInfNanPreserveFloat32` is a boolean value indicating whether sign of a zero, Nans and ±∞ can be preserved in 32-bit floating-point computations. It also indicates whether the `SignedZeroInfNanPreserve` execution mode can be used for 32-bit floating-point types.

- `shaderSignedZeroInfNanPreserveFloat64` is a boolean value indicating whether sign of a zero, Nans and ±∞ can be preserved in 64-bit floating-point computations. It also indicates whether the `SignedZeroInfNanPreserve` execution mode can be used for 64-bit floating-point types.

- `shaderDenormPreserveFloat16` is a boolean value indicating whether denormals can be preserved in 16-bit floating-point computations. It also indicates whether the `DenormPreserve` execution mode can be used for 16-bit floating-point types.

- `shaderDenormPreserveFloat32` is a boolean value indicating whether denormals can be preserved in 32-bit floating-point computations. It also indicates whether the `DenormPreserve` execution mode can be used for 32-bit floating-point types.

- `shaderDenormPreserveFloat64` is a boolean value indicating whether denormals can be preserved in 64-bit floating-point computations. It also indicates whether the `DenormPreserve` execution mode can be used for 64-bit floating-point types.

- `shaderDenormFlushToZeroFloat16` is a boolean value indicating whether denormals can be flushed to zero in 16-bit floating-point computations. It also indicates whether the `DenormFlushToZero` execution mode can be used for 16-bit floating-point types.

- `shaderDenormFlushToZeroFloat32` is a boolean value indicating whether denormals can be flushed to zero in 32-bit floating-point computations. It also indicates whether the `DenormFlushToZero` execution mode can be used for 32-bit floating-point types.

- `shaderDenormFlushToZeroFloat64` is a boolean value indicating whether denormals can be flushed to zero in 64-bit floating-point computations. It also indicates whether the `DenormFlushToZero` execution mode can be used for 64-bit floating-point types.

- `shaderRoundingModeRTEFloat16` is a boolean value indicating whether an implementation supports the round-to-nearest-even rounding mode for 16-bit floating-point arithmetic and conversion instructions. It also indicates whether the `RoundingModeRTE` execution mode can be used for 16-bit floating-point types.

- `shaderRoundingModeRTEFloat32` is a boolean value indicating whether an implementation supports the round-to-nearest-even rounding mode for 32-bit floating-point arithmetic and conversion instructions. It also indicates whether the `RoundingModeRTE` execution mode can be used for 32-bit floating-point types.

- `shaderRoundingModeRTEFloat64` is a boolean value indicating whether an implementation supports the round-to-nearest-even rounding mode for 64-bit floating-point arithmetic and conversion instructions. It also indicates whether the `RoundingModeRTE` execution mode can be used for 64-bit floating-point types.

- `shaderRoundingModeRTZFloat16` is a boolean value indicating whether an implementation supports the round-towards-zero rounding mode for 16-bit floating-point arithmetic and conversion instructions. It also indicates whether the `RoundingModeRTZ` execution mode can be used for 16-bit floating-point types.

- `shaderRoundingModeRTZFloat32` is a boolean value indicating whether an implementation supports the round-towards-zero rounding mode for 32-bit floating-point arithmetic and conversion instructions. It also indicates whether the `RoundingModeRTZ` execution mode can be used for 32-bit floating-point types.

- `shaderRoundingModeRTZFloat64` is a boolean value indicating whether an implementation supports the round-towards-zero rounding mode for 64-bit floating-point arithmetic and conversion instructions. It also indicates whether the `RoundingModeRTZ` execution mode can be used for 64-bit floating-point types.

| editing-note Implementations may not be able to control behavior of denorms for floating-point atomics. This needs to be taken into account when such atomics will be added to Vulkan.

If the `VkPhysicalDeviceFloatControlsProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFloatControlsProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES`

Values which may be returned in the `denormBehaviorIndependence` and `roundingModeIndependence` fields of `VkPhysicalDeviceFloatControlsProperties` are:

    // Provided by VK_VERSION_1_2
    typedef enum VkShaderFloatControlsIndependence {
        VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,
        VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,
        VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,
      // Provided by VK_KHR_shader_float_controls
        VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY,
      // Provided by VK_KHR_shader_float_controls
        VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
      // Provided by VK_KHR_shader_float_controls
        VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE,
    } VkShaderFloatControlsIndependence;

or the equivalent

    // Provided by VK_KHR_shader_float_controls
    typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR;

- `VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY` specifies that shader float controls for 32-bit floating point can be set independently; other bit widths must be set identically to each other.

- `VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL` specifies that shader float controls for all bit widths can be set independently.

- `VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE` specifies that shader float controls for all bit widths must be set identically.

The `VkPhysicalDeviceDiscardRectanglePropertiesEXT` structure is defined as:

    // Provided by VK_EXT_discard_rectangles
    typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxDiscardRectangles;
    } VkPhysicalDeviceDiscardRectanglePropertiesEXT;

- `sType` is the type of this structure.

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

- `maxDiscardRectangles` is the maximum number of active discard rectangles that can be specified.

If the `VkPhysicalDeviceDiscardRectanglePropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT`

The `VkPhysicalDeviceSampleLocationsPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_sample_locations
    typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
        VkStructureType       sType;
        void*                 pNext;
        VkSampleCountFlags    sampleLocationSampleCounts;
        VkExtent2D            maxSampleLocationGridSize;
        float                 sampleLocationCoordinateRange[2];
        uint32_t              sampleLocationSubPixelBits;
        VkBool32              variableSampleLocations;
    } VkPhysicalDeviceSampleLocationsPropertiesEXT;

- `sType` is the type of this structure.

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

- `sampleLocationSampleCounts` is a bitmask of VkSampleCountFlagBits indicating the sample counts supporting custom sample locations.

- `maxSampleLocationGridSize` is the maximum size of the pixel grid in which sample locations can vary that is supported for all sample counts in `sampleLocationSampleCounts`.

- `sampleLocationCoordinateRange`[2] is the range of supported sample location coordinates.

- `sampleLocationSubPixelBits` is the number of bits of subpixel precision for sample locations.

- `variableSampleLocations` specifies whether the sample locations used by all pipelines that will be bound to a command buffer during a subpass must match. If set to `VK_TRUE`, the implementation supports variable sample locations in a subpass. If set to `VK_FALSE`, then the sample locations must stay constant in each subpass.

If the `VkPhysicalDeviceSampleLocationsPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT`

The `VkPhysicalDeviceExternalMemoryHostPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_external_memory_host
    typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkDeviceSize       minImportedHostPointerAlignment;
    } VkPhysicalDeviceExternalMemoryHostPropertiesEXT;

- `sType` is the type of this structure.

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

- `minImportedHostPointerAlignment` is the minimum required alignment, in bytes, for the base address and size of host pointers that can be imported to a Vulkan memory object. The value must be a power of two.

If the `VkPhysicalDeviceExternalMemoryHostPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT`

The `VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX` structure is defined as:

    // Provided by VK_NVX_multiview_per_view_attributes
    typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           perViewPositionAllComponents;
    } VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;

- `sType` is the type of this structure.

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

- `perViewPositionAllComponents` is `VK_TRUE` if the implementation supports per-view position values that differ in components other than the X component.

If the `VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX`

The `VkPhysicalDevicePointClippingProperties` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDevicePointClippingProperties {
        VkStructureType            sType;
        void*                      pNext;
        VkPointClippingBehavior    pointClippingBehavior;
    } VkPhysicalDevicePointClippingProperties;

or the equivalent

    // Provided by VK_KHR_maintenance2
    typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;

- `sType` is the type of this structure.

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

- `pointClippingBehavior` is a VkPointClippingBehavior value specifying the point clipping behavior supported by the implementation.

If the `VkPhysicalDevicePointClippingProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePointClippingProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES`

The `VkPhysicalDeviceSubgroupProperties` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceSubgroupProperties {
        VkStructureType           sType;
        void*                     pNext;
        uint32_t                  subgroupSize;
        VkShaderStageFlags        supportedStages;
        VkSubgroupFeatureFlags    supportedOperations;
        VkBool32                  quadOperationsInAllStages;
    } VkPhysicalDeviceSubgroupProperties;

- `sType` is the type of this structure.

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

- `subgroupSize` is the default number of invocations in each subgroup. `subgroupSize` is at least 1 if any of the physical device’s queues support `VK_QUEUE_GRAPHICS_BIT` or `VK_QUEUE_COMPUTE_BIT`. `subgroupSize` is a power-of-two.

- `supportedStages` is a bitfield of VkShaderStageFlagBits describing the shader stages that group operations with subgroup scope are supported in. `supportedStages` will have the `VK_SHADER_STAGE_COMPUTE_BIT` bit set if any of the physical device’s queues support `VK_QUEUE_COMPUTE_BIT`.

- `supportedOperations` is a bitmask of VkSubgroupFeatureFlagBits specifying the sets of group operations with subgroup scope supported on this device. `supportedOperations` will have the `VK_SUBGROUP_FEATURE_BASIC_BIT` bit set if any of the physical device’s queues support `VK_QUEUE_GRAPHICS_BIT` or `VK_QUEUE_COMPUTE_BIT`.

- `quadOperationsInAllStages` is a boolean specifying whether quad group operations are available in all stages, or are restricted to fragment and compute stages.

If the `VkPhysicalDeviceSubgroupProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

If `supportedOperations` includes `VK_SUBGROUP_FEATURE_QUAD_BIT`, or `shaderSubgroupUniformControlFlow` is enabled, `subgroupSize` must be greater than or equal to 4.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSubgroupProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES`

Bits which can be set in VkPhysicalDeviceSubgroupProperties::`supportedOperations` and VkPhysicalDeviceVulkan11Properties::`subgroupSupportedOperations` to specify supported group operations with subgroup scope are:

    // Provided by VK_VERSION_1_1
    typedef enum VkSubgroupFeatureFlagBits {
        VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,
        VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,
        VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,
        VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,
        VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,
        VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,
        VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
        VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
      // Provided by VK_NV_shader_subgroup_partitioned
        VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
    } VkSubgroupFeatureFlagBits;

- `VK_SUBGROUP_FEATURE_BASIC_BIT` specifies the device will accept SPIR-V shader modules containing the `GroupNonUniform` capability.

- `VK_SUBGROUP_FEATURE_VOTE_BIT` specifies the device will accept SPIR-V shader modules containing the `GroupNonUniformVote` capability.

- `VK_SUBGROUP_FEATURE_ARITHMETIC_BIT` specifies the device will accept SPIR-V shader modules containing the `GroupNonUniformArithmetic` capability.

- `VK_SUBGROUP_FEATURE_BALLOT_BIT` specifies the device will accept SPIR-V shader modules containing the `GroupNonUniformBallot` capability.

- `VK_SUBGROUP_FEATURE_SHUFFLE_BIT` specifies the device will accept SPIR-V shader modules containing the `GroupNonUniformShuffle` capability.

- `VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT` specifies the device will accept SPIR-V shader modules containing the `GroupNonUniformShuffleRelative` capability.

- `VK_SUBGROUP_FEATURE_CLUSTERED_BIT` specifies the device will accept SPIR-V shader modules containing the `GroupNonUniformClustered` capability.

- `VK_SUBGROUP_FEATURE_QUAD_BIT` specifies the device will accept SPIR-V shader modules containing the `GroupNonUniformQuad` capability.

- `VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV` specifies the device will accept SPIR-V shader modules containing the `GroupNonUniformPartitionedNV` capability.

    // Provided by VK_VERSION_1_1
    typedef VkFlags VkSubgroupFeatureFlags;

`VkSubgroupFeatureFlags` is a bitmask type for setting a mask of zero or more VkSubgroupFeatureFlagBits.

The `VkPhysicalDeviceSubgroupSizeControlProperties` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceSubgroupSizeControlProperties {
        VkStructureType       sType;
        void*                 pNext;
        uint32_t              minSubgroupSize;
        uint32_t              maxSubgroupSize;
        uint32_t              maxComputeWorkgroupSubgroups;
        VkShaderStageFlags    requiredSubgroupSizeStages;
    } VkPhysicalDeviceSubgroupSizeControlProperties;

or the equivalent

    // Provided by VK_EXT_subgroup_size_control
    typedef VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;

- `sType` is the type of this structure.

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

- `minSubgroupSize` is the minimum subgroup size supported by this device. `minSubgroupSize` is at least one if any of the physical device’s queues support `VK_QUEUE_GRAPHICS_BIT` or `VK_QUEUE_COMPUTE_BIT`. `minSubgroupSize` is a power-of-two. `minSubgroupSize` is less than or equal to `maxSubgroupSize`. `minSubgroupSize` is less than or equal to `subgroupSize`.

- `maxSubgroupSize` is the maximum subgroup size supported by this device. `maxSubgroupSize` is at least one if any of the physical device’s queues support `VK_QUEUE_GRAPHICS_BIT` or `VK_QUEUE_COMPUTE_BIT`. `maxSubgroupSize` is a power-of-two. `maxSubgroupSize` is greater than or equal to `minSubgroupSize`. `maxSubgroupSize` is greater than or equal to `subgroupSize`.

- `maxComputeWorkgroupSubgroups` is the maximum number of subgroups supported by the implementation within a workgroup.

- `requiredSubgroupSizeStages` is a bitfield of what shader stages support having a required subgroup size specified.

If the `VkPhysicalDeviceSubgroupSizeControlProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

If VkPhysicalDeviceSubgroupProperties::`supportedOperations` includes `VK_SUBGROUP_FEATURE_QUAD_BIT`, `minSubgroupSize` must be greater than or equal to 4.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSubgroupSizeControlProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES`

The `VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_blend_operation_advanced
    typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           advancedBlendMaxColorAttachments;
        VkBool32           advancedBlendIndependentBlend;
        VkBool32           advancedBlendNonPremultipliedSrcColor;
        VkBool32           advancedBlendNonPremultipliedDstColor;
        VkBool32           advancedBlendCorrelatedOverlap;
        VkBool32           advancedBlendAllOperations;
    } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;

- `sType` is the type of this structure.

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

- `advancedBlendMaxColorAttachments` is one greater than the highest color attachment index that can be used in a subpass, for a pipeline that uses an advanced blend operation.

- `advancedBlendIndependentBlend` specifies whether advanced blend operations can vary per-attachment.

- `advancedBlendNonPremultipliedSrcColor` specifies whether the source color can be treated as non-premultiplied. If this is `VK_FALSE`, then VkPipelineColorBlendAdvancedStateCreateInfoEXT::`srcPremultiplied` must be `VK_TRUE`.

- `advancedBlendNonPremultipliedDstColor` specifies whether the destination color can be treated as non-premultiplied. If this is `VK_FALSE`, then VkPipelineColorBlendAdvancedStateCreateInfoEXT::`dstPremultiplied` must be `VK_TRUE`.

- `advancedBlendCorrelatedOverlap` specifies whether the overlap mode can be treated as correlated. If this is `VK_FALSE`, then VkPipelineColorBlendAdvancedStateCreateInfoEXT::`blendOverlap` must be `VK_BLEND_OVERLAP_UNCORRELATED_EXT`.

- `advancedBlendAllOperations` specifies whether all advanced blend operation enums are supported. See the valid usage of VkPipelineColorBlendAttachmentState.

If the `VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT`

The `VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_vertex_attribute_divisor
    typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxVertexAttribDivisor;
    } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;

- `sType` is the type of this structure.

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

- `maxVertexAttribDivisor` is the maximum value of the number of instances that will repeat the value of vertex attribute data when instanced rendering is enabled.

If the `VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT`

The `VkPhysicalDeviceSamplerFilterMinmaxProperties` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           filterMinmaxSingleComponentFormats;
        VkBool32           filterMinmaxImageComponentMapping;
    } VkPhysicalDeviceSamplerFilterMinmaxProperties;

or the equivalent

    // Provided by VK_EXT_sampler_filter_minmax
    typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;

- `sType` is the type of this structure.

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

- `filterMinmaxSingleComponentFormats` is a boolean value indicating whether a minimum set of required formats support min/max filtering.

- `filterMinmaxImageComponentMapping` is a boolean value indicating whether the implementation supports non-identity component mapping of the image when doing min/max filtering.

If the `VkPhysicalDeviceSamplerFilterMinmaxProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

If `filterMinmaxSingleComponentFormats` is `VK_TRUE`, the following formats must support the `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT` feature with `VK_IMAGE_TILING_OPTIMAL`, if they support `VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT`:

- `VK_FORMAT_R8_UNORM`

- `VK_FORMAT_R8_SNORM`

- `VK_FORMAT_R16_UNORM`

- `VK_FORMAT_R16_SNORM`

- `VK_FORMAT_R16_SFLOAT`

- `VK_FORMAT_R32_SFLOAT`

- `VK_FORMAT_D16_UNORM`

- `VK_FORMAT_X8_D24_UNORM_PACK32`

- `VK_FORMAT_D32_SFLOAT`

- `VK_FORMAT_D16_UNORM_S8_UINT`

- `VK_FORMAT_D24_UNORM_S8_UINT`

- `VK_FORMAT_D32_SFLOAT_S8_UINT`

If the format is a depth/stencil format, this bit only specifies that the depth aspect (not the stencil aspect) of an image of this format supports min/max filtering, and that min/max filtering of the depth aspect is supported when depth compare is disabled in the sampler.

If `filterMinmaxImageComponentMapping` is `VK_FALSE` the component mapping of the image view used with min/max filtering must have been created with the `r` component set to the identity swizzle. Only the `r` component of the sampled image value is defined and the other component values are undefined. If `filterMinmaxImageComponentMapping` is `VK_TRUE` this restriction does not apply and image component mapping works as normal.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSamplerFilterMinmaxProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES`

The `VkPhysicalDeviceProtectedMemoryProperties` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceProtectedMemoryProperties {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           protectedNoFault;
    } VkPhysicalDeviceProtectedMemoryProperties;

- `sType` is the type of this structure.

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

- `protectedNoFault` specifies how an implementation behaves when an application attempts to write to unprotected memory in a protected queue operation, read from protected memory in an unprotected queue operation, or perform a query in a protected queue operation. If this limit is `VK_TRUE`, such writes will be discarded or have undefined values written, reads and queries will return undefined values. If this limit is `VK_FALSE`, applications must not perform these operations. See Protected Memory Access Rules for more information.

If the `VkPhysicalDeviceProtectedMemoryProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES`

The `VkPhysicalDeviceMaintenance3Properties` structure is defined as:

    // Provided by VK_VERSION_1_1
    typedef struct VkPhysicalDeviceMaintenance3Properties {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxPerSetDescriptors;
        VkDeviceSize       maxMemoryAllocationSize;
    } VkPhysicalDeviceMaintenance3Properties;

or the equivalent

    // Provided by VK_KHR_maintenance3
    typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;

- `sType` is the type of this structure.

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

- `maxPerSetDescriptors` is a maximum number of descriptors (summed over all descriptor types) in a single descriptor set that is guaranteed to satisfy any implementation-dependent constraints on the size of a descriptor set itself. Applications can query whether a descriptor set that goes beyond this limit is supported using vkGetDescriptorSetLayoutSupport.

- `maxMemoryAllocationSize` is the maximum size of a memory allocation that can be created, even if there is more space available in the heap.

If the `VkPhysicalDeviceMaintenance3Properties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES`

The `VkPhysicalDeviceMaintenance4Properties` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceMaintenance4Properties {
        VkStructureType    sType;
        void*              pNext;
        VkDeviceSize       maxBufferSize;
    } VkPhysicalDeviceMaintenance4Properties;

or the equivalent

    // Provided by VK_KHR_maintenance4
    typedef VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4PropertiesKHR;

- `sType` is the type of this structure.

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

- `maxBufferSize` is the maximum size `VkBuffer` that can be created.

If the `VkPhysicalDeviceMaintenance4Properties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMaintenance4Properties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES`

The `VkPhysicalDeviceMeshShaderPropertiesNV` structure is defined as:

    // Provided by VK_NV_mesh_shader
    typedef struct VkPhysicalDeviceMeshShaderPropertiesNV {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxDrawMeshTasksCount;
        uint32_t           maxTaskWorkGroupInvocations;
        uint32_t           maxTaskWorkGroupSize[3];
        uint32_t           maxTaskTotalMemorySize;
        uint32_t           maxTaskOutputCount;
        uint32_t           maxMeshWorkGroupInvocations;
        uint32_t           maxMeshWorkGroupSize[3];
        uint32_t           maxMeshTotalMemorySize;
        uint32_t           maxMeshOutputVertices;
        uint32_t           maxMeshOutputPrimitives;
        uint32_t           maxMeshMultiviewViewCount;
        uint32_t           meshOutputPerVertexGranularity;
        uint32_t           meshOutputPerPrimitiveGranularity;
    } VkPhysicalDeviceMeshShaderPropertiesNV;

- `sType` is the type of this structure.

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

- `maxDrawMeshTasksCount` is the maximum number of local workgroups that can be launched by a single draw mesh tasks command. See Programmable Mesh Shading.

- `maxTaskWorkGroupInvocations` is the maximum total number of task shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode in shader modules or by the object decorated by the `WorkgroupSize` decoration, must be less than or equal to this limit.

- `maxTaskWorkGroupSize`[3] is the maximum size of a local task workgroup. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The `x`, `y`, and `z` sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode or by the object decorated by the `WorkgroupSize` decoration in shader modules, must be less than or equal to the corresponding limit.

- `maxTaskTotalMemorySize` is the maximum number of bytes that the task shader can use in total for shared and output memory combined.

- `maxTaskOutputCount` is the maximum number of output tasks a single task shader workgroup can emit.

- `maxMeshWorkGroupInvocations` is the maximum total number of mesh shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode in shader modules or by the object decorated by the `WorkgroupSize` decoration, must be less than or equal to this limit.

- `maxMeshWorkGroupSize`[3] is the maximum size of a local mesh workgroup. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The `x`, `y`, and `z` sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode or by the object decorated by the `WorkgroupSize` decoration in shader modules, must be less than or equal to the corresponding limit.

- `maxMeshTotalMemorySize` is the maximum number of bytes that the mesh shader can use in total for shared and output memory combined.

- `maxMeshOutputVertices` is the maximum number of vertices a mesh shader output can store.

- `maxMeshOutputPrimitives` is the maximum number of primitives a mesh shader output can store.

- `maxMeshMultiviewViewCount` is the maximum number of multiview views a mesh shader can use.

- `meshOutputPerVertexGranularity` is the granularity with which mesh vertex outputs are allocated. The value can be used to compute the memory size used by the mesh shader, which must be less than or equal to `maxMeshTotalMemorySize`.

- `meshOutputPerPrimitiveGranularity` is the granularity with which mesh outputs qualified as per-primitive are allocated. The value can be used to compute the memory size used by the mesh shader, which must be less than or equal to `maxMeshTotalMemorySize`.

If the `VkPhysicalDeviceMeshShaderPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMeshShaderPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV`

The `VkPhysicalDeviceMeshShaderPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_mesh_shader
    typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxTaskWorkGroupTotalCount;
        uint32_t           maxTaskWorkGroupCount[3];
        uint32_t           maxTaskWorkGroupInvocations;
        uint32_t           maxTaskWorkGroupSize[3];
        uint32_t           maxTaskPayloadSize;
        uint32_t           maxTaskSharedMemorySize;
        uint32_t           maxTaskPayloadAndSharedMemorySize;
        uint32_t           maxMeshWorkGroupTotalCount;
        uint32_t           maxMeshWorkGroupCount[3];
        uint32_t           maxMeshWorkGroupInvocations;
        uint32_t           maxMeshWorkGroupSize[3];
        uint32_t           maxMeshSharedMemorySize;
        uint32_t           maxMeshPayloadAndSharedMemorySize;
        uint32_t           maxMeshOutputMemorySize;
        uint32_t           maxMeshPayloadAndOutputMemorySize;
        uint32_t           maxMeshOutputComponents;
        uint32_t           maxMeshOutputVertices;
        uint32_t           maxMeshOutputPrimitives;
        uint32_t           maxMeshOutputLayers;
        uint32_t           maxMeshMultiviewViewCount;
        uint32_t           meshOutputPerVertexGranularity;
        uint32_t           meshOutputPerPrimitiveGranularity;
        uint32_t           maxPreferredTaskWorkGroupInvocations;
        uint32_t           maxPreferredMeshWorkGroupInvocations;
        VkBool32           prefersLocalInvocationVertexOutput;
        VkBool32           prefersLocalInvocationPrimitiveOutput;
        VkBool32           prefersCompactVertexOutput;
        VkBool32           prefersCompactPrimitiveOutput;
    } VkPhysicalDeviceMeshShaderPropertiesEXT;

The members of the `VkPhysicalDeviceMeshShaderPropertiesEXT` structure describe the following implementation-dependent limits:

- `sType` is the type of this structure.

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

- `maxTaskWorkGroupTotalCount` is the maximum number of total local workgroups that can be launched by a single mesh tasks drawing command. See Programmable Mesh Shading.

- `maxTaskWorkGroupCount`[3] is the maximum number of local workgroups that can be launched by a single mesh tasks drawing command. These three values represent the maximum number of local workgroups for the X, Y, and Z dimensions, respectively. The workgroup count parameters to the drawing commands must be less than or equal to the corresponding limit. The product of these dimensions must be less than or equal to `maxTaskWorkGroupTotalCount`.

- `maxTaskWorkGroupInvocations` is the maximum total number of task shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode in shader modules or by the object decorated by the `WorkgroupSize` decoration, must be less than or equal to this limit.

- `maxTaskWorkGroupSize`[3] is the maximum size of a local task workgroup, per dimension. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The `x`, `y`, and `z` sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode or by the object decorated by the `WorkgroupSize` decoration in shader modules, must be less than or equal to the corresponding limit.

- `maxTaskPayloadSize` is the maximum total storage size, in bytes, available for variables declared with the `TaskPayloadWorkgroupEXT` storage class in shader modules in the task shader stage.

- `maxTaskSharedMemorySize` is the maximum total storage size, in bytes, available for variables declared with the `Workgroup` storage class in shader modules in the task shader stage.

- `maxTaskPayloadAndSharedMemorySize` is the maximum total storage size, in bytes, available for variables that are declared with the `TaskPayloadWorkgroupEXT` or `Workgroup` storage class, in shader modules in the task shader stage.

- `maxMeshWorkGroupTotalCount` is the maximum number of local output tasks a single task shader workgroup can emit.

- `maxMeshWorkGroupCount`[3] is the maximum number of local output tasks a single task shader workgroup can emit, per dimension. These three values represent the maximum number of local output tasks for the X, Y, and Z dimensions, respectively. The workgroup count parameters to the `OpEmitMeshTasksEXT` must be less than or equal to the corresponding limit. The product of these dimensions must be less than or equal to `maxMeshWorkGroupTotalCount`.

- `maxMeshWorkGroupInvocations` is the maximum total number of mesh shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode in shader modules or by the object decorated by the `WorkgroupSize` decoration, must be less than or equal to this limit.

- `maxMeshWorkGroupSize`[3] is the maximum size of a local mesh workgroup, per dimension. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The `x`, `y`, and `z` sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode or by the object decorated by the `WorkgroupSize` decoration in shader modules, must be less than or equal to the corresponding limit.

- `maxMeshSharedMemorySize` is the maximum total storage size, in bytes, available for variables declared with the `Workgroup` storage class in shader modules in the mesh shader stage.

- `maxMeshPayloadAndSharedMemorySize` is the maximum total storage size, in bytes, available for variables that are declared with the `TaskPayloadWorkgroupEXT` or `Workgroup` storage class in shader modules in the mesh shader stage.

- `maxMeshOutputMemorySize` is the maximum total storage size, in bytes, available for output variables in shader modules in the mesh shader stage, according to the formula in Mesh Shader Output.

- `maxMeshPayloadAndOutputMemorySize` is the maximum total storage size, in bytes, available for variables that are declared with the `TaskPayloadWorkgroupEXT` storage class, or output variables in shader modules in the mesh shader stage, according to the formula in Mesh Shader Output.

- `maxMeshOutputComponents` is the maximum number of components of output variables which can be output from the mesh shader stage.

- `maxMeshOutputVertices` is the maximum number of vertices which can be emitted by a single mesh shader workgroup.

- `maxMeshOutputPrimitives` is the maximum number of primitives which can be emitted by a single mesh shader workgroup.

- `maxMeshOutputLayers` is one greater than the maximum layer index that can be output from the mesh shader stage.

- `maxMeshMultiviewViewCount` is one greater than the maximum view index that can be used by any mesh shader.

- `meshOutputPerVertexGranularity` is the granularity of vertex allocation. The number of output vertices allocated for the mesh shader stage is padded to a multiple of this number. The value can be used to calculate the required storage size for output variables in shader modules in the mesh shader stage, which must be less than or equal to `maxMeshOutputMemorySize`.

- `meshOutputPerPrimitiveGranularity` is the granularity of primitive allocation. The number of output primitives allocated for the mesh shader stage is padded to a multiple of this number. The value can be used to calculate the required storage size for output variables in shader modules in the mesh shader stage, which must be less than or equal to `maxMeshOutputMemorySize`.

- `maxPreferredTaskWorkGroupInvocations` is the maximum number of task shader invocations in a single workgroup that is preferred by the implementation for optimal performance. The value is guaranteed to be a multiple of a supported subgroup size for the task shader stage.

- `maxPreferredMeshWorkGroupInvocations` is the maximum number of mesh shader invocations in a single workgroup that is preferred by the implementation for optimal performance. The value is guaranteed to be a multiple of a supported subgroup size for the mesh shader stage.

- `prefersLocalInvocationVertexOutput` specifies whether writes to the vertex output array in a mesh shader yield best performance when the array index matches `LocalInvocationIndex`.

- `prefersLocalInvocationPrimitiveOutput` specifies whether writes to the primitive output array in a mesh shader yield best performance when the array index matches `LocalInvocationIndex`.

- `prefersCompactVertexOutput` specifies whether output vertices should be compacted after custom culling in the mesh shader for best performance, otherwise keeping the vertices at their original location may be better.

- `prefersCompactPrimitiveOutput` specifies whether output primitives should be compacted after custom culling in the mesh shader for best performance, otherwise the use of `CullPrimitiveEXT` may be better.

If the `VkPhysicalDeviceMeshShaderPropertiesEXT` structure is included in the `pNext` chain of VkPhysicalDeviceProperties2, it is filled with the implementation-dependent limits.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMeshShaderPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT`

The `VkPhysicalDeviceDescriptorIndexingProperties` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceDescriptorIndexingProperties {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxUpdateAfterBindDescriptorsInAllPools;
        VkBool32           shaderUniformBufferArrayNonUniformIndexingNative;
        VkBool32           shaderSampledImageArrayNonUniformIndexingNative;
        VkBool32           shaderStorageBufferArrayNonUniformIndexingNative;
        VkBool32           shaderStorageImageArrayNonUniformIndexingNative;
        VkBool32           shaderInputAttachmentArrayNonUniformIndexingNative;
        VkBool32           robustBufferAccessUpdateAfterBind;
        VkBool32           quadDivergentImplicitLod;
        uint32_t           maxPerStageDescriptorUpdateAfterBindSamplers;
        uint32_t           maxPerStageDescriptorUpdateAfterBindUniformBuffers;
        uint32_t           maxPerStageDescriptorUpdateAfterBindStorageBuffers;
        uint32_t           maxPerStageDescriptorUpdateAfterBindSampledImages;
        uint32_t           maxPerStageDescriptorUpdateAfterBindStorageImages;
        uint32_t           maxPerStageDescriptorUpdateAfterBindInputAttachments;
        uint32_t           maxPerStageUpdateAfterBindResources;
        uint32_t           maxDescriptorSetUpdateAfterBindSamplers;
        uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffers;
        uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
        uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffers;
        uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
        uint32_t           maxDescriptorSetUpdateAfterBindSampledImages;
        uint32_t           maxDescriptorSetUpdateAfterBindStorageImages;
        uint32_t           maxDescriptorSetUpdateAfterBindInputAttachments;
    } VkPhysicalDeviceDescriptorIndexingProperties;

or the equivalent

    // Provided by VK_EXT_descriptor_indexing
    typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT;

- `sType` is the type of this structure.

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

- `maxUpdateAfterBindDescriptorsInAllPools` is the maximum number of descriptors (summed over all descriptor types) that can be created across all pools that are created with the `VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT` bit set. Pool creation may fail when this limit is exceeded, or when the space this limit represents is unable to satisfy a pool creation due to fragmentation.

- `shaderUniformBufferArrayNonUniformIndexingNative` is a boolean value indicating whether uniform buffer descriptors natively support nonuniform indexing. If this is `VK_FALSE`, then a single dynamic instance of an instruction that nonuniformly indexes an array of uniform buffers may execute multiple times in order to access all the descriptors.

- `shaderSampledImageArrayNonUniformIndexingNative` is a boolean value indicating whether sampler and image descriptors natively support nonuniform indexing. If this is `VK_FALSE`, then a single dynamic instance of an instruction that nonuniformly indexes an array of samplers or images may execute multiple times in order to access all the descriptors.

- `shaderStorageBufferArrayNonUniformIndexingNative` is a boolean value indicating whether storage buffer descriptors natively support nonuniform indexing. If this is `VK_FALSE`, then a single dynamic instance of an instruction that nonuniformly indexes an array of storage buffers may execute multiple times in order to access all the descriptors.

- `shaderStorageImageArrayNonUniformIndexingNative` is a boolean value indicating whether storage image descriptors natively support nonuniform indexing. If this is `VK_FALSE`, then a single dynamic instance of an instruction that nonuniformly indexes an array of storage images may execute multiple times in order to access all the descriptors.

- `shaderInputAttachmentArrayNonUniformIndexingNative` is a boolean value indicating whether input attachment descriptors natively support nonuniform indexing. If this is `VK_FALSE`, then a single dynamic instance of an instruction that nonuniformly indexes an array of input attachments may execute multiple times in order to access all the descriptors.

- `robustBufferAccessUpdateAfterBind` is a boolean value indicating whether `robustBufferAccess` can be enabled on a device simultaneously with `descriptorBindingUniformBufferUpdateAfterBind`, `descriptorBindingStorageBufferUpdateAfterBind`, `descriptorBindingUniformTexelBufferUpdateAfterBind`, and/or `descriptorBindingStorageTexelBufferUpdateAfterBind`. If this is `VK_FALSE`, then either `robustBufferAccess` must be disabled or all of these update-after-bind features must be disabled.

- `quadDivergentImplicitLod` is a boolean value indicating whether implicit level of detail calculations for image operations have well-defined results when the image and/or sampler objects used for the instruction are not uniform within a quad. See Derivative Image Operations.

- `maxPerStageDescriptorUpdateAfterBindSamplers` is similar to `maxPerStageDescriptorSamplers` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxPerStageDescriptorUpdateAfterBindUniformBuffers` is similar to `maxPerStageDescriptorUniformBuffers` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxPerStageDescriptorUpdateAfterBindStorageBuffers` is similar to `maxPerStageDescriptorStorageBuffers` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxPerStageDescriptorUpdateAfterBindSampledImages` is similar to `maxPerStageDescriptorSampledImages` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxPerStageDescriptorUpdateAfterBindStorageImages` is similar to `maxPerStageDescriptorStorageImages` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxPerStageDescriptorUpdateAfterBindInputAttachments` is similar to `maxPerStageDescriptorInputAttachments` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxPerStageUpdateAfterBindResources` is similar to `maxPerStageResources` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxDescriptorSetUpdateAfterBindSamplers` is similar to `maxDescriptorSetSamplers` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxDescriptorSetUpdateAfterBindUniformBuffers` is similar to `maxDescriptorSetUniformBuffers` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxDescriptorSetUpdateAfterBindUniformBuffersDynamic` is similar to `maxDescriptorSetUniformBuffersDynamic` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set. While an application can allocate dynamic uniform buffer descriptors from a pool created with the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT`, bindings for these descriptors must not be present in any descriptor set layout that includes bindings created with `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT`.

- `maxDescriptorSetUpdateAfterBindStorageBuffers` is similar to `maxDescriptorSetStorageBuffers` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxDescriptorSetUpdateAfterBindStorageBuffersDynamic` is similar to `maxDescriptorSetStorageBuffersDynamic` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set. While an application can allocate dynamic storage buffer descriptors from a pool created with the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT`, bindings for these descriptors must not be present in any descriptor set layout that includes bindings created with `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT`.

- `maxDescriptorSetUpdateAfterBindSampledImages` is similar to `maxDescriptorSetSampledImages` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxDescriptorSetUpdateAfterBindStorageImages` is similar to `maxDescriptorSetStorageImages` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxDescriptorSetUpdateAfterBindInputAttachments` is similar to `maxDescriptorSetInputAttachments` but counts descriptors from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

If the `VkPhysicalDeviceDescriptorIndexingProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDescriptorIndexingProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES`

The `VkPhysicalDeviceInlineUniformBlockProperties` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceInlineUniformBlockProperties {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxInlineUniformBlockSize;
        uint32_t           maxPerStageDescriptorInlineUniformBlocks;
        uint32_t           maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
        uint32_t           maxDescriptorSetInlineUniformBlocks;
        uint32_t           maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
    } VkPhysicalDeviceInlineUniformBlockProperties;

or the equivalent

    // Provided by VK_EXT_inline_uniform_block
    typedef VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInlineUniformBlockPropertiesEXT;

- `sType` is the type of this structure.

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

- `maxInlineUniformBlockSize` is the maximum size in bytes of an inline uniform block binding.

- `maxPerStageDescriptorInlineUniformBlock` is the maximum number of inline uniform block bindings that can be accessible to a single shader stage in a pipeline layout. Descriptor bindings with a descriptor type of `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK` count against this limit. Only descriptor bindings in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit.

- `maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks` is similar to `maxPerStageDescriptorInlineUniformBlocks` but counts descriptor bindings from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxDescriptorSetInlineUniformBlocks` is the maximum number of inline uniform block bindings that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptor bindings with a descriptor type of `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK` count against this limit. Only descriptor bindings in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit.

- `maxDescriptorSetUpdateAfterBindInlineUniformBlocks` is similar to `maxDescriptorSetInlineUniformBlocks` but counts descriptor bindings from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

If the `VkPhysicalDeviceInlineUniformBlockProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceInlineUniformBlockProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES`

The `VkPhysicalDeviceConservativeRasterizationPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_conservative_rasterization
    typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        float              primitiveOverestimationSize;
        float              maxExtraPrimitiveOverestimationSize;
        float              extraPrimitiveOverestimationSizeGranularity;
        VkBool32           primitiveUnderestimation;
        VkBool32           conservativePointAndLineRasterization;
        VkBool32           degenerateTrianglesRasterized;
        VkBool32           degenerateLinesRasterized;
        VkBool32           fullyCoveredFragmentShaderInputVariable;
        VkBool32           conservativeRasterizationPostDepthCoverage;
    } VkPhysicalDeviceConservativeRasterizationPropertiesEXT;

- `sType` is the type of this structure.

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

- `primitiveOverestimationSize` is the size in pixels the generating primitive is increased at each of its edges during conservative rasterization overestimation mode. Even with a size of 0.0, conservative rasterization overestimation rules still apply and if any part of the pixel rectangle is covered by the generating primitive, fragments are generated for the entire pixel. However implementations may make the pixel coverage area even more conservative by increasing the size of the generating primitive.

- `maxExtraPrimitiveOverestimationSize` is the maximum size in pixels of extra overestimation the implementation supports in the pipeline state. A value of 0.0 means the implementation does not support any additional overestimation of the generating primitive during conservative rasterization. A value above 0.0 allows the application to further increase the size of the generating primitive during conservative rasterization overestimation.

- `extraPrimitiveOverestimationSizeGranularity` is the granularity of extra overestimation that can be specified in the pipeline state between 0.0 and `maxExtraPrimitiveOverestimationSize` inclusive. A value of 0.0 means the implementation can use the smallest representable non-zero value in the screen space pixel fixed-point grid.

- `primitiveUnderestimation` is `VK_TRUE` if the implementation supports the `VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT` conservative rasterization mode in addition to `VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT`. Otherwise the implementation only supports `VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT`.

- `conservativePointAndLineRasterization` is `VK_TRUE` if the implementation supports conservative rasterization of point and line primitives as well as triangle primitives. Otherwise the implementation only supports triangle primitives.

- `degenerateTrianglesRasterized` is `VK_FALSE` if the implementation culls primitives generated from triangles that become zero area after they are quantized to the fixed-point rasterization pixel grid. `degenerateTrianglesRasterized` is `VK_TRUE` if these primitives are not culled and the provoking vertex attributes and depth value are used for the fragments. The primitive area calculation is done on the primitive generated from the clipped triangle if applicable. Zero area primitives are backfacing and the application can enable backface culling if desired.

- `degenerateLinesRasterized` is `VK_FALSE` if the implementation culls lines that become zero length after they are quantized to the fixed-point rasterization pixel grid. `degenerateLinesRasterized` is `VK_TRUE` if zero length lines are not culled and the provoking vertex attributes and depth value are used for the fragments.

- `fullyCoveredFragmentShaderInputVariable` is `VK_TRUE` if the implementation supports the SPIR-V builtin fragment shader input variable `FullyCoveredEXT` specifying that conservative rasterization is enabled and the fragment area is fully covered by the generating primitive.

- `conservativeRasterizationPostDepthCoverage` is `VK_TRUE` if the implementation supports conservative rasterization with the `PostDepthCoverage` execution mode enabled. Otherwise the `PostDepthCoverage` execution mode must not be used when conservative rasterization is enabled.

If the `VkPhysicalDeviceConservativeRasterizationPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT`

The `VkPhysicalDeviceFragmentDensityMapPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_fragment_density_map
    typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkExtent2D         minFragmentDensityTexelSize;
        VkExtent2D         maxFragmentDensityTexelSize;
        VkBool32           fragmentDensityInvocations;
    } VkPhysicalDeviceFragmentDensityMapPropertiesEXT;

- `sType` is the type of this structure.

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

- `minFragmentDensityTexelSize` is the minimum fragment density texel size.

- `maxFragmentDensityTexelSize` is the maximum fragment density texel size.

- `fragmentDensityInvocations` specifies whether the implementation may invoke additional fragment shader invocations for each covered sample.

If the `VkPhysicalDeviceFragmentDensityMapPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentDensityMapPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT`

The `VkPhysicalDeviceFragmentDensityMap2PropertiesEXT` structure is defined as:

    // Provided by VK_EXT_fragment_density_map2
    typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           subsampledLoads;
        VkBool32           subsampledCoarseReconstructionEarlyAccess;
        uint32_t           maxSubsampledArrayLayers;
        uint32_t           maxDescriptorSetSubsampledSamplers;
    } VkPhysicalDeviceFragmentDensityMap2PropertiesEXT;

- `sType` is the type of this structure.

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

- `subsampledLoads` specifies if performing image data read with load operations on subsampled attachments will be resampled to the fragment density of the render pass

- `subsampledCoarseReconstructionEarlyAccess` specifies if performing image data read with samplers created with `flags` containing `VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT` in fragment shader will trigger additional reads during `VK_PIPELINE_STAGE_VERTEX_SHADER_BIT`

- `maxSubsampledArrayLayers` is the maximum number of VkImageView array layers for usages supporting subsampled samplers

- `maxDescriptorSetSubsampledSamplers` is the maximum number of subsampled samplers that can be included in a VkPipelineLayout

If the `VkPhysicalDeviceFragmentDensityMap2PropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentDensityMap2PropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT`

The `VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM` structure is defined as:

    // Provided by VK_QCOM_fragment_density_map_offset
    typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
        VkStructureType    sType;
        void*              pNext;
        VkExtent2D         fragmentDensityOffsetGranularity;
    } VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;

- `sType` is the type of this structure.

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

- `fragmentDensityOffsetGranularity` is the granularity for fragment density offsets.

If the `VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM`

The `VkPhysicalDeviceShaderCorePropertiesAMD` structure is defined as:

    // Provided by VK_AMD_shader_core_properties
    typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           shaderEngineCount;
        uint32_t           shaderArraysPerEngineCount;
        uint32_t           computeUnitsPerShaderArray;
        uint32_t           simdPerComputeUnit;
        uint32_t           wavefrontsPerSimd;
        uint32_t           wavefrontSize;
        uint32_t           sgprsPerSimd;
        uint32_t           minSgprAllocation;
        uint32_t           maxSgprAllocation;
        uint32_t           sgprAllocationGranularity;
        uint32_t           vgprsPerSimd;
        uint32_t           minVgprAllocation;
        uint32_t           maxVgprAllocation;
        uint32_t           vgprAllocationGranularity;
    } VkPhysicalDeviceShaderCorePropertiesAMD;

- `sType` is the type of this structure.

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

- `shaderEngineCount` is an unsigned integer value indicating the number of shader engines found inside the shader core of the physical device.

- `shaderArraysPerEngineCount` is an unsigned integer value indicating the number of shader arrays inside a shader engine. Each shader array has its own scan converter, set of compute units, and a render back end (color and depth attachments). Shader arrays within a shader engine share shader processor input (wave launcher) and shader export (export buffer) units. Currently, a shader engine can have one or two shader arrays.

- `computeUnitsPerShaderArray` is an unsigned integer value indicating the physical number of compute units within a shader array. The active number of compute units in a shader array may be lower. A compute unit houses a set of SIMDs along with a sequencer module and a local data store.

- `simdPerComputeUnit` is an unsigned integer value indicating the number of SIMDs inside a compute unit. Each SIMD processes a single instruction at a time.

- `wavefrontSize` is an unsigned integer value indicating the maximum size of a subgroup.

- `sgprsPerSimd` is an unsigned integer value indicating the number of physical Scalar General Purpose Registers (SGPRs) per SIMD.

- `minSgprAllocation` is an unsigned integer value indicating the minimum number of SGPRs allocated for a wave.

- `maxSgprAllocation` is an unsigned integer value indicating the maximum number of SGPRs allocated for a wave.

- `sgprAllocationGranularity` is an unsigned integer value indicating the granularity of SGPR allocation for a wave.

- `vgprsPerSimd` is an unsigned integer value indicating the number of physical Vector General Purpose Registers (VGPRs) per SIMD.

- `minVgprAllocation` is an unsigned integer value indicating the minimum number of VGPRs allocated for a wave.

- `maxVgprAllocation` is an unsigned integer value indicating the maximum number of VGPRs allocated for a wave.

- `vgprAllocationGranularity` is an unsigned integer value indicating the granularity of VGPR allocation for a wave.

If the `VkPhysicalDeviceShaderCorePropertiesAMD` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD`

The `VkPhysicalDeviceShaderCoreProperties2AMD` structure is defined as:

    // Provided by VK_AMD_shader_core_properties2
    typedef struct VkPhysicalDeviceShaderCoreProperties2AMD {
        VkStructureType                   sType;
        void*                             pNext;
        VkShaderCorePropertiesFlagsAMD    shaderCoreFeatures;
        uint32_t                          activeComputeUnitCount;
    } VkPhysicalDeviceShaderCoreProperties2AMD;

- `sType` is the type of this structure.

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

- `shaderCoreFeatures` is a bitmask of VkShaderCorePropertiesFlagBitsAMD indicating the set of features supported by the shader core.

- `activeComputeUnitCount` is an unsigned integer value indicating the number of compute units that have been enabled.

If the `VkPhysicalDeviceShaderCoreProperties2AMD` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderCoreProperties2AMD-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD`

Bits for this type may be defined by future extensions, or new versions of the `VK_AMD_shader_core_properties2` extension. Possible values of the `flags` member of VkShaderCorePropertiesFlagsAMD are:

    // Provided by VK_AMD_shader_core_properties2
    typedef enum VkShaderCorePropertiesFlagBitsAMD {
    } VkShaderCorePropertiesFlagBitsAMD;

    // Provided by VK_AMD_shader_core_properties2
    typedef VkFlags VkShaderCorePropertiesFlagsAMD;

`VkShaderCorePropertiesFlagsAMD` is a bitmask type for providing zero or more VkShaderCorePropertiesFlagBitsAMD.

The `VkPhysicalDeviceDepthStencilResolveProperties` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceDepthStencilResolveProperties {
        VkStructureType       sType;
        void*                 pNext;
        VkResolveModeFlags    supportedDepthResolveModes;
        VkResolveModeFlags    supportedStencilResolveModes;
        VkBool32              independentResolveNone;
        VkBool32              independentResolve;
    } VkPhysicalDeviceDepthStencilResolveProperties;

or the equivalent

    // Provided by VK_KHR_depth_stencil_resolve
    typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR;

- `sType` is the type of this structure.

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

- `supportedDepthResolveModes` is a bitmask of VkResolveModeFlagBits indicating the set of supported depth resolve modes. `VK_RESOLVE_MODE_SAMPLE_ZERO_BIT` must be included in the set but implementations may support additional modes.

- `supportedStencilResolveModes` is a bitmask of VkResolveModeFlagBits indicating the set of supported stencil resolve modes. `VK_RESOLVE_MODE_SAMPLE_ZERO_BIT` must be included in the set but implementations may support additional modes. `VK_RESOLVE_MODE_AVERAGE_BIT` must not be included in the set.

- `independentResolveNone` is `VK_TRUE` if the implementation supports setting the depth and stencil resolve modes to different values when one of those modes is `VK_RESOLVE_MODE_NONE`. Otherwise the implementation only supports setting both modes to the same value.

- `independentResolve` is `VK_TRUE` if the implementation supports all combinations of the supported depth and stencil resolve modes, including setting either depth or stencil resolve mode to `VK_RESOLVE_MODE_NONE`. An implementation that supports `independentResolve` must also support `independentResolveNone`.

If the `VkPhysicalDeviceDepthStencilResolveProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDepthStencilResolveProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES`

The `VkPhysicalDevicePerformanceQueryPropertiesKHR` structure is defined as:

    // Provided by VK_KHR_performance_query
    typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           allowCommandBufferQueryCopies;
    } VkPhysicalDevicePerformanceQueryPropertiesKHR;

- `sType` is the type of this structure.

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

- `allowCommandBufferQueryCopies` is `VK_TRUE` if the performance query pools are allowed to be used with vkCmdCopyQueryPoolResults.

If the `VkPhysicalDevicePerformanceQueryPropertiesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePerformanceQueryPropertiesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR`

The `VkPhysicalDeviceShadingRateImagePropertiesNV` structure is defined as:

    // Provided by VK_NV_shading_rate_image
    typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV {
        VkStructureType    sType;
        void*              pNext;
        VkExtent2D         shadingRateTexelSize;
        uint32_t           shadingRatePaletteSize;
        uint32_t           shadingRateMaxCoarseSamples;
    } VkPhysicalDeviceShadingRateImagePropertiesNV;

- `sType` is the type of this structure.

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

- `shadingRateTexelSize` indicates the width and height of the portion of the framebuffer corresponding to each texel in the shading rate image.

- `shadingRatePaletteSize` indicates the maximum number of palette entries supported for the shading rate image.

- `shadingRateMaxCoarseSamples` specifies the maximum number of coverage samples supported in a single fragment. If the product of the fragment size derived from the base shading rate and the number of coverage samples per pixel exceeds this limit, the final shading rate will be adjusted so that its product does not exceed the limit.

If the `VkPhysicalDeviceShadingRateImagePropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

These properties are related to the shading rate image feature.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShadingRateImagePropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV`

The `VkPhysicalDeviceMemoryDecompressionPropertiesNV` structure is defined as:

    // Provided by VK_NV_memory_decompression
    typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV {
        VkStructureType                       sType;
        void*                                 pNext;
        VkMemoryDecompressionMethodFlagsNV    decompressionMethods;
        uint64_t                              maxDecompressionIndirectCount;
    } VkPhysicalDeviceMemoryDecompressionPropertiesNV;

- `sType` is the type of this structure.

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

- `decompressionMethods` is a bitmask of VkMemoryDecompressionMethodFlagBitsNV specifying memory decompression methods supported by the implementation.

- `maxDecompressionIndirectCount` specifies the maximum supported count value in the `countBuffer` of vkCmdDecompressMemoryIndirectCountNV

If the `VkPhysicalDeviceMemoryDecompressionPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMemoryDecompressionPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV`

The `VkPhysicalDeviceTransformFeedbackPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_transform_feedback
    typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxTransformFeedbackStreams;
        uint32_t           maxTransformFeedbackBuffers;
        VkDeviceSize       maxTransformFeedbackBufferSize;
        uint32_t           maxTransformFeedbackStreamDataSize;
        uint32_t           maxTransformFeedbackBufferDataSize;
        uint32_t           maxTransformFeedbackBufferDataStride;
        VkBool32           transformFeedbackQueries;
        VkBool32           transformFeedbackStreamsLinesTriangles;
        VkBool32           transformFeedbackRasterizationStreamSelect;
        VkBool32           transformFeedbackDraw;
    } VkPhysicalDeviceTransformFeedbackPropertiesEXT;

- `sType` is the type of this structure.

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

- `maxTransformFeedbackStreams` is the maximum number of vertex streams that can be output from geometry shaders declared with the `GeometryStreams` capability. If the implementation does not support `VkPhysicalDeviceTransformFeedbackFeaturesEXT`::`geometryStreams` then `maxTransformFeedbackStreams` must be set to `1`.

- `maxTransformFeedbackBuffers` is the maximum number of transform feedback buffers that can be bound for capturing shader outputs from the last pre-rasterization shader stage.

- `maxTransformFeedbackBufferSize` is the maximum size that can be specified when binding a buffer for transform feedback in vkCmdBindTransformFeedbackBuffersEXT.

- `maxTransformFeedbackStreamDataSize` is the maximum amount of data in bytes for each vertex that captured to one or more transform feedback buffers associated with a specific vertex stream.

- `maxTransformFeedbackBufferDataSize` is the maximum amount of data in bytes for each vertex that can be captured to a specific transform feedback buffer.

- `maxTransformFeedbackBufferDataStride` is the maximum stride between each capture of vertex data to the buffer.

- `transformFeedbackQueries` is `VK_TRUE` if the implementation supports the `VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT` query type. `transformFeedbackQueries` is `VK_FALSE` if queries of this type cannot be created.

- `transformFeedbackStreamsLinesTriangles` is `VK_TRUE` if the implementation supports the geometry shader `OpExecutionMode` of `OutputLineStrip` and `OutputTriangleStrip` in addition to `OutputPoints` when more than one vertex stream is output. If `transformFeedbackStreamsLinesTriangles` is `VK_FALSE` the implementation only supports an `OpExecutionMode` of `OutputPoints` when more than one vertex stream is output from the geometry shader.

- `transformFeedbackRasterizationStreamSelect` is `VK_TRUE` if the implementation supports the `GeometryStreams` SPIR-V capability and the application can use VkPipelineRasterizationStateStreamCreateInfoEXT to modify which vertex stream output is used for rasterization. Otherwise vertex stream `0` must always be used for rasterization.

- `transformFeedbackDraw` is `VK_TRUE` if the implementation supports the vkCmdDrawIndirectByteCountEXT function otherwise the function must not be called.

If the `VkPhysicalDeviceTransformFeedbackPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceTransformFeedbackPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT`

The `VkPhysicalDeviceCopyMemoryIndirectPropertiesNV` structure is defined as:

    // Provided by VK_NV_copy_memory_indirect
    typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV {
        VkStructureType    sType;
        void*              pNext;
        VkQueueFlags       supportedQueues;
    } VkPhysicalDeviceCopyMemoryIndirectPropertiesNV;

- `sType` is the type of this structure.

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

- `supportedQueues` is a bitmask of VkQueueFlagBits indicating the queues on which indirect copy commands are supported.

If the `indirectCopy` feature is supported, `supportedQueues` must return at least one supported queue.

If the `VkPhysicalDeviceCopyMemoryIndirectPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceCopyMemoryIndirectPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV`

The `VkPhysicalDeviceRayTracingPropertiesNV` structure is defined as:

    // Provided by VK_NV_ray_tracing
    typedef struct VkPhysicalDeviceRayTracingPropertiesNV {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           shaderGroupHandleSize;
        uint32_t           maxRecursionDepth;
        uint32_t           maxShaderGroupStride;
        uint32_t           shaderGroupBaseAlignment;
        uint64_t           maxGeometryCount;
        uint64_t           maxInstanceCount;
        uint64_t           maxTriangleCount;
        uint32_t           maxDescriptorSetAccelerationStructures;
    } VkPhysicalDeviceRayTracingPropertiesNV;

- `sType` is the type of this structure.

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

- `shaderGroupHandleSize` is the size in bytes of the shader header.

- `maxRecursionDepth` is the maximum number of levels of recursion allowed in a trace command.

- `maxShaderGroupStride` is the maximum stride in bytes allowed between shader groups in the shader binding table.

- `shaderGroupBaseAlignment` is the required alignment in bytes for the base of the shader binding table.

- `maxGeometryCount` is the maximum number of geometries in the bottom level acceleration structure.

- `maxInstanceCount` is the maximum number of instances in the top level acceleration structure.

- `maxTriangleCount` is the maximum number of triangles in all geometries in the bottom level acceleration structure.

- `maxDescriptorSetAccelerationStructures` is the maximum number of acceleration structure descriptors that are allowed in a descriptor set.

Due to the fact that the geometry, instance, and triangle counts are specified at acceleration structure creation as 32-bit values, `maxGeometryCount`, `maxInstanceCount`, and `maxTriangleCount` must not exceed 232-1.

If the `VkPhysicalDeviceRayTracingPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Limits specified by this structure must match those specified with the same name in VkPhysicalDeviceAccelerationStructurePropertiesKHR and VkPhysicalDeviceRayTracingPipelinePropertiesKHR.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRayTracingPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV`

The `VkPhysicalDeviceAccelerationStructurePropertiesKHR` structure is defined as:

    // Provided by VK_KHR_acceleration_structure
    typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR {
        VkStructureType    sType;
        void*              pNext;
        uint64_t           maxGeometryCount;
        uint64_t           maxInstanceCount;
        uint64_t           maxPrimitiveCount;
        uint32_t           maxPerStageDescriptorAccelerationStructures;
        uint32_t           maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
        uint32_t           maxDescriptorSetAccelerationStructures;
        uint32_t           maxDescriptorSetUpdateAfterBindAccelerationStructures;
        uint32_t           minAccelerationStructureScratchOffsetAlignment;
    } VkPhysicalDeviceAccelerationStructurePropertiesKHR;

- `sType` is the type of this structure.

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

- `maxGeometryCount` is the maximum number of geometries in the bottom level acceleration structure.

- `maxInstanceCount` is the maximum number of instances in the top level acceleration structure.

- `maxPrimitiveCount` is the maximum number of triangles or AABBs in all geometries in the bottom level acceleration structure.

- `maxPerStageDescriptorAccelerationStructures` is the maximum number of acceleration structure bindings that can be accessible to a single shader stage in a pipeline layout. Descriptor bindings with a descriptor type of `VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR` count against this limit. Only descriptor bindings in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit.

- `maxPerStageDescriptorUpdateAfterBindAccelerationStructures` is similar to `maxPerStageDescriptorAccelerationStructures` but counts descriptor bindings from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `maxDescriptorSetAccelerationStructures` is the maximum number of acceleration structure descriptors that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptor bindings with a descriptor type of `VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR` count against this limit. Only descriptor bindings in descriptor set layouts created without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set count against this limit.

- `maxDescriptorSetUpdateAfterBindAccelerationStructures` is similar to `maxDescriptorSetAccelerationStructures` but counts descriptor bindings from descriptor sets created with or without the `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT` bit set.

- `minAccelerationStructureScratchOffsetAlignment` is the minimum required alignment, in bytes, for scratch data passed in to an acceleration structure build command. The value must be a power of two.

Due to the fact that the geometry, instance, and primitive counts are specified at acceleration structure creation as 32-bit values, `maxGeometryCount`, `maxInstanceCount`, and `maxPrimitiveCount` must not exceed 232-1.

If the `VkPhysicalDeviceAccelerationStructurePropertiesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Limits specified by this structure must match those specified with the same name in VkPhysicalDeviceRayTracingPropertiesNV.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceAccelerationStructurePropertiesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR`

The `VkPhysicalDeviceRayTracingPipelinePropertiesKHR` structure is defined as:

    // Provided by VK_KHR_ray_tracing_pipeline
    typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           shaderGroupHandleSize;
        uint32_t           maxRayRecursionDepth;
        uint32_t           maxShaderGroupStride;
        uint32_t           shaderGroupBaseAlignment;
        uint32_t           shaderGroupHandleCaptureReplaySize;
        uint32_t           maxRayDispatchInvocationCount;
        uint32_t           shaderGroupHandleAlignment;
        uint32_t           maxRayHitAttributeSize;
    } VkPhysicalDeviceRayTracingPipelinePropertiesKHR;

- `sType` is the type of this structure.

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

- `shaderGroupHandleSize` is the size in bytes of the shader header.

- `maxRayRecursionDepth` is the maximum number of levels of ray recursion allowed in a trace command.

- `maxShaderGroupStride` is the maximum stride in bytes allowed between shader groups in the shader binding table.

- `shaderGroupBaseAlignment` is the required alignment in bytes for the base of the shader binding table.

- `shaderGroupHandleCaptureReplaySize` is the number of bytes for the information required to do capture and replay for shader group handles.

- `maxRayDispatchInvocationCount` is the maximum number of ray generation shader invocations which may be produced by a single vkCmdTraceRaysIndirectKHR or vkCmdTraceRaysKHR command.

- `shaderGroupHandleAlignment` is the required alignment in bytes for each shader binding table entry. The value must be a power of two.

- `maxRayHitAttributeSize` is the maximum size in bytes for a ray attribute structure

If the `VkPhysicalDeviceRayTracingPipelinePropertiesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Limits specified by this structure must match those specified with the same name in VkPhysicalDeviceRayTracingPropertiesNV.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRayTracingPipelinePropertiesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR`

The `VkPhysicalDeviceCooperativeMatrixPropertiesNV` structure is defined as:

    // Provided by VK_NV_cooperative_matrix
    typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
        VkStructureType       sType;
        void*                 pNext;
        VkShaderStageFlags    cooperativeMatrixSupportedStages;
    } VkPhysicalDeviceCooperativeMatrixPropertiesNV;

- `sType` is the type of this structure.

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

- `cooperativeMatrixSupportedStages` is a bitfield of VkShaderStageFlagBits describing the shader stages that cooperative matrix instructions are supported in. `cooperativeMatrixSupportedStages` will have the `VK_SHADER_STAGE_COMPUTE_BIT` bit set if any of the physical device’s queues support `VK_QUEUE_COMPUTE_BIT`.

If the `VkPhysicalDeviceCooperativeMatrixPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceCooperativeMatrixPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV`

The `VkPhysicalDeviceCooperativeMatrixPropertiesKHR` structure is defined as:

    // Provided by VK_KHR_cooperative_matrix
    typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR {
        VkStructureType       sType;
        void*                 pNext;
        VkShaderStageFlags    cooperativeMatrixSupportedStages;
    } VkPhysicalDeviceCooperativeMatrixPropertiesKHR;

- `sType` is the type of this structure.

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

- `cooperativeMatrixSupportedStages` is a bitfield of VkShaderStageFlagBits describing the shader stages that cooperative matrix instructions are supported in. `cooperativeMatrixSupportedStages` will have the `VK_SHADER_STAGE_COMPUTE_BIT` bit set if any of the physical device’s queues support `VK_QUEUE_COMPUTE_BIT`.

If the `VkPhysicalDeviceCooperativeMatrixPropertiesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceCooperativeMatrixPropertiesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR`

The `VkPhysicalDeviceShaderSMBuiltinsPropertiesNV` structure is defined as:

    // Provided by VK_NV_shader_sm_builtins
    typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           shaderSMCount;
        uint32_t           shaderWarpsPerSM;
    } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;

- `sType` is the type of this structure.

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

- `shaderSMCount` is the number of SMs on the device.

- `shaderWarpsPerSM` is the maximum number of simultaneously executing warps on an SM.

If the `VkPhysicalDeviceShaderSMBuiltinsPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderSMBuiltinsPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV`

The `VkPhysicalDeviceTexelBufferAlignmentProperties` structure is defined as:

    // Provided by VK_VERSION_1_3
    typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties {
        VkStructureType    sType;
        void*              pNext;
        VkDeviceSize       storageTexelBufferOffsetAlignmentBytes;
        VkBool32           storageTexelBufferOffsetSingleTexelAlignment;
        VkDeviceSize       uniformTexelBufferOffsetAlignmentBytes;
        VkBool32           uniformTexelBufferOffsetSingleTexelAlignment;
    } VkPhysicalDeviceTexelBufferAlignmentProperties;

or the equivalent

    // Provided by VK_EXT_texel_buffer_alignment
    typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;

- `sType` is the type of this structure.

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

- `storageTexelBufferOffsetAlignmentBytes` is a byte alignment that is sufficient for a storage texel buffer of any format. The value must be a power of two.

- `storageTexelBufferOffsetSingleTexelAlignment` indicates whether single texel alignment is sufficient for a storage texel buffer of any format.

- `uniformTexelBufferOffsetAlignmentBytes` is a byte alignment that is sufficient for a uniform texel buffer of any format. The value must be a power of two.

- `uniformTexelBufferOffsetSingleTexelAlignment` indicates whether single texel alignment is sufficient for a uniform texel buffer of any format.

If the `VkPhysicalDeviceTexelBufferAlignmentProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

If the single texel alignment property is `VK_FALSE`, then the buffer view’s offset must be aligned to the corresponding byte alignment value. If the single texel alignment property is `VK_TRUE`, then the buffer view’s offset must be aligned to the lesser of the corresponding byte alignment value or the size of a single texel, based on VkBufferViewCreateInfo::`format`. If the size of a single texel is a multiple of three bytes, then the size of a single component of the format is used instead.

These limits must not advertise a larger alignment than the required maximum minimum value of VkPhysicalDeviceLimits::`minTexelBufferOffsetAlignment`, for any format that supports use as a texel buffer.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceTexelBufferAlignmentProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES`

The `VkPhysicalDeviceTimelineSemaphoreProperties` structure is defined as:

    // Provided by VK_VERSION_1_2
    typedef struct VkPhysicalDeviceTimelineSemaphoreProperties {
        VkStructureType    sType;
        void*              pNext;
        uint64_t           maxTimelineSemaphoreValueDifference;
    } VkPhysicalDeviceTimelineSemaphoreProperties;

or the equivalent

    // Provided by VK_KHR_timeline_semaphore
    typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR;

- `sType` is the type of this structure.

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

- `maxTimelineSemaphoreValueDifference` indicates the maximum difference allowed by the implementation between the current value of a timeline semaphore and any pending signal or wait operations.

If the `VkPhysicalDeviceTimelineSemaphoreProperties` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceTimelineSemaphoreProperties-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES`

The `VkPhysicalDeviceLineRasterizationPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_line_rasterization
    typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           lineSubPixelPrecisionBits;
    } VkPhysicalDeviceLineRasterizationPropertiesEXT;

- `sType` is the type of this structure.

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

- `lineSubPixelPrecisionBits` is the number of bits of subpixel precision in framebuffer coordinates xf and yf when rasterizing line segments.

If the `VkPhysicalDeviceLineRasterizationPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceLineRasterizationPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT`

The `VkPhysicalDeviceRobustness2PropertiesEXT` structure is defined as:

    // Provided by VK_EXT_robustness2
    typedef struct VkPhysicalDeviceRobustness2PropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkDeviceSize       robustStorageBufferAccessSizeAlignment;
        VkDeviceSize       robustUniformBufferAccessSizeAlignment;
    } VkPhysicalDeviceRobustness2PropertiesEXT;

- `sType` is the type of this structure.

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

- `robustStorageBufferAccessSizeAlignment` is the number of bytes that the range of a storage buffer descriptor is rounded up to when used for bounds-checking when the `robustBufferAccess2` feature is enabled. This value must be either 1 or 4.

- `robustUniformBufferAccessSizeAlignment` is the number of bytes that the range of a uniform buffer descriptor is rounded up to when used for bounds-checking when the `robustBufferAccess2` feature is enabled. This value must be a power of two in the range [1, 256].

If the `VkPhysicalDeviceRobustness2PropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRobustness2PropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT`

The `VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV` structure is defined as:

    // Provided by VK_NV_device_generated_commands
    typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxGraphicsShaderGroupCount;
        uint32_t           maxIndirectSequenceCount;
        uint32_t           maxIndirectCommandsTokenCount;
        uint32_t           maxIndirectCommandsStreamCount;
        uint32_t           maxIndirectCommandsTokenOffset;
        uint32_t           maxIndirectCommandsStreamStride;
        uint32_t           minSequencesCountBufferOffsetAlignment;
        uint32_t           minSequencesIndexBufferOffsetAlignment;
        uint32_t           minIndirectCommandsBufferOffsetAlignment;
    } VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV;

- `sType` is the type of this structure.

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

- `maxGraphicsShaderGroupCount` is the maximum number of shader groups in VkGraphicsPipelineShaderGroupsCreateInfoNV.

- `maxIndirectSequenceCount` is the maximum number of sequences in VkGeneratedCommandsInfoNV and in VkGeneratedCommandsMemoryRequirementsInfoNV.

- `maxIndirectCommandsTokenCount` is the maximum number of tokens in VkIndirectCommandsLayoutCreateInfoNV.

- `maxIndirectCommandsStreamCount` is the maximum number of streams in VkIndirectCommandsLayoutCreateInfoNV.

- `maxIndirectCommandsTokenOffset` is the maximum offset in VkIndirectCommandsLayoutTokenNV.

- `maxIndirectCommandsStreamStride` is the maximum stream stride in VkIndirectCommandsLayoutCreateInfoNV.

- `minSequencesCountBufferOffsetAlignment` is the minimum alignment for memory addresses which can be used in VkGeneratedCommandsInfoNV.

- `minSequencesIndexBufferOffsetAlignment` is the minimum alignment for memory addresses which can be used in VkGeneratedCommandsInfoNV.

- `minIndirectCommandsBufferOffsetAlignment` is the minimum alignment for memory addresses used in VkIndirectCommandsStreamNV, and as preprocess buffer in VkGeneratedCommandsInfoNV.

If the `VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV`

The `VkPhysicalDevicePortabilitySubsetPropertiesKHR` structure is defined as:

    // Provided by VK_KHR_portability_subset
    typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           minVertexInputBindingStrideAlignment;
    } VkPhysicalDevicePortabilitySubsetPropertiesKHR;

- `sType` is the type of this structure.

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

- `minVertexInputBindingStrideAlignment` indicates the minimum alignment for vertex input strides. VkVertexInputBindingDescription::`stride` must be a multiple of, and at least as large as, this value. The value must be a power of two.

If the `VkPhysicalDevicePortabilitySubsetPropertiesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePortabilitySubsetPropertiesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR`

The `VkPhysicalDeviceFragmentShadingRatePropertiesKHR` structure is defined as:

    // Provided by VK_KHR_fragment_shading_rate
    typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
        VkStructureType          sType;
        void*                    pNext;
        VkExtent2D               minFragmentShadingRateAttachmentTexelSize;
        VkExtent2D               maxFragmentShadingRateAttachmentTexelSize;
        uint32_t                 maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
        VkBool32                 primitiveFragmentShadingRateWithMultipleViewports;
        VkBool32                 layeredShadingRateAttachments;
        VkBool32                 fragmentShadingRateNonTrivialCombinerOps;
        VkExtent2D               maxFragmentSize;
        uint32_t                 maxFragmentSizeAspectRatio;
        uint32_t                 maxFragmentShadingRateCoverageSamples;
        VkSampleCountFlagBits    maxFragmentShadingRateRasterizationSamples;
        VkBool32                 fragmentShadingRateWithShaderDepthStencilWrites;
        VkBool32                 fragmentShadingRateWithSampleMask;
        VkBool32                 fragmentShadingRateWithShaderSampleMask;
        VkBool32                 fragmentShadingRateWithConservativeRasterization;
        VkBool32                 fragmentShadingRateWithFragmentShaderInterlock;
        VkBool32                 fragmentShadingRateWithCustomSampleLocations;
        VkBool32                 fragmentShadingRateStrictMultiplyCombiner;
    } VkPhysicalDeviceFragmentShadingRatePropertiesKHR;

- `sType` is the type of this structure.

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

- `minFragmentShadingRateAttachmentTexelSize` indicates minimum supported width and height of the portion of the framebuffer corresponding to each texel in a fragment shading rate attachment. Each value must be less than or equal to the values in `maxFragmentShadingRateAttachmentTexelSize`. Each value must be a power-of-two. It must be (0,0) if the `attachmentFragmentShadingRate` feature is not supported.

- `maxFragmentShadingRateAttachmentTexelSize` indicates maximum supported width and height of the portion of the framebuffer corresponding to each texel in a fragment shading rate attachment. Each value must be greater than or equal to the values in `minFragmentShadingRateAttachmentTexelSize`. Each value must be a power-of-two. It must be (0,0) if the `attachmentFragmentShadingRate` feature is not supported.

- `maxFragmentShadingRateAttachmentTexelSizeAspectRatio` indicates the maximum ratio between the width and height of the portion of the framebuffer corresponding to each texel in a fragment shading rate attachment. `maxFragmentShadingRateAttachmentTexelSizeAspectRatio` must be a power-of-two value, and must be less than or equal to max(`maxFragmentShadingRateAttachmentTexelSize.width` / `minFragmentShadingRateAttachmentTexelSize.height`, `maxFragmentShadingRateAttachmentTexelSize.height` / `minFragmentShadingRateAttachmentTexelSize.width`). It must be 0 if the `attachmentFragmentShadingRate` feature is not supported.

- `primitiveFragmentShadingRateWithMultipleViewports` specifies whether the primitive fragment shading rate can be used when multiple viewports are used. If this value is `VK_FALSE`, only a single viewport must be used, and applications must not write to the `ViewportMaskNV` or `ViewportIndex` built-in when setting `PrimitiveShadingRateKHR`. It must be `VK_FALSE` if the `shaderOutputViewportIndex` feature, the `VK_EXT_shader_viewport_index_layer` extension, or the `geometryShader` feature is not supported, or if the `primitiveFragmentShadingRate` feature is not supported.

- `layeredShadingRateAttachments` specifies whether a shading rate attachment image view can be created with multiple layers. If this value is `VK_FALSE`, when creating an image view with a `usage` that includes `VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR`, `layerCount` must be `1`. It must be `VK_FALSE` if the `multiview` feature, the `shaderOutputViewportIndex` feature, the `VK_EXT_shader_viewport_index_layer` extension, or the `geometryShader` feature is not supported, or if the `attachmentFragmentShadingRate` feature is not supported.

- `fragmentShadingRateNonTrivialCombinerOps` specifies whether VkFragmentShadingRateCombinerOpKHR enums other than `VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR` or `VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR` can be used. It must be `VK_FALSE` unless either the `primitiveFragmentShadingRate` or `attachmentFragmentShadingRate` feature is supported.

- `maxFragmentSize` indicates the maximum supported width and height of a fragment. Its `width` and `height` members must both be power-of-two values. This limit is purely informational, and is not validated.

- `maxFragmentSizeAspectRatio` indicates the maximum ratio between the width and height of a fragment. `maxFragmentSizeAspectRatio` must be a power-of-two value, and must be less than or equal to the maximum of the `width` and `height` members of `maxFragmentSize`. This limit is purely informational, and is not validated.

- `maxFragmentShadingRateCoverageSamples` specifies the maximum number of coverage samples supported in a single fragment. `maxFragmentShadingRateCoverageSamples` must be less than or equal to the product of the `width` and `height` members of `maxFragmentSize`, and the sample count reported by `maxFragmentShadingRateRasterizationSamples`. `maxFragmentShadingRateCoverageSamples` must be less than or equal to `maxSampleMaskWords` × 32 if `fragmentShadingRateWithShaderSampleMask` is supported. This limit is purely informational, and is not validated.

- `maxFragmentShadingRateRasterizationSamples` is a VkSampleCountFlagBits value specifying the maximum sample rate supported when a fragment covers multiple pixels. This limit is purely informational, and is not validated.

- `fragmentShadingRateWithShaderDepthStencilWrites` specifies whether the implementation supports writing `FragDepth` or `FragStencilRefEXT` from a fragment shader for multi-pixel fragments. If this value is `VK_FALSE`, writing to those built-ins will clamp the fragment shading rate to (1,1).

- `fragmentShadingRateWithSampleMask` specifies whether the implementation supports setting valid bits of VkPipelineMultisampleStateCreateInfo::`pSampleMask` to `0` for multi-pixel fragments. If this value is `VK_FALSE`, zeroing valid bits in the sample mask will clamp the fragment shading rate to (1,1).

- `fragmentShadingRateWithShaderSampleMask` specifies whether the implementation supports reading or writing `SampleMask` for multi-pixel fragments. If this value is `VK_FALSE`, using that built-in will clamp the fragment shading rate to (1,1).

- `fragmentShadingRateWithConservativeRasterization` specifies whether conservative rasterization is supported for multi-pixel fragments. It must be `VK_FALSE` if `VK_EXT_conservative_rasterization` is not supported. If this value is `VK_FALSE`, using conservative rasterization will clamp the fragment shading rate to (1,1).

- `fragmentShadingRateWithFragmentShaderInterlock` specifies whether fragment shader interlock is supported for multi-pixel fragments. It must be `VK_FALSE` if `VK_EXT_fragment_shader_interlock` is not supported. If this value is `VK_FALSE`, using fragment shader interlock will clamp the fragment shading rate to (1,1).

- `fragmentShadingRateWithCustomSampleLocations` specifies whether custom sample locations are supported for multi-pixel fragments. It must be `VK_FALSE` if `VK_EXT_sample_locations` is not supported. If this value is `VK_FALSE`, using custom sample locations will clamp the fragment shading rate to (1,1).

- `fragmentShadingRateStrictMultiplyCombiner` specifies whether `VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR` accurately performs a multiplication or not. Implementations where this value is `VK_FALSE` will instead combine rates with an addition. If `fragmentShadingRateNonTrivialCombinerOps` is `VK_FALSE`, implementations must report this as `VK_FALSE`. If `fragmentShadingRateNonTrivialCombinerOps` is `VK_TRUE`, implementations should report this as `VK_TRUE`.

| Note Multiplication of the combiner rates using the fragment width/height in linear space is equivalent to an addition of those values in log2 space. Some implementations inadvertently implemented an addition in linear space due to unclear requirements originating outside of this specification. This resulted in `fragmentShadingRateStrictMultiplyCombiner` being added. Fortunately, this only affects situations where a rate of 1 in either dimension is combined with another rate of 1. All other combinations result in the exact same result as if multiplication was performed in linear space due to the clamping logic, and the fact that both the sum and product of 2 and 2 are equal. In many cases, this limit will not affect the correct operation of applications.

If the `VkPhysicalDeviceFragmentShadingRatePropertiesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

These properties are related to fragment shading rates.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentShadingRatePropertiesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR`

The `VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV` structure is defined as:

    // Provided by VK_NV_fragment_shading_rate_enums
    typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
        VkStructureType          sType;
        void*                    pNext;
        VkSampleCountFlagBits    maxFragmentShadingRateInvocationCount;
    } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV;

- `sType` is the type of this structure.

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

- `maxFragmentShadingRateInvocationCount` is a VkSampleCountFlagBits value indicating the maximum number of fragment shader invocations per fragment supported in pipeline, primitive, and attachment fragment shading rates.

If the `VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

These properties are related to fragment shading rates.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV`

- VUID-VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV-maxFragmentShadingRateInvocationCount-parameter
  `maxFragmentShadingRateInvocationCount` must be a valid VkSampleCountFlagBits value

The `VkPhysicalDeviceCustomBorderColorPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_custom_border_color
    typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxCustomBorderColorSamplers;
    } VkPhysicalDeviceCustomBorderColorPropertiesEXT;

- `maxCustomBorderColorSamplers` indicates the maximum number of samplers with custom border colors which can simultaneously exist on a device.

If the `VkPhysicalDeviceCustomBorderColorPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceCustomBorderColorPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT`

The `VkPhysicalDeviceProvokingVertexPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_provoking_vertex
    typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           provokingVertexModePerPipeline;
        VkBool32           transformFeedbackPreservesTriangleFanProvokingVertex;
    } VkPhysicalDeviceProvokingVertexPropertiesEXT;

- `sType` is the type of this structure.

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

- `provokingVertexModePerPipeline` indicates whether the implementation supports graphics pipelines with different provoking vertex modes within the same render pass instance.

- `transformFeedbackPreservesTriangleFanProvokingVertex` indicates whether the implementation can preserve the provoking vertex order when writing triangle fan vertices to transform feedback.

If the `VkPhysicalDeviceProvokingVertexPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceProvokingVertexPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT`

The `VkPhysicalDeviceDescriptorBufferPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_descriptor_buffer
    typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           combinedImageSamplerDescriptorSingleArray;
        VkBool32           bufferlessPushDescriptors;
        VkBool32           allowSamplerImageViewPostSubmitCreation;
        VkDeviceSize       descriptorBufferOffsetAlignment;
        uint32_t           maxDescriptorBufferBindings;
        uint32_t           maxResourceDescriptorBufferBindings;
        uint32_t           maxSamplerDescriptorBufferBindings;
        uint32_t           maxEmbeddedImmutableSamplerBindings;
        uint32_t           maxEmbeddedImmutableSamplers;
        size_t             bufferCaptureReplayDescriptorDataSize;
        size_t             imageCaptureReplayDescriptorDataSize;
        size_t             imageViewCaptureReplayDescriptorDataSize;
        size_t             samplerCaptureReplayDescriptorDataSize;
        size_t             accelerationStructureCaptureReplayDescriptorDataSize;
        size_t             samplerDescriptorSize;
        size_t             combinedImageSamplerDescriptorSize;
        size_t             sampledImageDescriptorSize;
        size_t             storageImageDescriptorSize;
        size_t             uniformTexelBufferDescriptorSize;
        size_t             robustUniformTexelBufferDescriptorSize;
        size_t             storageTexelBufferDescriptorSize;
        size_t             robustStorageTexelBufferDescriptorSize;
        size_t             uniformBufferDescriptorSize;
        size_t             robustUniformBufferDescriptorSize;
        size_t             storageBufferDescriptorSize;
        size_t             robustStorageBufferDescriptorSize;
        size_t             inputAttachmentDescriptorSize;
        size_t             accelerationStructureDescriptorSize;
        VkDeviceSize       maxSamplerDescriptorBufferRange;
        VkDeviceSize       maxResourceDescriptorBufferRange;
        VkDeviceSize       samplerDescriptorBufferAddressSpaceSize;
        VkDeviceSize       resourceDescriptorBufferAddressSpaceSize;
        VkDeviceSize       descriptorBufferAddressSpaceSize;
    } VkPhysicalDeviceDescriptorBufferPropertiesEXT;

- `sType` is the type of this structure.

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

- `combinedImageSamplerDescriptorSingleArray` indicates that the implementation does not require an array of `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER` descriptors to be written into a descriptor buffer as an array of image descriptors, immediately followed by an array of sampler descriptors.

- `bufferlessPushDescriptors` indicates that the implementation does not require a buffer created with `VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT` to be bound when using push descriptors.

- `allowSamplerImageViewPostSubmitCreation` indicates that the implementation does not restrict when the VkSampler or VkImageView objects used to retrieve descriptor data can be created in relation to command buffer submission. If this value is `VK_FALSE`, then the application must create any VkSampler or VkImageView objects whose descriptor data is accessed during the execution of a command buffer, before the vkQueueSubmit , or vkQueueSubmit2, call that submits that command buffer.

- `descriptorBufferOffsetAlignment` indicates the required alignment in bytes when setting offsets into the descriptor buffer.

- `maxDescriptorBufferBindings` indicates the maximum sum total number of descriptor buffers and embedded immutable sampler sets that can be bound.

- `maxResourceDescriptorBufferBindings` indicates the maximum number of resource descriptor buffers that can be bound.

- `maxSamplerDescriptorBufferBindings` indicates the maximum number of sampler descriptor buffers that can be bound.

- `maxEmbeddedImmutableSamplerBindings` indicates the maximum number of embedded immutable sampler sets that can be bound.

- `maxEmbeddedImmutableSamplers` indicates the maximum number of unique immutable samplers in descriptor set layouts created with `VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT`, and pipeline layouts created from them, which can simultaneously exist on a device.

- `bufferCaptureReplayDescriptorDataSize` indicates the maximum size in bytes of the opaque data used for capture and replay with buffers.

- `imageCaptureReplayDescriptorDataSize` indicates the maximum size in bytes of the opaque data used for capture and replay with images.

- `imageViewCaptureReplayDescriptorDataSize` indicates the maximum size in bytes of the opaque data used for capture and replay with image views.

- `samplerCaptureReplayDescriptorDataSize` indicates the maximum size in bytes of the opaque data used for capture and replay with samplers.

- `accelerationStructureCaptureReplayDescriptorDataSize` indicates the maximum size in bytes of the opaque data used for capture and replay with acceleration structures.

- `samplerDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_SAMPLER` descriptor.

- `combinedImageSamplerDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER` descriptor.

- `sampledImageDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE` descriptor.

- `storageImageDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_STORAGE_IMAGE` descriptor.

- `uniformTexelBufferDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER` descriptor if the `robustBufferAccess` feature is not enabled.

- `robustUniformTexelBufferDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER` descriptor if the `robustBufferAccess` feature is enabled.

- `storageTexelBufferDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER` descriptor if the `robustBufferAccess` feature is not enabled.

- `robustStorageTexelBufferDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER` descriptor if the `robustBufferAccess` feature is enabled.

- `uniformBufferDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` descriptor.

- `robustUniformBufferDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER` descriptor if the `robustBufferAccess` feature is enabled.

- `storageBufferDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` descriptor.

- `robustStorageBufferDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER` descriptor if the `robustBufferAccess` feature is enabled.

- `inputAttachmentDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT` descriptor.

- `accelerationStructureDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR` or `VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV` descriptor.

- `maxSamplerDescriptorBufferRange` indicates the maximum range in bytes from the address of a sampler descriptor buffer binding that is accessible to a shader.

- `maxResourceDescriptorBufferRange` indicates the maximum range in bytes from the address of a resource descriptor buffer binding that is accessible to a shader.

- `samplerDescriptorBufferAddressSpaceSize` indicates the total size in bytes of the address space available for descriptor buffers created with `VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT`.

- `resourceDescriptorBufferAddressSpaceSize` indicates the total size in bytes of the address space available for descriptor buffers created with `VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT`.

- `descriptorBufferAddressSpaceSize` indicates the total size in bytes of the address space available for descriptor buffers created with both `VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT` and `VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT`.

A descriptor binding with type `VK_DESCRIPTOR_TYPE_MUTABLE_VALVE` has a descriptor size which is implied by the descriptor types included in the VkMutableDescriptorTypeCreateInfoVALVE::`pDescriptorTypes` list. The descriptor size is equal to the maximum size of any descriptor type included in the `pDescriptorTypes` list.

As there is no way to request robust and non-robust descriptors separately, or specify robust/non-robust descriptors in the set layout, if `robustBufferAccess` is enabled then robust descriptors are always used.

If the `VkPhysicalDeviceDescriptorBufferPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDescriptorBufferPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT`

The `VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_descriptor_buffer
    typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        size_t             combinedImageSamplerDensityMapDescriptorSize;
    } VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;

- `sType` is the type of this structure.

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

- `combinedImageSamplerDensityMapDescriptorSize` indicates the size in bytes of a `VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER` descriptor when creating the descriptor with `VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT` set.

If the `VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT`

The `VkPhysicalDeviceSubpassShadingPropertiesHUAWEI` structure is defined as:

    // Provided by VK_HUAWEI_subpass_shading
    typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxSubpassShadingWorkgroupSizeAspectRatio;
    } VkPhysicalDeviceSubpassShadingPropertiesHUAWEI;

- `sType` is the type of this structure.

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

- `maxSubpassShadingWorkgroupSizeAspectRatio` indicates the maximum ratio between the width and height of the portion of the subpass shading shader workgroup size. `maxSubpassShadingWorkgroupSizeAspectRatio` must be a power-of-two value, and must be less than or equal to max(`WorkgroupSize.x` / `WorkgroupSize.y`, `WorkgroupSize.y` / `WorkgroupSize.x`).

If the `VkPhysicalDeviceSubpassShadingPropertiesHUAWEI` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceSubpassShadingPropertiesHUAWEI-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI`

The `VkPhysicalDeviceMultiDrawPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_multi_draw
    typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxMultiDrawCount;
    } VkPhysicalDeviceMultiDrawPropertiesEXT;

The members of the `VkPhysicalDeviceMultiDrawPropertiesEXT` structure describe the following features:

- `maxMultiDrawCount` indicates the maximum number of draw calls which can be batched into a single multidraw.

If the `VkPhysicalDeviceMultiDrawPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceMultiDrawPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT`

The `VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_graphics_pipeline_library
    typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           graphicsPipelineLibraryFastLinking;
        VkBool32           graphicsPipelineLibraryIndependentInterpolationDecoration;
    } VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;

- `graphicsPipelineLibraryFastLinking` indicates whether fast linking of graphics pipelines is supported. If it is `VK_TRUE`, creating a graphics pipeline entirely from pipeline libraries without `VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT` is comparable in cost to recording a command in a command buffer.

- `graphicsPipelineLibraryIndependentInterpolationDecoration` indicates whether `NoPerspective` and `Flat` interpolation decorations in the last vertex processing stage and the fragment shader are required to match when using graphics pipeline libraries. If it is `VK_TRUE`, the interpolation decorations do not need to match. If it is `VK_FALSE`, these decorations must either be present in both stages or neither stage in order for a given interface variable to match.

If the `VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT`

The `VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR` structure is defined as:

    // Provided by VK_KHR_fragment_shader_barycentric
    typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           triStripVertexOrderIndependentOfProvokingVertex;
    } VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR;

- `triStripVertexOrderIndependentOfProvokingVertex` indicates that the implementation does not change its vertex numbering for triangle strip primitives when the provoking vertex mode is `VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT`, as shown in the last vertex table.

If the `VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR`

The `VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_shader_module_identifier
    typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint8_t            shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
    } VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT;

The members of the `VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT` structure describe the following:

- `shaderModuleIdentifierAlgorithmUUID` is an array of `VK_UUID_SIZE` `uint8_t` values which uniquely represents the algorithm used to compute an identifier in vkGetShaderModuleIdentifierEXT and vkGetShaderModuleCreateInfoIdentifierEXT. Implementations should not change this value in different driver versions if the algorithm used to compute an identifier is the same.

| Note The algorithm UUID may be the same in different ICDs if the algorithms are guaranteed to produce the same results. This may happen in driver stacks which support different kinds of hardware with shared code. Khronos' conformance testing can not guarantee that `shaderModuleIdentifierAlgorithmUUID` values are actually unique, so implementors should make their own best efforts to ensure that their UUID is unlikely to conflict with other implementations which may use a different algorithm. In particular, hard-coded values which easily conflict, such as all-`0` bits, should never be used. Hard-coded values are acceptable if best effort is ensured that the value will not accidentally conflict.

If the `VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT`

The `VkPhysicalDevicePipelineRobustnessPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_pipeline_robustness
    typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT {
        VkStructureType                          sType;
        void*                                    pNext;
        VkPipelineRobustnessBufferBehaviorEXT    defaultRobustnessStorageBuffers;
        VkPipelineRobustnessBufferBehaviorEXT    defaultRobustnessUniformBuffers;
        VkPipelineRobustnessBufferBehaviorEXT    defaultRobustnessVertexInputs;
        VkPipelineRobustnessImageBehaviorEXT     defaultRobustnessImages;
    } VkPhysicalDevicePipelineRobustnessPropertiesEXT;

- `sType` is the type of this structure.

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

- `defaultRobustnessStorageBuffers` describes the behaviour of out of bounds accesses made to storage buffers when no robustness features are enabled

- `defaultRobustnessUniformBuffers` describes the behaviour of out of bounds accesses made to uniform buffers when no robustness features are enabled

- `defaultRobustnessVertexInputs` describes the behaviour of out of bounds accesses made to vertex input attributes when no robustness features are enabled

- `defaultRobustnessImages` describes the behaviour of out of bounds accesses made to images when no robustness features are enabled

Some implementations of Vulkan may be able to guarantee that certain types of accesses are always performed with robustness even when the Vulkan API’s robustness features are not explicitly enabled.

Even when an implementation reports that accesses to a given resource type are robust by default, it remains invalid to make an out of bounds access without requesting the appropriate robustness feature.

If the `VkPhysicalDevicePipelineRobustnessPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDevicePipelineRobustnessPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT`

The `VkPhysicalDeviceExtendedDynamicState3PropertiesEXT` structure is defined as:

    // Provided by VK_EXT_extended_dynamic_state3
    typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkBool32           dynamicPrimitiveTopologyUnrestricted;
    } VkPhysicalDeviceExtendedDynamicState3PropertiesEXT;

- `dynamicPrimitiveTopologyUnrestricted` indicates that the implementation allows `vkCmdSetPrimitiveTopology` to use a different primitive topology class to the one specified in the active graphics pipeline.

If the `VkPhysicalDeviceExtendedDynamicState3PropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceExtendedDynamicState3PropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT`

The `VkPhysicalDeviceOpticalFlowPropertiesNV` structure is defined as:

    // Provided by VK_NV_optical_flow
    typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV {
        VkStructureType                 sType;
        void*                           pNext;
        VkOpticalFlowGridSizeFlagsNV    supportedOutputGridSizes;
        VkOpticalFlowGridSizeFlagsNV    supportedHintGridSizes;
        VkBool32                        hintSupported;
        VkBool32                        costSupported;
        VkBool32                        bidirectionalFlowSupported;
        VkBool32                        globalFlowSupported;
        uint32_t                        minWidth;
        uint32_t                        minHeight;
        uint32_t                        maxWidth;
        uint32_t                        maxHeight;
        uint32_t                        maxNumRegionsOfInterest;
    } VkPhysicalDeviceOpticalFlowPropertiesNV;

- `sType` is the type of this structure.

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

- `supportedOutputGridSizes` are the supported VkOpticalFlowGridSizeFlagsNV which can be specified in `VkOpticalFlowSessionCreateInfoNV`::`outputGridSize`.

- `supportedHintGridSizes` are the supported VkOpticalFlowGridSizeFlagsNV which can be specified in `VkOpticalFlowSessionCreateInfoNV`::`hintGridSize`.

- `hintSupported` is a boolean describing whether using hint flow vector map is supported in an optical flow session.

- `costSupported` is a boolean describing whether cost map generation is supported in an optical flow session.

- `bidirectionalFlowSupported` is a boolean describing whether bi-directional flow generation is supported in an optical flow session.

- `globalFlowSupported` is a boolean describing whether global flow vector map generation is supported in an optical flow session.

- `minWidth` is the minimum width in pixels for images used in an optical flow session.

- `minHeight` is the minimum height in pixels for images used in an optical flow session.

- `maxWidth` is the maximum width in pixels for images used in an optical flow session.

- `maxHeight` is the maximum height in pixels for images used in an optical flow session.

- `maxNumRegionsOfInterest` is the maximum number of regions of interest which can be used in an optical flow session. If this `maxNumRegionsOfInterest` is 0, regions of interest are not supported in an optical flow session.

If the `VkPhysicalDeviceOpticalFlowPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceOpticalFlowPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV`

The `VkPhysicalDeviceOpacityMicromapPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_opacity_micromap
    typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxOpacity2StateSubdivisionLevel;
        uint32_t           maxOpacity4StateSubdivisionLevel;
    } VkPhysicalDeviceOpacityMicromapPropertiesEXT;

- `sType` is the type of this structure.

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

- `maxOpacity2StateSubdivisionLevel` is the maximum allowed `subdivisionLevel` when `format` is `VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT`

- `maxOpacity4StateSubdivisionLevel` is the maximum allowed `subdivisionLevel` when `format` is `VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT`

If the `VkPhysicalDeviceOpacityMicromapPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceOpacityMicromapPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT`

The `VkPhysicalDeviceDisplacementMicromapPropertiesNV` structure is defined as:

    // Provided by VK_NV_displacement_micromap
    typedef struct VkPhysicalDeviceDisplacementMicromapPropertiesNV {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxDisplacementMicromapSubdivisionLevel;
    } VkPhysicalDeviceDisplacementMicromapPropertiesNV;

- `sType` is the type of this structure.

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

- `maxDisplacementMicromapSubdivisionLevel` is the maximum allowed `subdivisionLevel` for displacement micromaps.

If the `VkPhysicalDeviceDisplacementMicromapPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceDisplacementMicromapPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV`

The `VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM` structure is defined as:

    // Provided by VK_ARM_shader_core_builtins
    typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM {
        VkStructureType    sType;
        void*              pNext;
        uint64_t           shaderCoreMask;
        uint32_t           shaderCoreCount;
        uint32_t           shaderWarpsPerCore;
    } VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM;

- `sType` is the type of this structure.

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

- `shaderCoreMask` is a bitfield where each bit set represents the presence of a shader core whose ID is the bit position. The highest ID for any shader core on the device is the position of the most significant bit set.

- `shaderCoreCount` is the number of shader cores on the device.

- `shaderWarpsPerCore` is the maximum number of simultaneously executing warps on a shader core.

If the `VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM`

Values which may be returned in the `rayTracingInvocationReorderReorderingHint` field of `VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV` are:

    // Provided by VK_NV_ray_tracing_invocation_reorder
    typedef enum VkRayTracingInvocationReorderModeNV {
        VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = 0,
        VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = 1,
    } VkRayTracingInvocationReorderModeNV;

- `VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV` indicates that the implementation is likely to not reorder at reorder calls.

- `VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV` indicates that the implementation is likely to reorder at reorder calls.

The `VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV` structure is defined as:

    // Provided by VK_NV_ray_tracing_invocation_reorder
    typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV {
        VkStructureType                        sType;
        void*                                  pNext;
        VkRayTracingInvocationReorderModeNV    rayTracingInvocationReorderReorderingHint;
    } VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV;

- `rayTracingInvocationReorderReorderingHint` is a hint indicating if the implementation will actually reorder at the reorder calls.

| Note Because the extension changes how hits are managed there is a compatibility reason to expose the extension even when an implementation does not have sorting active.

If the `VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV`

The `VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI` structure is defined as:

    // Provided by VK_HUAWEI_cluster_culling_shader
    typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           maxWorkGroupCount[3];
        uint32_t           maxWorkGroupSize[3];
        uint32_t           maxOutputClusterCount;
        VkDeviceSize       indirectBufferOffsetAlignment;
    } VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI;

- `sType` is the type of this structure.

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

- `maxWorkGroupCount`[3] is the maximum number of local workgroups that can be launched by a single command. These three value represent the maximum local workgroup count in the X, Y and Z dimensions, respectively. In the current implementation, the values of Y and Z are both implicitly set as one. groupCountX of DrawCluster command must be less than or equal to maxWorkGroupCount[0].

- `maxWorkGroupSize`[3] is the maximum size of a local workgroup. These three value represent the maximum local workgroup size in the X, Y and Z dimensions, respectively. The x, y and z sizes, as specified by the `LocalSize` or `LocalSizeId` execution mode or by the object decorated by the WorkgroupSize decoration in shader modules, must be less than or equal to the corresponding limit. In the current implementation, the maximum workgroup size of the X dimension is 32, the others are 1.

- `maxOutputClusterCount` is the maximum number of output cluster a single cluster culling shader workgroup can emit.

- `indirectBufferOffsetAlignment` indicates the alignment for cluster drawing command buffer stride. vkCmdDrawClusterIndirectHUAWEI::`offset` must be a multiple of this value.

If the `VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI`

The `VkPhysicalDeviceShaderCorePropertiesARM` structure is defined as:

    // Provided by VK_ARM_shader_core_properties
    typedef struct VkPhysicalDeviceShaderCorePropertiesARM {
        VkStructureType    sType;
        void*              pNext;
        uint32_t           pixelRate;
        uint32_t           texelRate;
        uint32_t           fmaRate;
    } VkPhysicalDeviceShaderCorePropertiesARM;

- `sType` is the type of this structure.

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

- `pixelRate` is an unsigned integer value indicating the maximum number of pixels output per clock per shader core.

- `texelRate` is an unsigned integer value indicating the maximum number of texels per clock per shader core.

- `fmaRate` is an unsigned integer value indicating the maximum number of single-precision fused multiply-add operations per clock per shader core.

If a throughput rate cannot be determined on the physical device, the value `0` will be returned for that rate.

If the `VkPhysicalDeviceShaderCorePropertiesARM` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderCorePropertiesARM-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM`

The `VkPhysicalDeviceShaderObjectPropertiesEXT` structure is defined as:

    // Provided by VK_EXT_shader_object
    typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        uint8_t            shaderBinaryUUID[VK_UUID_SIZE];
        uint32_t           shaderBinaryVersion;
    } VkPhysicalDeviceShaderObjectPropertiesEXT;

- `sType` is the type of this structure.

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

- `shaderBinaryUUID` is an array of `VK_UUID_SIZE` `uint8_t` values representing a universally unique identifier for one or more implementations whose shader binaries are guaranteed to be compatible with each other.

- `shaderBinaryVersion` is an unsigned integer incremented to represent backwards compatible differences between implementations with the same `shaderBinaryUUID`.

The purpose and usage of the values of this structure are described in greater detail in Binary Shader Compatibility.

If the `VkPhysicalDeviceShaderObjectPropertiesEXT` structure is included in the `pNext` chain of the VkPhysicalDeviceProperties2 structure passed to vkGetPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

- VUID-VkPhysicalDeviceShaderObjectPropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT`

### 46.1. Limit Requirements

The following table specifies the required minimum/maximum for all Vulkan graphics implementations. Where a limit corresponds to a fine-grained device feature which is optional, the feature name is listed with two required limits, one when the feature is supported and one when it is not supported. If an implementation supports a feature, the limits reported are the same whether or not the feature is enabled.

Table 56. Required Limit Types
Type | Limit | Feature
--- | --- | ---
`uint32_t` | `maxImageDimension1D` | -
`uint32_t` | `maxImageDimension2D` | -
`uint32_t` | `maxImageDimension3D` | -
`uint32_t` | `maxImageDimensionCube` | -
`uint32_t` | `maxImageArrayLayers` | -
`uint32_t` | `maxTexelBufferElements` | -
`uint32_t` | `maxUniformBufferRange` | -
`uint32_t` | `maxStorageBufferRange` | -
`uint32_t` | `maxPushConstantsSize` | -
`uint32_t` | `maxMemoryAllocationCount` | -
`uint32_t` | `maxSamplerAllocationCount` | -
VkDeviceSize | `bufferImageGranularity` | -
VkDeviceSize | `sparseAddressSpaceSize` | `sparseBinding`
`uint32_t` | `maxBoundDescriptorSets` | -
`uint32_t` | `maxPerStageDescriptorSamplers` | -
`uint32_t` | `maxPerStageDescriptorUniformBuffers` | -
`uint32_t` | `maxPerStageDescriptorStorageBuffers` | -
`uint32_t` | `maxPerStageDescriptorSampledImages` | -
`uint32_t` | `maxPerStageDescriptorStorageImages` | -
`uint32_t` | `maxPerStageDescriptorInputAttachments` | -
`uint32_t` | `maxPerStageResources` | -
`uint32_t` | `maxDescriptorSetSamplers` | -
`uint32_t` | `maxDescriptorSetUniformBuffers` | -
`uint32_t` | `maxDescriptorSetUniformBuffersDynamic` | -
`uint32_t` | `maxDescriptorSetStorageBuffers` | -
`uint32_t` | `maxDescriptorSetStorageBuffersDynamic` | -
`uint32_t` | `maxDescriptorSetSampledImages` | -
`uint32_t` | `maxDescriptorSetStorageImages` | -
`uint32_t` | `maxDescriptorSetInputAttachments` | -
`uint32_t` | `maxVertexInputAttributes` | -
`uint32_t` | `maxVertexInputBindings` | -
`uint32_t` | `maxVertexInputAttributeOffset` | -
`uint32_t` | `maxVertexInputBindingStride` | -
`uint32_t` | `maxVertexOutputComponents` | -
`uint32_t` | `maxTessellationGenerationLevel` | `tessellationShader`
`uint32_t` | `maxTessellationPatchSize` | `tessellationShader`
`uint32_t` | `maxTessellationControlPerVertexInputComponents` | `tessellationShader`
`uint32_t` | `maxTessellationControlPerVertexOutputComponents` | `tessellationShader`
`uint32_t` | `maxTessellationControlPerPatchOutputComponents` | `tessellationShader`
`uint32_t` | `maxTessellationControlTotalOutputComponents` | `tessellationShader`
`uint32_t` | `maxTessellationEvaluationInputComponents` | `tessellationShader`
`uint32_t` | `maxTessellationEvaluationOutputComponents` | `tessellationShader`
`uint32_t` | `maxGeometryShaderInvocations` | `geometryShader`
`uint32_t` | `maxGeometryInputComponents` | `geometryShader`
`uint32_t` | `maxGeometryOutputComponents` | `geometryShader`
`uint32_t` | `maxGeometryOutputVertices` | `geometryShader`
`uint32_t` | `maxGeometryTotalOutputComponents` | `geometryShader`
`uint32_t` | `maxFragmentInputComponents` | -
`uint32_t` | `maxFragmentOutputAttachments` | -
`uint32_t` | `maxFragmentDualSrcAttachments` | `dualSrcBlend`
`uint32_t` | `maxFragmentCombinedOutputResources` | -
`uint32_t` | `maxComputeSharedMemorySize` | -
3 × `uint32_t` | `maxComputeWorkGroupCount` | -
`uint32_t` | `maxComputeWorkGroupInvocations` | -
3 × `uint32_t` | `maxComputeWorkGroupSize` | -
`uint32_t` | `subPixelPrecisionBits` | -
`uint32_t` | `subTexelPrecisionBits` | -
`uint32_t` | `mipmapPrecisionBits` | -
`uint32_t` | `maxDrawIndexedIndexValue` | `fullDrawIndexUint32`
`uint32_t` | `maxDrawIndirectCount` | `multiDrawIndirect`
`float` | `maxSamplerLodBias` | -
`float` | `maxSamplerAnisotropy` | `samplerAnisotropy`
`uint32_t` | `maxViewports` | `multiViewport`
2 × `uint32_t` | `maxViewportDimensions` | -
2 × `float` | `viewportBoundsRange` | -
`uint32_t` | `viewportSubPixelBits` | -
`size_t` | `minMemoryMapAlignment` | -
VkDeviceSize | `minTexelBufferOffsetAlignment` | -
VkDeviceSize | `minUniformBufferOffsetAlignment` | -
VkDeviceSize | `minStorageBufferOffsetAlignment` | -
`int32_t` | `minTexelOffset` | -
`uint32_t` | `maxTexelOffset` | -
`int32_t` | `minTexelGatherOffset` | `shaderImageGatherExtended`
`uint32_t` | `maxTexelGatherOffset` | `shaderImageGatherExtended`
`float` | `minInterpolationOffset` | `sampleRateShading`
`float` | `maxInterpolationOffset` | `sampleRateShading`
`uint32_t` | `subPixelInterpolationOffsetBits` | `sampleRateShading`
`uint32_t` | `maxFramebufferWidth` | -
`uint32_t` | `maxFramebufferHeight` | -
`uint32_t` | `maxFramebufferLayers` | -
VkSampleCountFlags | `framebufferColorSampleCounts` | -
VkSampleCountFlags | `framebufferIntegerColorSampleCounts` | -
VkSampleCountFlags | `framebufferDepthSampleCounts` | -
VkSampleCountFlags | `framebufferStencilSampleCounts` | -
VkSampleCountFlags | `framebufferNoAttachmentsSampleCounts` | -
`uint32_t` | `maxColorAttachments` | -
VkSampleCountFlags | `sampledImageColorSampleCounts` | -
VkSampleCountFlags | `sampledImageIntegerSampleCounts` | -
VkSampleCountFlags | `sampledImageDepthSampleCounts` | -
VkSampleCountFlags | `sampledImageStencilSampleCounts` | -
VkSampleCountFlags | `storageImageSampleCounts` | `shaderStorageImageMultisample`
`uint32_t` | `maxSampleMaskWords` | -
VkBool32 | `timestampComputeAndGraphics` | -
`float` | `timestampPeriod` | -
`uint32_t` | `maxClipDistances` | `shaderClipDistance`
`uint32_t` | `maxCullDistances` | `shaderCullDistance`
`uint32_t` | `maxCombinedClipAndCullDistances` | `shaderCullDistance`
`uint32_t` | `discreteQueuePriorities` | -
2 × `float` | `pointSizeRange` | `largePoints`
2 × `float` | `lineWidthRange` | `wideLines`
`float` | `pointSizeGranularity` | `largePoints`
`float` | `lineWidthGranularity` | `wideLines`
VkBool32 | `strictLines` | -
VkBool32 | `standardSampleLocations` | -
VkDeviceSize | `optimalBufferCopyOffsetAlignment` | -
VkDeviceSize | `optimalBufferCopyRowPitchAlignment` | -
VkDeviceSize | `nonCoherentAtomSize` | -
`uint32_t` | `maxDiscardRectangles` | `VK_EXT_discard_rectangles`
VkBool32 | `filterMinmaxSingleComponentFormats` | ``samplerFilterMinmax`` `VK_EXT_sampler_filter_minmax`
VkBool32 | `filterMinmaxImageComponentMapping` | ``samplerFilterMinmax`` `VK_EXT_sampler_filter_minmax`
VkDeviceSize | `maxBufferSize` | ``maintenance4``
`float` | `primitiveOverestimationSize` | `VK_EXT_conservative_rasterization`
VkBool32 | `maxExtraPrimitiveOverestimationSize` | `VK_EXT_conservative_rasterization`
`float` | `extraPrimitiveOverestimationSizeGranularity` | `VK_EXT_conservative_rasterization`
VkBool32 | `degenerateTriangleRasterized` | `VK_EXT_conservative_rasterization`
`float` | `degenerateLinesRasterized` | `VK_EXT_conservative_rasterization`
VkBool32 | `fullyCoveredFragmentShaderInputVariable` | `VK_EXT_conservative_rasterization`
VkBool32 | `conservativeRasterizationPostDepthCoverage` | `VK_EXT_conservative_rasterization`
`uint32_t` | `maxUpdateAfterBindDescriptorsInAllPools` | ``descriptorIndexing``
VkBool32 | `shaderUniformBufferArrayNonUniformIndexingNative` | -
VkBool32 | `shaderSampledImageArrayNonUniformIndexingNative` | -
VkBool32 | `shaderStorageBufferArrayNonUniformIndexingNative` | -
VkBool32 | `shaderStorageImageArrayNonUniformIndexingNative` | -
VkBool32 | `shaderInputAttachmentArrayNonUniformIndexingNative` | -
`uint32_t` | `maxPerStageDescriptorUpdateAfterBindSamplers` | ``descriptorIndexing``
`uint32_t` | `maxPerStageDescriptorUpdateAfterBindUniformBuffers` | ``descriptorIndexing``
`uint32_t` | `maxPerStageDescriptorUpdateAfterBindStorageBuffers` | ``descriptorIndexing``
`uint32_t` | `maxPerStageDescriptorUpdateAfterBindSampledImages` | ``descriptorIndexing``
`uint32_t` | `maxPerStageDescriptorUpdateAfterBindStorageImages` | ``descriptorIndexing``
`uint32_t` | `maxPerStageDescriptorUpdateAfterBindInputAttachments` | ``descriptorIndexing``
`uint32_t` | `maxPerStageUpdateAfterBindResources` | ``descriptorIndexing``
`uint32_t` | `maxDescriptorSetUpdateAfterBindSamplers` | ``descriptorIndexing``
`uint32_t` | `maxDescriptorSetUpdateAfterBindUniformBuffers` | ``descriptorIndexing``
`uint32_t` | `maxDescriptorSetUpdateAfterBindUniformBuffersDynamic` | ``descriptorIndexing``
`uint32_t` | `maxDescriptorSetUpdateAfterBindStorageBuffers` | ``descriptorIndexing``
`uint32_t` | `maxDescriptorSetUpdateAfterBindStorageBuffersDynamic` | ``descriptorIndexing``
`uint32_t` | `maxDescriptorSetUpdateAfterBindSampledImages` | ``descriptorIndexing``
`uint32_t` | `maxDescriptorSetUpdateAfterBindStorageImages` | ``descriptorIndexing``
`uint32_t` | `maxDescriptorSetUpdateAfterBindInputAttachments` | ``descriptorIndexing``
`uint32_t` | `maxInlineUniformBlockSize` | ``inlineUniformBlock``
`uint32_t` | `maxPerStageDescriptorInlineUniformBlocks` | ``inlineUniformBlock``
`uint32_t` | `maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks` | ``inlineUniformBlock``
`uint32_t` | `maxDescriptorSetInlineUniformBlocks` | ``inlineUniformBlock``
`uint32_t` | `maxDescriptorSetUpdateAfterBindInlineUniformBlocks` | ``inlineUniformBlock``
`uint32_t` | `maxInlineUniformTotalSize` | ``inlineUniformBlock``
`uint32_t` | `maxVertexAttribDivisor` | `VK_EXT_vertex_attribute_divisor`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxDrawMeshTasksCount` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxTaskWorkGroupInvocations` | `VK_NV_mesh_shader`
3 × `uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxTaskWorkGroupSize` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxTaskTotalMemorySize` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxTaskOutputCount` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshWorkGroupInvocations` | `VK_NV_mesh_shader`
3 × `uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshWorkGroupSize` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshTotalMemorySize` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshOutputVertices` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshOutputPrimitives` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshMultiviewViewCount` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`meshOutputPerVertexGranularity` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesNV::`meshOutputPerPrimitiveGranularity` | `VK_NV_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskWorkGroupTotalCount` | `VK_EXT_mesh_shader`
3 × `uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskWorkGroupCount` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskWorkGroupInvocations` | `VK_EXT_mesh_shader`
3 × `uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskWorkGroupSize` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskPayloadSize` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskSharedMemorySize` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskPayloadAndSharedMemorySize` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshWorkGroupTotalCount` | `VK_EXT_mesh_shader`
3 × `uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshWorkGroupCount` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshWorkGroupInvocations` | `VK_EXT_mesh_shader`
3 × `uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshWorkGroupSize` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshSharedMemorySize` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshPayloadAndSharedMemorySize` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputMemorySize` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshPayloadAndOutputMemorySize` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputComponents` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputVertices` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputPrimitives` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputLayers` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshMultiviewViewCount` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`meshOutputPerVertexGranularity` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`meshOutputPerPrimitiveGranularity` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxPreferredTaskWorkGroupInvocations` | `VK_EXT_mesh_shader`
`uint32_t` | VkPhysicalDeviceMeshShaderPropertiesEXT::`maxPreferredMeshWorkGroupInvocations` | `VK_EXT_mesh_shader`
VkBool32 | VkPhysicalDeviceMeshShaderPropertiesEXT::`prefersLocalInvocationVertexOutput` | `VK_EXT_mesh_shader`
VkBool32 | VkPhysicalDeviceMeshShaderPropertiesEXT::`prefersLocalInvocationPrimitiveOutput` | `VK_EXT_mesh_shader`
VkBool32 | VkPhysicalDeviceMeshShaderPropertiesEXT::`prefersCompactVertexOutput` | `VK_EXT_mesh_shader`
VkBool32 | VkPhysicalDeviceMeshShaderPropertiesEXT::`prefersCompactPrimitiveOutput` | `VK_EXT_mesh_shader`
`uint32_t` | `maxTransformFeedbackStreams` | `VK_EXT_transform_feedback`
`uint32_t` | `maxTransformFeedbackBuffers` | `VK_EXT_transform_feedback`
VkDeviceSize | `maxTransformFeedbackBufferSize` | `VK_EXT_transform_feedback`
`uint32_t` | `maxTransformFeedbackStreamDataSize` | `VK_EXT_transform_feedback`
`uint32_t` | `maxTransformFeedbackBufferDataSize` | `VK_EXT_transform_feedback`
`uint32_t` | `maxTransformFeedbackBufferDataStride` | `VK_EXT_transform_feedback`
VkBool32 | `transformFeedbackQueries` | `VK_EXT_transform_feedback`
VkBool32 | `transformFeedbackStreamsLinesTriangles` | `VK_EXT_transform_feedback`
VkBool32 | `transformFeedbackRasterizationStreamSelect` | `VK_EXT_transform_feedback`
VkBool32 | `transformFeedbackDraw` | `VK_EXT_transform_feedback`
VkExtent2D | `minFragmentDensityTexelSize` | ``fragmentDensityMap``
VkExtent2D | `maxFragmentDensityTexelSize` | ``fragmentDensityMap``
VkBool32 | `fragmentDensityInvocations` | ``fragmentDensityMap``
VkBool32 | `subsampledLoads` | `VK_EXT_fragment_density_map2`
VkBool32 | `subsampledCoarseReconstructionEarlyAccess` | `VK_EXT_fragment_density_map2`
`uint32_t` | `maxSubsampledArrayLayers` | `VK_EXT_fragment_density_map2`
`uint32_t` | `maxDescriptorSetSubsampledSamplers` | `VK_EXT_fragment_density_map2`
VkExtent2D | `fragmentDensityOffsetGranularity` | ``fragmentDensityMapOffset``
`uint32_t` | `maxGeometryCount` | `VK_NV_ray_tracing`, `VK_KHR_acceleration_structure`
`uint32_t` | `maxInstanceCount` | `VK_NV_ray_tracing`, `VK_KHR_acceleration_structure`
`uint32_t` | `shaderGroupHandleSize` | `VK_NV_ray_tracing`, `VK_KHR_ray_tracing_pipeline`
`uint32_t` | `maxShaderGroupStride` | `VK_NV_ray_tracing`, `VK_KHR_ray_tracing_pipeline`
`uint32_t` | `shaderGroupBaseAlignment` | `VK_NV_ray_tracing`, `VK_KHR_ray_tracing_pipeline`
`uint32_t` | `maxRecursionDepth` | `VK_NV_ray_tracing`
`uint32_t` | `maxTriangleCount` | `VK_NV_ray_tracing`
`uint32_t` | `maxPerStageDescriptorAccelerationStructures` | `VK_KHR_acceleration_structure`
`uint32_t` | `maxPerStageDescriptorUpdateAfterBindAccelerationStructures` | `VK_KHR_acceleration_structure`
`uint32_t` | `maxDescriptorSetAccelerationStructures` | `VK_NV_ray_tracing`, `VK_KHR_acceleration_structure`
`uint32_t` | `maxDescriptorSetUpdateAfterBindAccelerationStructures` | `VK_KHR_acceleration_structure`
`uint32_t` | `minAccelerationStructureScratchOffsetAlignment` | `VK_KHR_acceleration_structure`
`uint32_t` | `maxRayRecursionDepth` | `VK_KHR_ray_tracing_pipeline`
`uint32_t` | `shaderGroupHandleCaptureReplaySize` | `VK_KHR_ray_tracing_pipeline`
`uint32_t` | `maxRayDispatchInvocationCount` | `VK_KHR_ray_tracing_pipeline`
`uint32_t` | `shaderGroupHandleAlignment` | `VK_KHR_ray_tracing_pipeline`
`uint32_t` | `maxRayHitAttributeSize` | `VK_KHR_ray_tracing_pipeline`
`uint64_t` | `maxTimelineSemaphoreValueDifference` | ``timelineSemaphore``
`uint32_t` | `lineSubPixelPrecisionBits` | `VK_EXT_line_rasterization`
`uint32_t` | `maxCustomBorderColorSamplers` | `VK_EXT_custom_border_color`
VkDeviceSize | `robustStorageBufferAccessSizeAlignment` | `VK_EXT_robustness2`
VkDeviceSize | `robustUniformBufferAccessSizeAlignment` | `VK_EXT_robustness2`
2 × `uint32_t` | `minFragmentShadingRateAttachmentTexelSize` | ``attachmentFragmentShadingRate``
2 × `uint32_t` | `maxFragmentShadingRateAttachmentTexelSize` | ``attachmentFragmentShadingRate``
`uint32_t` | `maxFragmentShadingRateAttachmentTexelSizeAspectRatio` | ``attachmentFragmentShadingRate``
VkBool32 | `primitiveFragmentShadingRateWithMultipleViewports` | ``primitiveFragmentShadingRate``
VkBool32 | `layeredShadingRateAttachments` | ``attachmentFragmentShadingRate``
VkBool32 | `fragmentShadingRateNonTrivialCombinerOps` | ``pipelineFragmentShadingRate``
2 × `uint32_t` | `maxFragmentSize` | ``pipelineFragmentShadingRate``
`uint32_t` | `maxFragmentSizeAspectRatio` | ``pipelineFragmentShadingRate``
`uint32_t` | `maxFragmentShadingRateCoverageSamples` | ``pipelineFragmentShadingRate``
VkSampleCountFlagBits | `maxFragmentShadingRateRasterizationSamples` | ``pipelineFragmentShadingRate``
VkBool32 | `fragmentShadingRateWithShaderDepthStencilWrites` | ``pipelineFragmentShadingRate``
VkBool32 | `fragmentShadingRateWithSampleMask` | ``pipelineFragmentShadingRate``
VkBool32 | `fragmentShadingRateWithShaderSampleMask` | ``pipelineFragmentShadingRate``
VkBool32 | `fragmentShadingRateWithConservativeRasterization` | ``pipelineFragmentShadingRate``
VkBool32 | `fragmentShadingRateWithFragmentShaderInterlock` | ``pipelineFragmentShadingRate``
VkBool32 | `fragmentShadingRateWithCustomSampleLocations` | ``pipelineFragmentShadingRate``
VkBool32 | `fragmentShadingRateStrictMultiplyCombiner` | ``pipelineFragmentShadingRate``
VkSampleCountFlagBits | `maxFragmentShadingRateInvocationCount` | ``supersampleFragmentShadingRates``
VkBool32 | `combinedImageSamplerDescriptorSingleArray` | `VK_EXT_descriptor_buffer`
VkBool32 | `bufferlessPushDescriptors` | `VK_EXT_descriptor_buffer`
VkBool32 | `allowSamplerImageViewPostSubmitCreation` | `VK_EXT_descriptor_buffer`
VkDeviceSize | `descriptorBufferOffsetAlignment` | `VK_EXT_descriptor_buffer`
`uint32_t` | `maxDescriptorBufferBindings` | `VK_EXT_descriptor_buffer`
`uint32_t` | `maxResourceDescriptorBufferBindings` | `VK_EXT_descriptor_buffer`
`uint32_t` | `maxSamplerDescriptorBufferBindings` | `VK_EXT_descriptor_buffer`
`uint32_t` | `maxEmbeddedImmutableSamplerBindings` | `VK_EXT_descriptor_buffer`
`uint32_t` | `maxEmbeddedImmutableSamplers` | `VK_EXT_descriptor_buffer`
`size_t` | `bufferCaptureReplayDescriptorDataSize` | `VK_EXT_descriptor_buffer`
`size_t` | `imageCaptureReplayDescriptorDataSize` | `VK_EXT_descriptor_buffer`
`size_t` | `imageViewCaptureReplayDescriptorDataSize` | `VK_EXT_descriptor_buffer`
`size_t` | `samplerCaptureReplayDescriptorDataSize` | `VK_EXT_descriptor_buffer`
`size_t` | `accelerationStructureCaptureReplayDescriptorDataSize` | `VK_EXT_descriptor_buffer`
`size_t` | `samplerDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `combinedImageSamplerDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `sampledImageDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `storageImageDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `uniformTexelBufferDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `robustUniformTexelBufferDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `storageTexelBufferDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `robustStorageTexelBufferDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `uniformBufferDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `robustUniformBufferDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `storageBufferDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `robustStorageBufferDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `inputAttachmentDescriptorSize` | `VK_EXT_descriptor_buffer`
`size_t` | `accelerationStructureDescriptorSize` | `VK_EXT_descriptor_buffer`
VkDeviceSize | `maxSamplerDescriptorBufferRange` | `VK_EXT_descriptor_buffer`
VkDeviceSize | `maxResourceDescriptorBufferRange` | `VK_EXT_descriptor_buffer`
VkDeviceSize | `samplerDescriptorBufferAddressSpaceSize` | `VK_EXT_descriptor_buffer`
VkDeviceSize | `resourceDescriptorBufferAddressSpaceSize` | `VK_EXT_descriptor_buffer`
VkDeviceSize | `descriptorBufferAddressSpaceSize` | `VK_EXT_descriptor_buffer`
`size_t` | `combinedImageSamplerDensityMapDescriptorSize` | `VK_EXT_descriptor_buffer`
`uint32_t` | `maxSubpassShadingWorkgroupSizeAspectRatio` | ``subpassShading``
VkBool32 | `graphicsPipelineLibraryFastLinking` | ``graphicsPipelineLibrary``
VkBool32 | `graphicsPipelineLibraryIndependentInterpolationDecoration` | ``graphicsPipelineLibrary``
VkBool32 | `triStripVertexOrderIndependentOfProvokingVertex` | -
`uint32_t` | `maxWeightFilterPhases` | ``textureSampleWeighted``
2 × `uint32_t` | `maxWeightFilterDimension` | ``textureSampleWeighted``
2 × `uint32_t` | `maxBlockMatchRegion` | ``textureBlockMatch``
2 × `uint32_t` | `maxBoxFilterBlockSize` | ``textureBoxFilter``
VkBool32 | `dynamicPrimitiveTopologyUnrestricted` | `VK_EXT_extended_dynamic_state3`
`uint32_t` | `maxOpacity2StateSubdivisionLevel` | `VK_EXT_opacity_micromap`
`uint32_t` | `maxOpacity4StateSubdivisionLevel` | `VK_EXT_opacity_micromap`
`uint64_t` | `maxDecompressionIndirectCount` | `VK_NV_memory_decompression`
3 × `uint32_t` | `maxWorkGroupCount` | `VK_HUAWEI_cluster_culling_shader`
3 × `uint32_t` | `maxWorkGroupSize` | `VK_HUAWEI_cluster_culling_shader`
`uint32_t` | `maxOutputClusterCount` | `VK_HUAWEI_cluster_culling_shader`
VkDeviceSize | `indirectBufferOffsetAlignment` | `VK_HUAWEI_cluster_culling_shader`

Table 57. Required Limits
Limit | Unsupported Limit | Supported Limit | Limit Type1
--- | --- | --- | ---
`maxImageDimension1D` | - | 4096 | min
`maxImageDimension2D` | - | 4096 | min
`maxImageDimension3D` | - | 256 | min
`maxImageDimensionCube` | - | 4096 | min
`maxImageArrayLayers` | - | 256 | min
`maxTexelBufferElements` | - | 65536 | min
`maxUniformBufferRange` | - | 16384 | min
`maxStorageBufferRange` | - | 227 | min
`maxPushConstantsSize` | - | 128 | min
`maxMemoryAllocationCount` | - | 4096 | min
`maxSamplerAllocationCount` | - | 4000 | min
`bufferImageGranularity` | - | 131072 | max
`sparseAddressSpaceSize` | 0 | 231 | min
`maxBoundDescriptorSets` | - | 4 | min
`maxPerStageDescriptorSamplers` | - | 16 | min
`maxPerStageDescriptorUniformBuffers` | - | 12 | min
`maxPerStageDescriptorStorageBuffers` | - | 4 | min
`maxPerStageDescriptorSampledImages` | - | 16 | min
`maxPerStageDescriptorStorageImages` | - | 4 | min
`maxPerStageDescriptorInputAttachments` | - | 4 | min
`maxPerStageResources` | - | 128 2 | min
`maxDescriptorSetSamplers` | - | 96 8 | min, n × PerStage
`maxDescriptorSetUniformBuffers` | - | 72 8 | min, n × PerStage
`maxDescriptorSetUniformBuffersDynamic` | - | 8 | min
`maxDescriptorSetStorageBuffers` | - | 24 8 | min, n × PerStage
`maxDescriptorSetStorageBuffersDynamic` | - | 4 | min
`maxDescriptorSetSampledImages` | - | 96 8 | min, n × PerStage
`maxDescriptorSetStorageImages` | - | 24 8 | min, n × PerStage
`maxDescriptorSetInputAttachments` | - | 4 | min
`maxVertexInputAttributes` | - | 16 | min
`maxVertexInputBindings` | - | 16 10 | min
`maxVertexInputAttributeOffset` | - | 2047 | min
`maxVertexInputBindingStride` | - | 2048 | min
`maxVertexOutputComponents` | - | 64 | min
`maxTessellationGenerationLevel` | 0 | 64 | min
`maxTessellationPatchSize` | 0 | 32 | min
`maxTessellationControlPerVertexInputComponents` | 0 | 64 | min
`maxTessellationControlPerVertexOutputComponents` | 0 | 64 | min
`maxTessellationControlPerPatchOutputComponents` | 0 | 120 | min
`maxTessellationControlTotalOutputComponents` | 0 | 2048 | min
`maxTessellationEvaluationInputComponents` | 0 | 64 | min
`maxTessellationEvaluationOutputComponents` | 0 | 64 | min
`maxGeometryShaderInvocations` | 0 | 32 | min
`maxGeometryInputComponents` | 0 | 64 | min
`maxGeometryOutputComponents` | 0 | 64 | min
`maxGeometryOutputVertices` | 0 | 256 | min
`maxGeometryTotalOutputComponents` | 0 | 1024 | min
`maxFragmentInputComponents` | - | 64 | min
`maxFragmentOutputAttachments` | - | 4 | min
`maxFragmentDualSrcAttachments` | 0 | 1 | min
`maxFragmentCombinedOutputResources` | - | 4 | min
`maxComputeSharedMemorySize` | - | 16384 | min
`maxComputeWorkGroupCount` | - | (65535,65535,65535) | min
`maxComputeWorkGroupInvocations` | - | 128 | min
`maxComputeWorkGroupSize` | - | (128,128,64) | min
`subPixelPrecisionBits` | - | 4 | min
`subTexelPrecisionBits` | - | 4 | min
`mipmapPrecisionBits` | - | 4 | min
`maxDrawIndexedIndexValue` | 224-1 | 232-1 | min
`maxDrawIndirectCount` | 1 | 216-1 | min
`maxSamplerLodBias` | - | 2 | min
`maxSamplerAnisotropy` | 1 | 16 | min
`maxViewports` | 1 | 16 | min
`maxViewportDimensions` | - | (4096,4096) 3 | min
`viewportBoundsRange` | - | (-8192,8191) 4 | (max,min)
`viewportSubPixelBits` | - | 0 | min
`minMemoryMapAlignment` | - | 64 | min
`minTexelBufferOffsetAlignment` | - | 256 | max
`minUniformBufferOffsetAlignment` | - | 256 | max
`minStorageBufferOffsetAlignment` | - | 256 | max
`minTexelOffset` | - | -8 | max
`maxTexelOffset` | - | 7 | min
`minTexelGatherOffset` | 0 | -8 | max
`maxTexelGatherOffset` | 0 | 7 | min
`minInterpolationOffset` | 0.0 | -0.5 5 | max
`maxInterpolationOffset` | 0.0 | 0.5 - (1 ULP) 5 | min
`subPixelInterpolationOffsetBits` | 0 | 4 5 | min
`maxFramebufferWidth` | - | 4096 | min
`maxFramebufferHeight` | - | 4096 | min
`maxFramebufferLayers` | - | 256 | min
`framebufferColorSampleCounts` | - | (`VK_SAMPLE_COUNT_1_BIT` | `VK_SAMPLE_COUNT_4_BIT`) | min
`framebufferIntegerColorSampleCounts` | - | (`VK_SAMPLE_COUNT_1_BIT`) | min
`framebufferDepthSampleCounts` | - | (`VK_SAMPLE_COUNT_1_BIT` | `VK_SAMPLE_COUNT_4_BIT`) | min
`framebufferStencilSampleCounts` | - | (`VK_SAMPLE_COUNT_1_BIT` | `VK_SAMPLE_COUNT_4_BIT`) | min
`framebufferNoAttachmentsSampleCounts` | - | (`VK_SAMPLE_COUNT_1_BIT` | `VK_SAMPLE_COUNT_4_BIT`) | min
`maxColorAttachments` | - | 4 | min
`sampledImageColorSampleCounts` | - | (`VK_SAMPLE_COUNT_1_BIT` | `VK_SAMPLE_COUNT_4_BIT`) | min
`sampledImageIntegerSampleCounts` | - | `VK_SAMPLE_COUNT_1_BIT` | min
`sampledImageDepthSampleCounts` | - | (`VK_SAMPLE_COUNT_1_BIT` | `VK_SAMPLE_COUNT_4_BIT`) | min
`sampledImageStencilSampleCounts` | - | (`VK_SAMPLE_COUNT_1_BIT` | `VK_SAMPLE_COUNT_4_BIT`) | min
`storageImageSampleCounts` | `VK_SAMPLE_COUNT_1_BIT` | (`VK_SAMPLE_COUNT_1_BIT` | `VK_SAMPLE_COUNT_4_BIT`) | min
`maxSampleMaskWords` | - | 1 | min
`timestampComputeAndGraphics` | - | - | implementation-dependent
`timestampPeriod` | - | - | duration
`maxClipDistances` | 0 | 8 | min
`maxCullDistances` | 0 | 8 | min
`maxCombinedClipAndCullDistances` | 0 | 8 | min
`discreteQueuePriorities` | - | 2 | min
`pointSizeRange` | (1.0,1.0) | (1.0,64.0 - ULP)6 | (max,min)
`lineWidthRange` | (1.0,1.0) | (1.0,8.0 - ULP)7 | (max,min)
`pointSizeGranularity` | 0.0 | 1.0 6 | max, fixed point increment
`lineWidthGranularity` | 0.0 | 1.0 7 | max, fixed point increment
`strictLines` | - | - | implementation-dependent
`standardSampleLocations` | - | - | implementation-dependent
`optimalBufferCopyOffsetAlignment` | - | - | recommendation
`optimalBufferCopyRowPitchAlignment` | - | - | recommendation
`nonCoherentAtomSize` | - | 256 | max
`maxPushDescriptors` | - | 32 | min
`maxMultiviewViewCount` | - | 6 | min
`maxMultiviewInstanceIndex` | - | 227-1 | min
`maxDiscardRectangles` | 0 | 4 | min
`sampleLocationSampleCounts` | - | `VK_SAMPLE_COUNT_4_BIT` | min
`maxSampleLocationGridSize` | - | (1,1) | min
`sampleLocationCoordinateRange` | - | (0.0, 0.9375) | (max,min)
`sampleLocationSubPixelBits` | - | 4 | min
`variableSampleLocations` | - | false | implementation-dependent
`minImportedHostPointerAlignment` | - | 65536 | max
`perViewPositionAllComponents` | - | - | implementation-dependent
`filterMinmaxSingleComponentFormats` | - | - | implementation-dependent
`filterMinmaxImageComponentMapping` | - | - | implementation-dependent
`advancedBlendMaxColorAttachments` | - | 1 | min
`advancedBlendIndependentBlend` | - | false | implementation-dependent
`advancedBlendNonPremultipliedSrcColor` | - | false | implementation-dependent
`advancedBlendNonPremultipliedDstColor` | - | false | implementation-dependent
`advancedBlendCorrelatedOverlap` | - | false | implementation-dependent
`advancedBlendAllOperations` | - | false | implementation-dependent
`maxPerSetDescriptors` | - | 1024 | min
`maxMemoryAllocationSize` | - | 230 | min
`maxBufferSize` | - | 230 | min
`primitiveOverestimationSize` | - | 0.0 | min
`maxExtraPrimitiveOverestimationSize` | - | 0.0 | min
`extraPrimitiveOverestimationSizeGranularity` | - | 0.0 | min
`primitiveUnderestimation` | - | false | implementation-dependent
`conservativePointAndLineRasterization` | - | false | implementation-dependent
`degenerateTrianglesRasterized` | - | false | implementation-dependent
`degenerateLinesRasterized` | - | false | implementation-dependent
`fullyCoveredFragmentShaderInputVariable` | - | false | implementation-dependent
`conservativeRasterizationPostDepthCoverage` | - | false | implementation-dependent
`maxUpdateAfterBindDescriptorsInAllPools` | 0 | 500000 | min
`shaderUniformBufferArrayNonUniformIndexingNative` | - | false | implementation-dependent
`shaderSampledImageArrayNonUniformIndexingNative` | - | false | implementation-dependent
`shaderStorageBufferArrayNonUniformIndexingNative` | - | false | implementation-dependent
`shaderStorageImageArrayNonUniformIndexingNative` | - | false | implementation-dependent
`shaderInputAttachmentArrayNonUniformIndexingNative` | - | false | implementation-dependent
`maxPerStageDescriptorUpdateAfterBindSamplers` | 09 | 500000 9 | min
`maxPerStageDescriptorUpdateAfterBindUniformBuffers` | 09 | 12 9 | min
`maxPerStageDescriptorUpdateAfterBindStorageBuffers` | 09 | 500000 9 | min
`maxPerStageDescriptorUpdateAfterBindSampledImages` | 09 | 500000 9 | min
`maxPerStageDescriptorUpdateAfterBindStorageImages` | 09 | 500000 9 | min
`maxPerStageDescriptorUpdateAfterBindInputAttachments` | 09 | 4 9 | min
`maxPerStageUpdateAfterBindResources` | 09 | 500000 9 | min
`maxDescriptorSetUpdateAfterBindSamplers` | 09 | 500000 9 | min
`maxDescriptorSetUpdateAfterBindUniformBuffers` | 09 | 72 8 9 | min, n × PerStage
`maxDescriptorSetUpdateAfterBindUniformBuffersDynamic` | 09 | 8 9 | min
`maxDescriptorSetUpdateAfterBindStorageBuffers` | 09 | 500000 9 | min
`maxDescriptorSetUpdateAfterBindStorageBuffersDynamic` | 09 | 4 9 | min
`maxDescriptorSetUpdateAfterBindSampledImages` | 09 | 500000 9 | min
`maxDescriptorSetUpdateAfterBindStorageImages` | 09 | 500000 9 | min
`maxDescriptorSetUpdateAfterBindInputAttachments` | 09 | 4 9 | min
`maxInlineUniformBlockSize` | - | 256 | min
`maxPerStageDescriptorInlineUniformBlocks` | - | 4 | min
`maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks` | - | 4 | min
`maxDescriptorSetInlineUniformBlocks` | - | 4 | min
`maxDescriptorSetUpdateAfterBindInlineUniformBlocks` | - | 4 | min
`maxInlineUniformTotalSize` | - | 256 | min
`maxVertexAttribDivisor` | - | 216-1 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxDrawMeshTasksCount` | - | 216-1 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxTaskWorkGroupInvocations` | - | 32 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxTaskWorkGroupSize` | - | (32,1,1) | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxTaskTotalMemorySize` | - | 16384 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxTaskOutputCount` | - | 216-1 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshWorkGroupInvocations` | - | 32 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshWorkGroupSize` | - | (32,1,1) | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshTotalMemorySize` | - | 16384 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshOutputVertices` | - | 256 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshOutputPrimitives` | - | 256 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`maxMeshMultiviewViewCount` | - | 1 | min
VkPhysicalDeviceMeshShaderPropertiesNV::`meshOutputPerVertexGranularity` | - | - | implementation-dependent
VkPhysicalDeviceMeshShaderPropertiesNV::`meshOutputPerPrimitiveGranularity` | - | - | implementation-dependent
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskWorkGroupTotalCount` | - | 2^22 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskWorkGroupCount` | - | (65535,65535,65535) | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskWorkGroupInvocations` | - | 128 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskWorkGroupSize` | - | (128,128,128) | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskPayloadSize` | - | 16384 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskSharedMemorySize` | - | 32768 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxTaskPayloadAndSharedMemorySize` | - | 32768 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshWorkGroupTotalCount` | - | 2^22 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshWorkGroupCount` | - | (65535,65535,65535) | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshWorkGroupInvocations` | - | 128 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshWorkGroupSize` | - | (128,128,128) | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshSharedMemorySize` | - | 28672 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshPayloadAndSharedMemorySize` | - | 28672 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputMemorySize` | - | 32768 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshPayloadAndOutputMemorySize` | - | 48128 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputComponents` | - | 128 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputVertices` | - | 256 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputPrimitives` | - | 256 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshOutputLayers` | - | 8 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxMeshMultiviewViewCount` | - | 1 | min
VkPhysicalDeviceMeshShaderPropertiesEXT::`meshOutputPerVertexGranularity` | 0 | 32 | max
VkPhysicalDeviceMeshShaderPropertiesEXT::`meshOutputPerPrimitiveGranularity` | 0 | 32 | max
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxPreferredTaskWorkGroupInvocations` | - | - | implementation-dependent
VkPhysicalDeviceMeshShaderPropertiesEXT::`maxPreferredMeshWorkGroupInvocations` | - | - | implementation-dependent
VkPhysicalDeviceMeshShaderPropertiesEXT::`prefersLocalInvocationVertexOutput` | - | - | implementation-dependent
VkPhysicalDeviceMeshShaderPropertiesEXT::`prefersLocalInvocationPrimitiveOutput` | - | - | implementation-dependent
VkPhysicalDeviceMeshShaderPropertiesEXT::`prefersCompactVertexOutput` | - | - | implementation-dependent
VkPhysicalDeviceMeshShaderPropertiesEXT::`prefersCompactPrimitiveOutput` | - | - | implementation-dependent
`maxTransformFeedbackStreams` | - | 1 | min
`maxTransformFeedbackBuffers` | - | 1 | min
`maxTransformFeedbackBufferSize` | - | 227 | min
`maxTransformFeedbackStreamDataSize` | - | 512 | min
`maxTransformFeedbackBufferDataSize` | - | 512 | min
`maxTransformFeedbackBufferDataStride` | - | 512 | min
`transformFeedbackQueries` | - | false | implementation-dependent
`transformFeedbackStreamsLinesTriangles` | - | false | implementation-dependent
`transformFeedbackRasterizationStreamSelect` | - | false | implementation-dependent
`transformFeedbackDraw` | - | false | implementation-dependent
`minFragmentDensityTexelSize` | - | (1,1) | min
`maxFragmentDensityTexelSize` | - | (1,1) | min
`fragmentDensityInvocations` | - | - | implementation-dependent
`subsampledLoads` | true | false | implementation-dependent
`subsampledCoarseReconstructionEarlyAccess` | false | false | implementation-dependent
`maxSubsampledArrayLayers` | 2 | 2 | min
`maxDescriptorSetSubsampledSamplers` | 1 | 1 | min
`fragmentDensityOffsetGranularity` | - | (1024,1024) | max
VkPhysicalDeviceRayTracingPropertiesNV::`shaderGroupHandleSize` | - | 16 | min
VkPhysicalDeviceRayTracingPropertiesNV::`maxRecursionDepth` | - | 31 | min
VkPhysicalDeviceRayTracingPipelinePropertiesKHR::`shaderGroupHandleSize` | - | 32 | exact
VkPhysicalDeviceRayTracingPipelinePropertiesKHR::`maxRayRecursionDepth` | - | 1 | min
`maxShaderGroupStride` | - | 4096 | min
`shaderGroupBaseAlignment` | - | 64 | max
`maxGeometryCount` | - | 224-1 | min
`maxInstanceCount` | - | 224-1 | min
`maxTriangleCount` | - | 229-1 | min
`maxPrimitiveCount` | - | 229-1 | min
`maxPerStageDescriptorAccelerationStructures` | - | 16 | min
`maxPerStageDescriptorUpdateAfterBindAccelerationStructures` | - | 500000 9 | min
`maxDescriptorSetAccelerationStructures` | - | 16 | min
`maxDescriptorSetUpdateAfterBindAccelerationStructures` | - | 500000 9 | min
`minAccelerationStructureScratchOffsetAlignment` | - | 256 | max
`shaderGroupHandleCaptureReplaySize` | - | 64 | max
`maxRayDispatchInvocationCount` | - | 230 | min
`shaderGroupHandleAlignment` | - | 32 | max
`maxRayHitAttributeSize` | - | 32 | min
`maxTimelineSemaphoreValueDifference` | - | 231-1 | min
`lineSubPixelPrecisionBits` | - | 4 | min
`maxGraphicsShaderGroupCount` | - | 212 | min
`maxIndirectSequenceCount` | - | 220 | min
`maxIndirectCommandsTokenCount` | - | 16 | min
`maxIndirectCommandsStreamCount` | - | 16 | min
`maxIndirectCommandsTokenOffset` | - | 2047 | min
`maxIndirectCommandsStreamStride` | - | 2048 | min
`minSequencesCountBufferOffsetAlignment` | - | 256 | max
`minSequencesIndexBufferOffsetAlignment` | - | 256 | max
`minIndirectCommandsBufferOffsetAlignment` | - | 256 | max
`maxCustomBorderColorSamplers` | - | 32 | min
`robustStorageBufferAccessSizeAlignment` | - | 4 | max
`robustUniformBufferAccessSizeAlignment` | - | 256 | max
`minFragmentShadingRateAttachmentTexelSize` | (0,0) | (32,32) | max
`maxFragmentShadingRateAttachmentTexelSize` | (0,0) | (8,8) | min
`maxFragmentShadingRateAttachmentTexelSizeAspectRatio` | 0 | 1 | min
`primitiveFragmentShadingRateWithMultipleViewports` | false | false | implementation-dependent
`layeredShadingRateAttachments` | false | false | implementation-dependent
`fragmentShadingRateNonTrivialCombinerOps` | - | false | implementation-dependent
`maxFragmentSize` | - | (2,2) | min
`maxFragmentSizeAspectRatio` | - | 2 | min
`maxFragmentShadingRateCoverageSamples` | - | 16 | min
`maxFragmentShadingRateRasterizationSamples` | - | `VK_SAMPLE_COUNT_4_BIT` | min
`fragmentShadingRateWithShaderDepthStencilWrites` | - | false | implementation-dependent
`fragmentShadingRateWithSampleMask` | - | false | implementation-dependent
`fragmentShadingRateWithShaderSampleMask` | - | false | implementation-dependent
`fragmentShadingRateWithConservativeRasterization` | - | false | implementation-dependent
`fragmentShadingRateWithFragmentShaderInterlock` | - | false | implementation-dependent
`fragmentShadingRateWithCustomSampleLocations` | - | false | implementation-dependent
`fragmentShadingRateStrictMultiplyCombiner` | - | false | implementation-dependent
`maxFragmentShadingRateInvocationCount` | - | `VK_SAMPLE_COUNT_4_BIT` | min
`combinedImageSamplerDescriptorSingleArray` | - | false | implementation-dependent
`bufferlessPushDescriptors` | - | false | implementation-dependent
`allowSamplerImageViewPostSubmitCreation` | - | false | implementation-dependent
`descriptorBufferOffsetAlignment` | - | 256 | max
`maxDescriptorBufferBindings` | - | 3 | min
`maxResourceDescriptorBufferBindings` | - | 1 | min
`maxSamplerDescriptorBufferBindings` | - | 1 | min
`maxEmbeddedImmutableSamplerBindings` | - | 1 | min
`maxEmbeddedImmutableSamplers` | - | 2032 | min
`bufferCaptureReplayDescriptorDataSize` | - | 64 | max
`imageCaptureReplayDescriptorDataSize` | - | 64 | max
`imageViewCaptureReplayDescriptorDataSize` | - | 64 | max
`samplerCaptureReplayDescriptorDataSize` | - | 64 | max
`accelerationStructureCaptureReplayDescriptorDataSize` | - | 64 | max
`samplerDescriptorSize` | - | 256 | max
`combinedImageSamplerDescriptorSize` | - | 256 | max
`sampledImageDescriptorSize` | - | 256 | max
`storageImageDescriptorSize` | - | 256 | max
`uniformTexelBufferDescriptorSize` | - | 256 | max
`robustUniformTexelBufferDescriptorSize` | - | 256 | max
`storageTexelBufferDescriptorSize` | - | 256 | max
`robustStorageTexelBufferDescriptorSize` | - | 256 | max
`uniformBufferDescriptorSize` | - | 256 | max
`robustUniformBufferDescriptorSize` | - | 256 | max
`storageBufferDescriptorSize` | - | 256 | max
`robustStorageBufferDescriptorSize` | - | 256 | max
`inputAttachmentDescriptorSize` | - | 256 | max
`accelerationStructureDescriptorSize` | - | 256 | max
`maxSamplerDescriptorBufferRange` | - | 211 × `samplerDescriptorSize` | min
`maxResourceDescriptorBufferRange` | - | (220 - 215) × `maxResourceDescriptorSize` 12 | min
`samplerDescriptorBufferAddressSpaceSize` | - | 227 | min
`resourceDescriptorBufferAddressSpaceSize` | - | 227 | min
`descriptorBufferAddressSpaceSize` | - | 227 | min
`combinedImageSamplerDensityMapDescriptorSize` | - | 256 | max
`maxSubpassShadingWorkgroupSizeAspectRatio` | 0 | 1 | min
`maxMultiDrawCount` | - | 1024 | min
`graphicsPipelineLibraryFastLinking` | - | false | implementation-dependent
`graphicsPipelineLibraryIndependentInterpolationDecoration` | - | false | implementation-dependent
`triStripVertexOrderIndependentOfProvokingVertex` | - | false | implementation-dependent
`maxWeightFilterPhases` | - | 1024 | min
`maxWeightFilterDimension` | - | (64,64) | min
`maxBlockMatchRegion` | - | (64,64) | min
`maxBoxFilterBlockSize` | - | (64,64) | min
`dynamicPrimitiveTopologyUnrestricted` | - | - | implementation-dependent
`maxOpacity2StateSubdivisionLevel` | - | 3 | min
`maxOpacity4StateSubdivisionLevel` | - | 3 | min
`maxDecompressionIndirectCount` | 1 | 216-1 | min
`maxWorkGroupCount` | - | (65536,1,1) | min
`maxWorkGroupSize` | - | (32,1,1) | min
`maxOutputClusterCount` | - | 1024 | min
`indirectBufferOffsetAlignment` | - | - | implementation-dependent

1

  The Limit Type column specifies the limit is either the minimum limit all implementations must support, the maximum limit all implementations must support, or the exact value all implementations must support. For bitmasks a minimum limit is the least bits all implementations must set, but they may have additional bits set beyond this minimum.

2

  The `maxPerStageResources` must be at least the smallest of the following:

  - the sum of the `maxPerStageDescriptorUniformBuffers`, `maxPerStageDescriptorStorageBuffers`, `maxPerStageDescriptorSampledImages`, `maxPerStageDescriptorStorageImages`, `maxPerStageDescriptorInputAttachments`, `maxColorAttachments` limits, or

  - 128.

  It may not be possible to reach this limit in every stage.

3

  See `maxViewportDimensions` for the required relationship to other limits.

4

  See `viewportBoundsRange` for the required relationship to other limits.

5

  The values `minInterpolationOffset` and `maxInterpolationOffset` describe the closed interval of supported interpolation offsets: [`minInterpolationOffset`, `maxInterpolationOffset`]. The ULP is determined by `subPixelInterpolationOffsetBits`. If `subPixelInterpolationOffsetBits` is 4, this provides increments of (1/24) = 0.0625, and thus the range of supported interpolation offsets would be [-0.5, 0.4375].

6

  The point size ULP is determined by `pointSizeGranularity`. If the `pointSizeGranularity` is 0.125, the range of supported point sizes must be at least [1.0, 63.875].

7

  The line width ULP is determined by `lineWidthGranularity`. If the `lineWidthGranularity` is 0.0625, the range of supported line widths must be at least [1.0, 7.9375].

8

  The minimum `maxDescriptorSet*` limit is n times the corresponding specification minimum `maxPerStageDescriptor*` limit, where n is the number of shader stages supported by the VkPhysicalDevice. If all shader stages are supported, n = 6 (vertex, tessellation control, tessellation evaluation, geometry, fragment, compute).

9

  The `UpdateAfterBind` descriptor limits must each be greater than or equal to the corresponding `non`-UpdateAfterBind limit.

10

  If the `VK_KHR_portability_subset` extension is enabled, the required minimum value of `maxVertexInputBindings` is `8`.

12

  `maxResourceDescriptorSize` is defined as the maximum value of `storageImageDescriptorSize`, `sampledImageDescriptorSize`, `robustUniformTexelBufferDescriptorSize`, `robustStorageTexelBufferDescriptorSize`, `robustUniformBufferDescriptorSize`, `robustStorageBufferDescriptorSize`, `inputAttachmentDescriptorSize`, and `accelerationStructureDescriptorSize`.

### 46.2. Additional Multisampling Capabilities

To query additional multisampling capabilities which may be supported for a specific sample count, beyond the minimum capabilities described for Limits above, call:

    // Provided by VK_EXT_sample_locations
    void vkGetPhysicalDeviceMultisamplePropertiesEXT(
        VkPhysicalDevice                            physicalDevice,
        VkSampleCountFlagBits                       samples,
        VkMultisamplePropertiesEXT*                 pMultisampleProperties);

- `physicalDevice` is the physical device from which to query the additional multisampling capabilities.

- `samples` is a VkSampleCountFlagBits value specifying the sample count to query capabilities for.

- `pMultisampleProperties` is a pointer to a VkMultisamplePropertiesEXT structure in which information about additional multisampling capabilities specific to the sample count is returned.

Valid Usage (Implicit)

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

- VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter
  `samples` must be a valid VkSampleCountFlagBits value

- VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter
  `pMultisampleProperties` must be a valid pointer to a VkMultisamplePropertiesEXT structure

The `VkMultisamplePropertiesEXT` structure is defined as

    // Provided by VK_EXT_sample_locations
    typedef struct VkMultisamplePropertiesEXT {
        VkStructureType    sType;
        void*              pNext;
        VkExtent2D         maxSampleLocationGridSize;
    } VkMultisamplePropertiesEXT;

- `sType` is the type of this structure.

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

- `maxSampleLocationGridSize` is the maximum size of the pixel grid in which sample locations can vary.

Valid Usage (Implicit)

- VUID-VkMultisamplePropertiesEXT-sType-sType
  `sType` must be `VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT`

- VUID-VkMultisamplePropertiesEXT-pNext-pNext
  `pNext` must be `NULL`

If the sample count for which additional multisampling capabilities are requested using `vkGetPhysicalDeviceMultisamplePropertiesEXT` is set in `sampleLocationSampleCounts` the `width` and `height` members of `VkMultisamplePropertiesEXT`::`maxSampleLocationGridSize` must be greater than or equal to the corresponding members of `maxSampleLocationGridSize`, respectively, otherwise both members must be `0`.

### 46.3. Profile Limits

#### 46.3.1. Roadmap 2022

Implementations that claim support for the Roadmap 2022 profile must satisfy the following additional limit requirements:

Limit | Supported Limit | Limit Type1
--- | --- | ---
`maxImageDimension1D` | 8192 | min
`maxImageDimension2D` | 8192 | min
`maxImageDimensionCube` | 8192 | min
`maxImageArrayLayers` | 2048 | min
`maxUniformBufferRange` | 65536 | min
`bufferImageGranularity` | 4096 | max
`maxPerStageDescriptorSamplers` | 64 | min
`maxPerStageDescriptorUniformBuffers` | 15 | min
`maxPerStageDescriptorStorageBuffers` | 30 | min
`maxPerStageDescriptorSampledImages` | 200 | min
`maxPerStageDescriptorStorageImages` | 16 | min
`maxPerStageResources` | 200 | min
`maxDescriptorSetSamplers` | 576 | min
`maxDescriptorSetUniformBuffers` | 90 | min
`maxDescriptorSetStorageBuffers` | 96 | min
`maxDescriptorSetSampledImages` | 1800 | min
`maxDescriptorSetStorageImages` | 144 | min
`maxFragmentCombinedOutputResources` | 16 | min
`maxComputeWorkGroupInvocations` | 256 | min
`maxComputeWorkGroupSize` | (256,256,64) | min
`subTexelPrecisionBits` | 8 | min
`mipmapPrecisionBits` | 6 | min
`maxSamplerLodBias` | 14 | min
`pointSizeGranularity` | 0.125 | max
`lineWidthGranularity` | 0.5 | max
`standardSampleLocations` | `VK_TRUE` | Boolean
`maxColorAttachments` | 7 | min
`subgroupSize` | 4 | min
`subgroupSupportedStages` | `VK_SHADER_STAGE_COMPUTE_BIT` `VK_SHADER_STAGE_FRAGMENT_BIT` | bitfield
`subgroupSupportedOperations` | `VK_SUBGROUP_FEATURE_BASIC_BIT` `VK_SUBGROUP_FEATURE_VOTE_BIT` `VK_SUBGROUP_FEATURE_ARITHMETIC_BIT` `VK_SUBGROUP_FEATURE_BALLOT_BIT` `VK_SUBGROUP_FEATURE_SHUFFLE_BIT` `VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT` `VK_SUBGROUP_FEATURE_QUAD_BIT` | bitfield
`shaderSignedZeroInfNanPreserveFloat16` | `VK_TRUE` | Boolean
`shaderSignedZeroInfNanPreserveFloat32` | `VK_TRUE` | Boolean
`maxSubgroupSize` | 4 | min
`maxPerStageDescriptorUpdateAfterBindInputAttachments` | 7 | min