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 |
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 animageType
ofVK_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
orheight
) that is guaranteed to be supported for all images created with animageType
ofVK_IMAGE_TYPE_2D
and withoutVK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
set inflags
. 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
, ordepth
) that is guaranteed to be supported for all images created with animageType
ofVK_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
orheight
) that is guaranteed to be supported for all images created with animageType
ofVK_IMAGE_TYPE_2D
and withVK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
set inflags
. 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 theVK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
orVK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
set in theusage
member of the VkBufferCreateInfo structure. -
maxUniformBufferRange
is the maximum value that can be specified in therange
member of a VkDescriptorBufferInfo structure passed to vkUpdateDescriptorSets for descriptors of typeVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
orVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
. -
maxStorageBufferRange
is the maximum value that can be specified in therange
member of a VkDescriptorBufferInfo structure passed to vkUpdateDescriptorSets for descriptors of typeVK_DESCRIPTOR_TYPE_STORAGE_BUFFER
orVK_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 thepPushConstantRanges
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 sameVkDeviceMemory
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. AllDescriptorSet
decorations in shader modules must have a value less thanmaxBoundDescriptorSets
. 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 ofVK_DESCRIPTOR_TYPE_SAMPLER
orVK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
count against this limit. Only descriptors in descriptor set layouts created without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set count against this limit. A descriptor is accessible to a shader stage when thestageFlags
member of theVkDescriptorSetLayoutBinding
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 ofVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
orVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
count against this limit. Only descriptors in descriptor set layouts created without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set count against this limit. A descriptor is accessible to a shader stage when thestageFlags
member of theVkDescriptorSetLayoutBinding
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 ofVK_DESCRIPTOR_TYPE_STORAGE_BUFFER
orVK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 thestageFlags
member of theVkDescriptorSetLayoutBinding
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 ofVK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
,VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
, orVK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 thestageFlags
member of theVkDescriptorSetLayoutBinding
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 ofVK_DESCRIPTOR_TYPE_STORAGE_IMAGE
, orVK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 thestageFlags
member of theVkDescriptorSetLayoutBinding
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 ofVK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 thestageFlags
member of theVkDescriptorSetLayoutBinding
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 ofVK_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
, orVK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 ofVK_DESCRIPTOR_TYPE_SAMPLER
orVK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 ofVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
orVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 ofVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 ofVK_DESCRIPTOR_TYPE_STORAGE_BUFFER
orVK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 ofVK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 ofVK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
,VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
, orVK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 ofVK_DESCRIPTOR_TYPE_STORAGE_IMAGE
, orVK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 ofVK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
count against this limit. Only descriptors in descriptor set layouts created without theVK_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 ofVkVertexInputAttributeDescription
structures that are provided at graphics pipeline creation time via thepVertexAttributeDescriptions
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 ofVkVertexInputBindingDescription
structures that are provided at graphics pipeline creation time via thepVertexBindingDescriptions
member of the VkPipelineVertexInputStateCreateInfo structure. Thebinding
member ofVkVertexInputBindingDescription
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. Theoffset
member of theVkVertexInputAttributeDescription
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. Thestride
member of theVkVertexInputBindingDescription
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. ThepatchControlPoints
member of the VkPipelineTessellationStateCreateInfo structure specified at pipeline creation time and the value provided in theOutputVertices
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 theInvocations
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 anddualSrcBlend
. -
maxFragmentCombinedOutputResources
is the total number of storage buffers, storage images, and outputLocation
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 theWorkgroup
storage class in shader modules (or with theshared
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 theLocalSize
orLocalSizeId
execution mode in shader modules or by the object decorated by theWorkgroupSize
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. Thex
,y
, andz
sizes, as specified by theLocalSize
orLocalSizeId
execution mode or by the object decorated by theWorkgroupSize
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. 2subTexelPrecisionBits
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. 2mipmapPrecisionBits
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. SeefullDrawIndexUint32
. -
maxDrawIndirectCount
is the maximum draw count that is supported for indirect drawing calls. SeemultiDrawIndirect
. -
maxSamplerLodBias
is the maximum absolute sampler LOD bias. The sum of themipLodBias
member of the VkSamplerCreateInfo structure and theBias
operand of image sampling operations in shader modules (or 0 if noBias
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 themaxAnisotropy
member of the VkSamplerCreateInfo structure and this limit. See [samplers-maxAnisotropy]. -
maxViewports
is the maximum number of active viewports. TheviewportCount
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], wheresize
= max(maxViewportDimensions
[0],maxViewportDimensions
[1]). See Controlling the Viewport.NoteThe 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, subtractingoffset
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 theoffset
member of the VkBufferViewCreateInfo structure for texel buffers. The value must be a power of two. IftexelBufferAlignment
is enabled, this limit is equivalent to the maximum of theuniformTexelBufferOffsetAlignmentBytes
andstorageTexelBufferOffsetAlignmentBytes
members of VkPhysicalDeviceTexelBufferAlignmentProperties, but smaller alignment is optionally allowed bystorageTexelBufferOffsetSingleTexelAlignment
anduniformTexelBufferOffsetSingleTexelAlignment
. IftexelBufferAlignment
is not enabled, VkBufferViewCreateInfo::offset
must be a multiple of this value. -
minUniformBufferOffsetAlignment
is the minimum required alignment, in bytes, for theoffset
member of theVkDescriptorBufferInfo
structure for uniform buffers. When a descriptor of typeVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
orVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
is updated, theoffset
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 theoffset
member of theVkDescriptorBufferInfo
structure for storage buffers. When a descriptor of typeVK_DESCRIPTOR_TYPE_STORAGE_BUFFER
orVK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
is updated, theoffset
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 theConstOffset
image operand of any of theOpImageSample*
orOpImageFetch*
image instructions. -
maxTexelOffset
is the maximum offset value for theConstOffset
image operand of any of theOpImageSample*
orOpImageFetch*
image instructions. -
minTexelGatherOffset
is the minimum offset value for theOffset
,ConstOffset
, orConstOffsets
image operands of any of theOpImage*Gather
image instructions. -
maxTexelGatherOffset
is the maximum offset value for theOffset
,ConstOffset
, orConstOffsets
image operands of any of theOpImage*Gather
image instructions. -
minInterpolationOffset
is the base minimum (inclusive) negative offset value for theOffset
operand of theInterpolateAtOffset
extended instruction. -
maxInterpolationOffset
is the base maximum (inclusive) positive offset value for theOffset
operand of theInterpolateAtOffset
extended instruction. -
subPixelInterpolationOffsetBits
is the number of fractional bits that thex
andy
offsets to theInterpolateAtOffset
extended instruction may be rounded to as fixed-point values. -
maxFramebufferWidth
is the maximum width for a framebuffer. Thewidth
member of the VkFramebufferCreateInfo structure must be less than or equal to this limit. -
maxFramebufferHeight
is the maximum height for a framebuffer. Theheight
member of the VkFramebufferCreateInfo structure must be less than or equal to this limit. -
maxFramebufferLayers
is the maximum layer count for a layered framebuffer. Thelayers
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, seeframebufferIntegerColorSampleCounts
. -
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. ThecolorAttachmentCount
member of theVkSubpassDescription
orVkSubpassDescription2
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 withVK_IMAGE_TILING_OPTIMAL
,usage
containingVK_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 withVK_IMAGE_TILING_OPTIMAL
,usage
containingVK_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 withVK_IMAGE_TILING_OPTIMAL
,usage
containingVK_IMAGE_USAGE_SAMPLED_BIT
, and a depth format. -
sampledImageStencilSampleCounts
is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created withVK_IMAGE_TILING_OPTIMAL
,usage
containingVK_IMAGE_USAGE_SAMPLED_BIT
, and a stencil format. -
storageImageSampleCounts
is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created withVK_IMAGE_TILING_OPTIMAL
, andusage
containingVK_IMAGE_USAGE_STORAGE_BIT
. -
maxSampleMaskWords
is the maximum number of array elements of a variable decorated with theSampleMask
built-in decoration. -
timestampComputeAndGraphics
specifies support for timestamps on all graphics and compute queues. If this limit is set toVK_TRUE
, all queues that advertise theVK_QUEUE_GRAPHICS_BIT
orVK_QUEUE_COMPUTE_BIT
in theVkQueueFamilyProperties
::queueFlags
supportVkQueueFamilyProperties
::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 theClipDistance
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 theCullDistance
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 theClipDistance
andCullDistance
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 thePointSize
built-in decoration are clamped to this range. -
lineWidthRange
[2] is the range [minimum
,maximum
] of supported widths for lines. Values specified by thelineWidth
member of the VkPipelineRasterizationStateCreateInfo or thelineWidth
parameter tovkCmdSetLineWidth
are clamped to this range. -
pointSizeGranularity
is the granularity of supported point sizes. Not all point sizes in the range defined bypointSizeRange
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 bylineWidthRange
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 toVK_FALSE
, lines may be rasterized under a relaxed set of rules. If set toVK_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 toVK_TRUE
, the implementation uses the documented sample locations. If set toVK_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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 withVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure.
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 theSignedZeroInfNanPreserve
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 theSignedZeroInfNanPreserve
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 theSignedZeroInfNanPreserve
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 theDenormPreserve
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 theDenormPreserve
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 theDenormPreserve
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 theDenormFlushToZero
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 theDenormFlushToZero
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 theDenormFlushToZero
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 theRoundingModeRTE
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 theRoundingModeRTE
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 theRoundingModeRTE
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 theRoundingModeRTZ
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 theRoundingModeRTZ
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 theRoundingModeRTZ
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 insampleLocationSampleCounts
. -
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 toVK_TRUE
, the implementation supports variable sample locations in a subpass. If set toVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure. -
perViewPositionAllComponents
isVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 supportVK_QUEUE_GRAPHICS_BIT
orVK_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 theVK_SHADER_STAGE_COMPUTE_BIT
bit set if any of the physical device’s queues supportVK_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 theVK_SUBGROUP_FEATURE_BASIC_BIT
bit set if any of the physical device’s queues supportVK_QUEUE_GRAPHICS_BIT
orVK_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.
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 theGroupNonUniform
capability. -
VK_SUBGROUP_FEATURE_VOTE_BIT
specifies the device will accept SPIR-V shader modules containing theGroupNonUniformVote
capability. -
VK_SUBGROUP_FEATURE_ARITHMETIC_BIT
specifies the device will accept SPIR-V shader modules containing theGroupNonUniformArithmetic
capability. -
VK_SUBGROUP_FEATURE_BALLOT_BIT
specifies the device will accept SPIR-V shader modules containing theGroupNonUniformBallot
capability. -
VK_SUBGROUP_FEATURE_SHUFFLE_BIT
specifies the device will accept SPIR-V shader modules containing theGroupNonUniformShuffle
capability. -
VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT
specifies the device will accept SPIR-V shader modules containing theGroupNonUniformShuffleRelative
capability. -
VK_SUBGROUP_FEATURE_CLUSTERED_BIT
specifies the device will accept SPIR-V shader modules containing theGroupNonUniformClustered
capability. -
VK_SUBGROUP_FEATURE_QUAD_BIT
specifies the device will accept SPIR-V shader modules containing theGroupNonUniformQuad
capability. -
VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV
specifies the device will accept SPIR-V shader modules containing theGroupNonUniformPartitionedNV
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 supportVK_QUEUE_GRAPHICS_BIT
orVK_QUEUE_COMPUTE_BIT
.minSubgroupSize
is a power-of-two.minSubgroupSize
is less than or equal tomaxSubgroupSize
.minSubgroupSize
is less than or equal tosubgroupSize
. -
maxSubgroupSize
is the maximum subgroup size supported by this device.maxSubgroupSize
is at least one if any of the physical device’s queues supportVK_QUEUE_GRAPHICS_BIT
orVK_QUEUE_COMPUTE_BIT
.maxSubgroupSize
is a power-of-two.maxSubgroupSize
is greater than or equal tominSubgroupSize
.maxSubgroupSize
is greater than or equal tosubgroupSize
. -
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 isVK_FALSE
, then VkPipelineColorBlendAdvancedStateCreateInfoEXT::srcPremultiplied
must beVK_TRUE
. -
advancedBlendNonPremultipliedDstColor
specifies whether the destination color can be treated as non-premultiplied. If this isVK_FALSE
, then VkPipelineColorBlendAdvancedStateCreateInfoEXT::dstPremultiplied
must beVK_TRUE
. -
advancedBlendCorrelatedOverlap
specifies whether the overlap mode can be treated as correlated. If this isVK_FALSE
, then VkPipelineColorBlendAdvancedStateCreateInfoEXT::blendOverlap
must beVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
The VkPhysicalDeviceProtectedMemoryProperties
structure is defined as:
// Provided by VK_VERSION_1_1
typedef struct VkPhysicalDeviceProtectedMemoryProperties {
VkStructureType sType;
void* pNext;
VkBool32 protectedNoFault;
} VkPhysicalDeviceProtectedMemoryProperties;
-
sType
is a VkStructureType value identifying this structure. -
pNext
isNULL
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 isVK_TRUE
, such writes will be discarded or have undefined values written, reads and queries will return undefined values. If this limit isVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure.
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 theLocalSize
orLocalSizeId
execution mode in shader modules or by the object decorated by theWorkgroupSize
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. Thex
,y
, andz
sizes, as specified by theLocalSize
orLocalSizeId
execution mode or by the object decorated by theWorkgroupSize
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 theLocalSize
orLocalSizeId
execution mode in shader modules or by the object decorated by theWorkgroupSize
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. Thex
,y
, andz
sizes, as specified by theLocalSize
orLocalSizeId
execution mode or by the object decorated by theWorkgroupSize
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 tomaxMeshTotalMemorySize
. -
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 tomaxMeshTotalMemorySize
.
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 tomaxTaskWorkGroupTotalCount
. -
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 theLocalSize
orLocalSizeId
execution mode in shader modules or by the object decorated by theWorkgroupSize
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. Thex
,y
, andz
sizes, as specified by theLocalSize
orLocalSizeId
execution mode or by the object decorated by theWorkgroupSize
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 theTaskPayloadWorkgroupEXT
storage class in shader modules in the task shader stage. -
maxTaskSharedMemorySize
is the maximum total storage size, in bytes, available for variables declared with theWorkgroup
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 theTaskPayloadWorkgroupEXT
orWorkgroup
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 theOpEmitMeshTasksEXT
must be less than or equal to the corresponding limit. The product of these dimensions must be less than or equal tomaxMeshWorkGroupTotalCount
. -
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 theLocalSize
orLocalSizeId
execution mode in shader modules or by the object decorated by theWorkgroupSize
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. Thex
,y
, andz
sizes, as specified by theLocalSize
orLocalSizeId
execution mode or by the object decorated by theWorkgroupSize
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 theWorkgroup
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 theTaskPayloadWorkgroupEXT
orWorkgroup
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 theTaskPayloadWorkgroupEXT
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 tomaxMeshOutputMemorySize
. -
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 tomaxMeshOutputMemorySize
. -
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 matchesLocalInvocationIndex
. -
prefersLocalInvocationPrimitiveOutput
specifies whether writes to the primitive output array in a mesh shader yield best performance when the array index matchesLocalInvocationIndex
. -
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 ofCullPrimitiveEXT
may be better.
If the VkPhysicalDeviceMeshShaderPropertiesEXT
structure is included
in the pNext
chain of VkPhysicalDeviceProperties2, it is filled
with the implementation-dependent limits.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 theVK_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 isVK_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 isVK_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 isVK_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 isVK_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 isVK_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 whetherrobustBufferAccess
can be enabled on a device simultaneously withdescriptorBindingUniformBufferUpdateAfterBind
,descriptorBindingStorageBufferUpdateAfterBind
,descriptorBindingUniformTexelBufferUpdateAfterBind
, and/ordescriptorBindingStorageTexelBufferUpdateAfterBind
. If this isVK_FALSE
, then eitherrobustBufferAccess
must be disabled or all of these update-after-bind features must be disabled. -
quadDivergentImplicitLod
is a boolean value indicating whether implicit LOD 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 tomaxPerStageDescriptorSamplers
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxPerStageDescriptorUpdateAfterBindUniformBuffers
is similar tomaxPerStageDescriptorUniformBuffers
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxPerStageDescriptorUpdateAfterBindStorageBuffers
is similar tomaxPerStageDescriptorStorageBuffers
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxPerStageDescriptorUpdateAfterBindSampledImages
is similar tomaxPerStageDescriptorSampledImages
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxPerStageDescriptorUpdateAfterBindStorageImages
is similar tomaxPerStageDescriptorStorageImages
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxPerStageDescriptorUpdateAfterBindInputAttachments
is similar tomaxPerStageDescriptorInputAttachments
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxPerStageUpdateAfterBindResources
is similar tomaxPerStageResources
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxDescriptorSetUpdateAfterBindSamplers
is similar tomaxDescriptorSetSamplers
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxDescriptorSetUpdateAfterBindUniformBuffers
is similar tomaxDescriptorSetUniformBuffers
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
is similar tomaxDescriptorSetUniformBuffersDynamic
but counts descriptors from descriptor sets created with or without theVK_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 theVK_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 withVK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
. -
maxDescriptorSetUpdateAfterBindStorageBuffers
is similar tomaxDescriptorSetStorageBuffers
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
is similar tomaxDescriptorSetStorageBuffersDynamic
but counts descriptors from descriptor sets created with or without theVK_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 theVK_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 withVK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
. -
maxDescriptorSetUpdateAfterBindSampledImages
is similar tomaxDescriptorSetSampledImages
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxDescriptorSetUpdateAfterBindStorageImages
is similar tomaxDescriptorSetStorageImages
but counts descriptors from descriptor sets created with or without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set. -
maxDescriptorSetUpdateAfterBindInputAttachments
is similar tomaxDescriptorSetInputAttachments
but counts descriptors from descriptor sets created with or without theVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure.
-
maxInlineUniformBlockSize
is the maximum size in bytes of an inline uniform block binding. -
maxPerStageDescriptorInlineUniformBlocks
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 ofVK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK
count against this limit. Only descriptor bindings in descriptor set layouts created without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set count against this limit. -
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks
is similar tomaxPerStageDescriptorInlineUniformBlocks
but counts descriptor bindings from descriptor sets created with or without theVK_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 ofVK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK
count against this limit. Only descriptor bindings in descriptor set layouts created without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set count against this limit. -
maxDescriptorSetUpdateAfterBindInlineUniformBlocks
is similar tomaxDescriptorSetInlineUniformBlocks
but counts descriptor bindings from descriptor sets created with or without theVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 andmaxExtraPrimitiveOverestimationSize
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
isVK_TRUE
if the implementation supports theVK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
conservative rasterization mode in addition toVK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT
. Otherwise the implementation only supportsVK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT
. -
conservativePointAndLineRasterization
isVK_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
isVK_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
isVK_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
isVK_FALSE
if the implementation culls lines that become zero length after they are quantized to the fixed-point rasterization pixel grid.degenerateLinesRasterized
isVK_TRUE
if zero length lines are not culled and the provoking vertex attributes and depth value are used for the fragments. -
fullyCoveredFragmentShaderInputVariable
isVK_TRUE
if the implementation supports the SPIR-V builtin fragment shader input variableFullyCoveredEXT
specifying that conservative rasterization is enabled and the fragment area is fully covered by the generating primitive. -
conservativeRasterizationPostDepthCoverage
isVK_TRUE
if the implementation supports conservative rasterization with thePostDepthCoverage
execution mode enabled. Otherwise thePostDepthCoverage
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 withflags
containingVK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT
in fragment shader will trigger additional reads duringVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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
isVK_TRUE
if the implementation supports setting the depth and stencil resolve modes to different values when one of those modes isVK_RESOLVE_MODE_NONE
. Otherwise the implementation only supports setting both modes to the same value. -
independentResolve
isVK_TRUE
if the implementation supports all combinations of the supported depth and stencil resolve modes, including setting either depth or stencil resolve mode toVK_RESOLVE_MODE_NONE
. An implementation that supportsindependentResolve
must also supportindependentResolveNone
.
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.
The VkPhysicalDevicePerformanceQueryPropertiesKHR
structure is defined
as:
// Provided by VK_KHR_performance_query
typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
VkStructureType sType;
void* pNext;
VkBool32 allowCommandBufferQueryCopies;
} VkPhysicalDevicePerformanceQueryPropertiesKHR;
-
sType
is a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure. -
allowCommandBufferQueryCopies
isVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 thecountBuffer
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 theGeometryStreams
capability. If the implementation does not supportVkPhysicalDeviceTransformFeedbackFeaturesEXT
::geometryStreams
thenmaxTransformFeedbackStreams
must be set to1
. -
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
isVK_TRUE
if the implementation supports theVK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT
query type.transformFeedbackQueries
isVK_FALSE
if queries of this type cannot be created. -
transformFeedbackStreamsLinesTriangles
isVK_TRUE
if the implementation supports the geometry shaderOpExecutionMode
ofOutputLineStrip
andOutputTriangleStrip
in addition toOutputPoints
when more than one vertex stream is output. IftransformFeedbackStreamsLinesTriangles
isVK_FALSE
the implementation only supports anOpExecutionMode
ofOutputPoints
when more than one vertex stream is output from the geometry shader. -
transformFeedbackRasterizationStreamSelect
isVK_TRUE
if the implementation supports theGeometryStreams
SPIR-V capability and the application can use VkPipelineRasterizationStateStreamCreateInfoEXT to modify which vertex stream output is used for rasterization. Otherwise vertex stream0
must always be used for rasterization. -
transformFeedbackDraw
isVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 ofVK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR
count against this limit. Only descriptor bindings in descriptor set layouts created without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set count against this limit. -
maxPerStageDescriptorUpdateAfterBindAccelerationStructures
is similar tomaxPerStageDescriptorAccelerationStructures
but counts descriptor bindings from descriptor sets created with or without theVK_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 ofVK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR
count against this limit. Only descriptor bindings in descriptor set layouts created without theVK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT
bit set count against this limit. -
maxDescriptorSetUpdateAfterBindAccelerationStructures
is similar tomaxDescriptorSetAccelerationStructures
but counts descriptor bindings from descriptor sets created with or without theVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
The VkPhysicalDeviceCooperativeMatrixPropertiesNV
structure is defined
as:
// Provided by VK_NV_cooperative_matrix
typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
VkStructureType sType;
void* pNext;
VkShaderStageFlags cooperativeMatrixSupportedStages;
} VkPhysicalDeviceCooperativeMatrixPropertiesNV;
-
sType
is a VkStructureType value identifying this structure. -
pNext
isNULL
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 theVK_SHADER_STAGE_COMPUTE_BIT
bit set if any of the physical device’s queues supportVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure. -
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure.
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 therobustBufferAccess2
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 therobustBufferAccess2
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 inmaxFragmentShadingRateAttachmentTexelSize
. Each value must be a power-of-two. It must be (0,0) if theattachmentFragmentShadingRate
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 inminFragmentShadingRateAttachmentTexelSize
. Each value must be a power-of-two. It must be (0,0) if theattachmentFragmentShadingRate
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 theattachmentFragmentShadingRate
feature is not supported. -
primitiveFragmentShadingRateWithMultipleViewports
specifies whether the primitive fragment shading rate can be used when multiple viewports are used. If this value isVK_FALSE
, only a single viewport must be used, and applications must not write to theViewportMaskNV
orViewportIndex
built-in when settingPrimitiveShadingRateKHR
. It must beVK_FALSE
if theshaderOutputViewportIndex
feature, theVK_EXT_shader_viewport_index_layer
extension, or thegeometryShader
feature is not supported, or if theprimitiveFragmentShadingRate
feature is not supported. -
layeredShadingRateAttachments
specifies whether a shading rate attachment image view can be created with multiple layers. If this value isVK_FALSE
, when creating an image view with ausage
that includesVK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR
,layerCount
must be1
. It must beVK_FALSE
if themultiview
feature, theshaderOutputViewportIndex
feature, theVK_EXT_shader_viewport_index_layer
extension, or thegeometryShader
feature is not supported, or if theattachmentFragmentShadingRate
feature is not supported. -
fragmentShadingRateNonTrivialCombinerOps
specifies whether VkFragmentShadingRateCombinerOpKHR enums other thanVK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR
orVK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR
can be used. It must beVK_FALSE
unless either theprimitiveFragmentShadingRate
orattachmentFragmentShadingRate
feature is supported. -
maxFragmentSize
indicates the maximum supported width and height of a fragment. Itswidth
andheight
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 thewidth
andheight
members ofmaxFragmentSize
. 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 thewidth
andheight
members ofmaxFragmentSize
, and the sample count reported bymaxFragmentShadingRateRasterizationSamples
.maxFragmentShadingRateCoverageSamples
must be less than or equal tomaxSampleMaskWords
× 32 iffragmentShadingRateWithShaderSampleMask
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 writingFragDepth
orFragStencilRefEXT
from a fragment shader for multi-pixel fragments. If this value isVK_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
to0
for multi-pixel fragments. If this value isVK_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 writingSampleMask
for multi-pixel fragments. If this value isVK_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 beVK_FALSE
ifVK_EXT_conservative_rasterization
is not supported. If this value isVK_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 beVK_FALSE
ifVK_EXT_fragment_shader_interlock
is not supported. If this value isVK_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 beVK_FALSE
ifVK_EXT_sample_locations
is not supported. If this value isVK_FALSE
, using custom sample locations will clamp the fragment shading rate to (1,1). -
fragmentShadingRateStrictMultiplyCombiner
specifies whetherVK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR
accurately performs a multiplication or not. Implementations where this value isVK_FALSE
will instead combine rates with an addition. IffragmentShadingRateNonTrivialCombinerOps
isVK_FALSE
, implementations must report this asVK_FALSE
. IffragmentShadingRateNonTrivialCombinerOps
isVK_TRUE
, implementations should report this asVK_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 |
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
The VkPhysicalDeviceCustomBorderColorPropertiesEXT
structure is
defined as:
// Provided by VK_EXT_custom_border_color
typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
VkStructureType sType;
void* pNext;
uint32_t maxCustomBorderColorSamplers;
} VkPhysicalDeviceCustomBorderColorPropertiesEXT;
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure. -
combinedImageSamplerDescriptorSingleArray
indicates that the implementation does not require an array ofVK_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 withVK_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 isVK_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 withVK_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 aVK_DESCRIPTOR_TYPE_SAMPLER
descriptor. -
combinedImageSamplerDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
descriptor. -
sampledImageDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
descriptor. -
storageImageDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_STORAGE_IMAGE
descriptor. -
uniformTexelBufferDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER
descriptor if therobustBufferAccess
feature is not enabled. -
robustUniformTexelBufferDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER
descriptor if therobustBufferAccess
feature is enabled. -
storageTexelBufferDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
descriptor if therobustBufferAccess
feature is not enabled. -
robustStorageTexelBufferDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
descriptor if therobustBufferAccess
feature is enabled. -
uniformBufferDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
descriptor. -
robustUniformBufferDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
descriptor if therobustBufferAccess
feature is enabled. -
storageBufferDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_STORAGE_BUFFER
descriptor. -
robustStorageBufferDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_STORAGE_BUFFER
descriptor if therobustBufferAccess
feature is enabled. -
inputAttachmentDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
descriptor. -
accelerationStructureDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR
orVK_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 withVK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT
. -
resourceDescriptorBufferAddressSpaceSize
indicates the total size in bytes of the address space available for descriptor buffers created withVK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT
. -
descriptorBufferAddressSpaceSize
indicates the total size in bytes of the address space available for descriptor buffers created with bothVK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT
andVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure. -
combinedImageSamplerDensityMapDescriptorSize
indicates the size in bytes of aVK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
descriptor when creating the descriptor withVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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:
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.
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 isVK_TRUE
, creating a graphics pipeline entirely from pipeline libraries withoutVK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT
is comparable in cost to recording a command in a command buffer. -
graphicsPipelineLibraryIndependentInterpolationDecoration
indicates whetherNoPerspective
andFlat
interpolation decorations in the last vertex processing stage and the fragment shader are required to match when using graphics pipeline libraries. If it isVK_TRUE
, the interpolation decorations do not need to match. If it isVK_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.
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 isVK_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.
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 ofVK_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
|
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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 allowsvkCmdSetPrimitiveTopology
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure. -
supportedOutputGridSizes
are the supported VkOpticalFlowGridSizeFlagsNV which can be specified inVkOpticalFlowSessionCreateInfoNV
::outputGridSize
. -
supportedHintGridSizes
are the supported VkOpticalFlowGridSizeFlagsNV which can be specified inVkOpticalFlowSessionCreateInfoNV
::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 thismaxNumRegionsOfInterest
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure. -
maxOpacity2StateSubdivisionLevel
is the maximum allowedsubdivisionLevel
whenformat
isVK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT
-
maxOpacity4StateSubdivisionLevel
is the maximum allowedsubdivisionLevel
whenformat
isVK_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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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 theLocalSize
orLocalSizeId
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.
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 a VkStructureType value identifying this structure. -
pNext
isNULL
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.
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.
Type | Limit | Feature |
---|---|---|
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
- |
|
|
|
|
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
- |
|
|
- |
|
|
|
|
|
- |
|
|
- |
3 × |
|
- |
|
|
- |
3 × |
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
|
|
|
|
|
|
- |
|
|
|
|
|
|
2 × |
|
- |
2 × |
|
- |
|
|
- |
|
|
- |
|
- |
|
|
- |
|
|
- |
|
|
|
- |
|
|
- |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
- |
|
|
- |
|
|
- |
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
|
- |
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
|
|
|
|
- |
|
- |
|
|
|
- |
|
|
|
|
|
|
|
|
|
|
|
- |
2 × |
|
|
2 × |
|
|
|
|
|
|
|
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
|
|
|
||
|
||
|
||
|
|
|
|
||
|
|
|
|
||
|
|
|
|
||
|
||
|
|
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
- |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
3 × |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
3 × |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesNV:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
3 × |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
3 × |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
3 × |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
3 × |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
|
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
||
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
||
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
||
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
||
|
|
|
|
|
|
|
||
|
|
|
|
|
|
|
|
|
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
|
|
|
|
|
|
||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||
|
||
2 × |
|
|
2 × |
|
|
|
|
|
|
||
|
||
|
||
2 × |
|
|
|
|
|
|
|
|
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||
|
||
|
||
|
||
|
||
|
|
|
|
|
|
|
||
|
||
|
- |
|
|
|
|
2 × |
|
|
2 × |
|
|
2 × |
|
|
|
||
|
|
|
|
|
|
|
|
|
3 × |
|
|
3 × |
|
|
|
|
|
|
Limit | Unsupported Limit | Supported Limit | Limit Type1 |
---|---|---|---|
|
- |
4096 |
min |
|
- |
4096 |
min |
|
- |
256 |
min |
|
- |
4096 |
min |
|
- |
256 |
min |
|
- |
65536 |
min |
|
- |
16384 |
min |
|
- |
227 |
min |
|
- |
128 |
min |
|
- |
4096 |
min |
|
- |
4000 |
min |
|
- |
131072 |
max |
|
0 |
231 |
min |
|
- |
4 |
min |
|
- |
16 |
min |
|
- |
12 |
min |
|
- |
4 |
min |
|
- |
16 |
min |
|
- |
4 |
min |
|
- |
4 |
min |
|
- |
128 2 |
min |
|
- |
96 8 |
min, n × PerStage |
|
- |
72 8 |
min, n × PerStage |
|
- |
8 |
min |
|
- |
24 8 |
min, n × PerStage |
|
- |
4 |
min |
|
- |
96 8 |
min, n × PerStage |
|
- |
24 8 |
min, n × PerStage |
|
- |
4 |
min |
|
- |
16 |
min |
|
- |
16 10 |
min |
|
- |
2047 |
min |
|
- |
2048 |
min |
|
- |
64 |
min |
|
0 |
64 |
min |
|
0 |
32 |
min |
|
0 |
64 |
min |
|
0 |
64 |
min |
|
0 |
120 |
min |
|
0 |
2048 |
min |
|
0 |
64 |
min |
|
0 |
64 |
min |
|
0 |
32 |
min |
|
0 |
64 |
min |
|
0 |
64 |
min |
|
0 |
256 |
min |
|
0 |
1024 |
min |
|
- |
64 |
min |
|
- |
4 |
min |
|
0 |
1 |
min |
|
- |
4 |
min |
|
- |
16384 |
min |
|
- |
(65535,65535,65535) |
min |
|
- |
128 |
min |
|
- |
(128,128,64) |
min |
|
- |
4 |
min |
|
- |
4 |
min |
|
- |
4 |
min |
|
224-1 |
232-1 |
min |
|
1 |
216-1 |
min |
|
- |
2 |
min |
|
1 |
16 |
min |
|
1 |
16 |
min |
|
- |
(4096,4096) 3 |
min |
|
- |
(-8192,8191) 4 |
(max,min) |
|
- |
0 |
min |
|
- |
64 |
min |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
-8 |
max |
|
- |
7 |
min |
|
0 |
-8 |
max |
|
0 |
7 |
min |
|
0.0 |
-0.5 5 |
max |
|
0.0 |
0.5 - (1 ULP) 5 |
min |
|
0 |
4 5 |
min |
|
- |
4096 |
min |
|
- |
4096 |
min |
|
- |
256 |
min |
|
- |
( |
min |
|
- |
( |
min |
|
- |
( |
min |
|
- |
( |
min |
|
- |
( |
min |
|
- |
4 |
min |
|
- |
( |
min |
|
- |
|
min |
|
- |
( |
min |
|
- |
( |
min |
|
|
( |
min |
|
- |
1 |
min |
|
- |
- |
implementation-dependent |
|
- |
- |
duration |
|
0 |
8 |
min |
|
0 |
8 |
min |
|
0 |
8 |
min |
|
- |
2 |
min |
|
(1.0,1.0) |
(1.0,64.0 - ULP)6 |
(max,min) |
|
(1.0,1.0) |
(1.0,8.0 - ULP)7 |
(max,min) |
|
0.0 |
1.0 6 |
max, fixed point increment |
|
0.0 |
1.0 7 |
max, fixed point increment |
|
- |
- |
implementation-dependent |
|
- |
- |
implementation-dependent |
|
- |
- |
recommendation |
|
- |
- |
recommendation |
|
- |
256 |
max |
|
- |
32 |
min |
|
- |
6 |
min |
|
- |
227-1 |
min |
|
0 |
4 |
min |
|
- |
|
min |
|
- |
(1,1) |
min |
|
- |
(0.0, 0.9375) |
(max,min) |
|
- |
4 |
min |
|
- |
false |
implementation-dependent |
|
- |
65536 |
max |
|
- |
- |
implementation-dependent |
|
- |
- |
implementation-dependent |
|
- |
- |
implementation-dependent |
|
- |
1 |
min |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
1024 |
min |
|
- |
230 |
min |
|
- |
230 |
min |
|
- |
0.0 |
min |
|
- |
0.0 |
min |
|
- |
0.0 |
min |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
0 |
500000 |
min |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
09 |
500000 9 |
min |
|
09 |
12 9 |
min |
|
09 |
500000 9 |
min |
|
09 |
500000 9 |
min |
|
09 |
500000 9 |
min |
|
09 |
4 9 |
min |
|
09 |
500000 9 |
min |
|
09 |
500000 9 |
min |
|
09 |
72 8 9 |
min, n × PerStage |
|
09 |
8 9 |
min |
|
09 |
500000 9 |
min |
|
09 |
4 9 |
min |
|
09 |
500000 9 |
min |
|
09 |
500000 9 |
min |
|
09 |
4 9 |
min |
|
- |
256 |
min |
|
- |
4 |
min |
|
- |
4 |
min |
|
- |
4 |
min |
|
- |
4 |
min |
|
- |
256 |
min |
|
- |
216-1 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
216-1 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
32 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
(32,1,1) |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
16384 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
216-1 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
32 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
(32,1,1) |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
16384 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
256 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
256 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
1 |
min |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
- |
implementation-dependent |
VkPhysicalDeviceMeshShaderPropertiesNV:: |
- |
- |
implementation-dependent |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
2^22 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
(65535,65535,65535) |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
128 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
(128,128,128) |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
16384 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
32768 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
32768 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
2^22 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
(65535,65535,65535) |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
128 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
(128,128,128) |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
28672 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
28672 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
32768 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
48128 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
128 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
256 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
256 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
8 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
1 |
min |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
0 |
32 |
max |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
0 |
32 |
max |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
- |
implementation-dependent |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
- |
implementation-dependent |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
- |
implementation-dependent |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
- |
implementation-dependent |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
- |
implementation-dependent |
VkPhysicalDeviceMeshShaderPropertiesEXT:: |
- |
- |
implementation-dependent |
|
- |
1 |
min |
|
- |
1 |
min |
|
- |
227 |
min |
|
- |
512 |
min |
|
- |
512 |
min |
|
- |
512 |
min |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
(1,1) |
min |
|
- |
(1,1) |
min |
|
- |
- |
implementation-dependent |
|
true |
false |
implementation-dependent |
|
false |
false |
implementation-dependent |
|
2 |
2 |
min |
|
1 |
1 |
min |
|
- |
(1024,1024) |
max |
VkPhysicalDeviceRayTracingPropertiesNV:: |
- |
16 |
min |
VkPhysicalDeviceRayTracingPropertiesNV:: |
- |
31 |
min |
VkPhysicalDeviceRayTracingPipelinePropertiesKHR:: |
- |
32 |
exact |
VkPhysicalDeviceRayTracingPipelinePropertiesKHR:: |
- |
1 |
min |
|
- |
4096 |
min |
|
- |
64 |
max |
|
- |
224-1 |
min |
|
- |
224-1 |
min |
|
- |
229-1 |
min |
|
- |
229-1 |
min |
|
- |
16 |
min |
|
- |
500000 9 |
min |
|
- |
16 |
min |
|
- |
500000 9 |
min |
|
- |
256 |
max |
|
- |
64 |
max |
|
- |
230 |
min |
|
- |
32 |
max |
|
- |
32 |
min |
|
- |
231-1 |
min |
|
- |
4 |
min |
|
- |
212 |
min |
|
- |
220 |
min |
|
- |
16 |
min |
|
- |
16 |
min |
|
- |
2047 |
min |
|
- |
2048 |
min |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
32 |
min |
|
- |
4 |
max |
|
- |
256 |
max |
|
(0,0) |
(32,32) |
max |
|
(0,0) |
(8,8) |
min |
|
0 |
1 |
min |
|
false |
false |
implementation-dependent |
|
false |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
(2,2) |
min |
|
- |
2 |
min |
|
- |
16 |
min |
|
- |
|
min |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
|
min |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
256 |
max |
|
- |
3 |
min |
|
- |
1 |
min |
|
- |
1 |
min |
|
- |
1 |
min |
|
- |
2032 |
min |
|
- |
64 |
max |
|
- |
64 |
max |
|
- |
64 |
max |
|
- |
64 |
max |
|
- |
64 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
256 |
max |
|
- |
211 × |
min |
|
- |
(220 - 215) × |
min |
|
- |
227 |
min |
|
- |
227 |
min |
|
- |
227 |
min |
|
- |
256 |
max |
|
0 |
1 |
min |
|
- |
1024 |
min |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
false |
implementation-dependent |
|
- |
1024 |
min |
|
- |
(64,64) |
min |
|
- |
(64,64) |
min |
|
- |
(64,64) |
min |
|
- |
- |
implementation-dependent |
|
- |
3 |
min |
|
- |
3 |
min |
|
1 |
216-1 |
min |
|
- |
(65536,1,1) |
min |
|
- |
(32,1,1) |
min |
|
- |
1024 |
min |
|
- |
- |
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
andmaxInterpolationOffset
describe the closed interval of supported interpolation offsets: [minInterpolationOffset
,maxInterpolationOffset
]. The ULP is determined bysubPixelInterpolationOffsetBits
. IfsubPixelInterpolationOffsetBits
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 thepointSizeGranularity
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 thelineWidthGranularity
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 minimummaxPerStageDescriptor*
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 correspondingnon
-UpdateAfterBind limit. - 10
-
If the
VK_KHR_portability_subset
extension is enabled, the required minimum value ofmaxVertexInputBindings
is8
. - 12
-
maxResourceDescriptorSize
is defined as the maximum value ofstorageImageDescriptorSize
,sampledImageDescriptorSize
,robustUniformTexelBufferDescriptorSize
,robustStorageTexelBufferDescriptorSize
,robustUniformBufferDescriptorSize
,robustStorageBufferDescriptorSize
,inputAttachmentDescriptorSize
, andaccelerationStructureDescriptorSize
.
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.
The VkMultisamplePropertiesEXT
structure is defined as
// Provided by VK_EXT_sample_locations
typedef struct VkMultisamplePropertiesEXT {
VkStructureType sType;
void* pNext;
VkExtent2D maxSampleLocationGridSize;
} VkMultisamplePropertiesEXT;
-
sType
is a VkStructureType value identifying this structure. -
pNext
isNULL
or a pointer to a structure extending this structure. -
maxSampleLocationGridSize
is the maximum size of the pixel grid in which sample locations can vary.
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 |
---|---|---|
|
8192 |
min |
|
8192 |
min |
|
8192 |
min |
|
2048 |
min |
|
65536 |
min |
|
4096 |
max |
|
64 |
min |
|
15 |
min |
|
30 |
min |
|
200 |
min |
|
16 |
min |
|
200 |
min |
|
576 |
min |
|
90 |
min |
|
96 |
min |
|
1800 |
min |
|
144 |
min |
|
16 |
min |
|
256 |
min |
|
(256,256,64) |
min |
|
8 |
min |
|
6 |
min |
|
14 |
min |
|
0.125 |
max |
|
0.5 |
max |
|
|
Boolean |
|
7 |
min |
|
4 |
min |
|
|
bitfield |
|
|
bitfield |
|
|
Boolean |
|
|
Boolean |
|
4 |
min |
|
7 |
min |