693 lines
39 KiB
Plaintext
693 lines
39 KiB
Plaintext
// Copyright (c) 2014-2016 Khronos Group. This work is licensed under a
|
|
// Creative Commons Attribution 4.0 International License; see
|
|
// http://creativecommons.org/licenses/by/4.0/
|
|
|
|
VkPhysicalDeviceLimits(3)
|
|
=========================
|
|
|
|
Name
|
|
----
|
|
VkPhysicalDeviceLimits - Structure
|
|
|
|
C Specification
|
|
---------------
|
|
|
|
// refBegin VkPhysicalDeviceLimits Structure
|
|
|
|
The sname:VkPhysicalDeviceLimits structure is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceLimits.txt[]
|
|
|
|
|
|
Members
|
|
-------
|
|
|
|
* [[features-limits-maxImageDimension1D]] pname:maxImageDimension1D is the
|
|
maximum dimension (pname:width) of an image created with an
|
|
pname:imageType of ename:VK_IMAGE_TYPE_1D.
|
|
* [[features-limits-maxImageDimension2D]] pname:maxImageDimension2D is the
|
|
maximum dimension (pname:width or pname:height) of an image created with
|
|
an pname:imageType of ename:VK_IMAGE_TYPE_2D and without
|
|
ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in pname:flags.
|
|
* [[features-limits-maxImageDimension3D]] pname:maxImageDimension3D is the
|
|
maximum dimension (pname:width, pname:height, or pname:depth) of an
|
|
image created with an pname:imageType of ename:VK_IMAGE_TYPE_3D.
|
|
* [[features-limits-maxImageDimensionCube]] pname:maxImageDimensionCube is
|
|
the maximum dimension (pname:width or pname:height) of an image created
|
|
with an pname:imageType of ename:VK_IMAGE_TYPE_2D and with
|
|
ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in pname:flags.
|
|
* [[features-limits-maxImageArrayLayers]] pname:maxImageArrayLayers is the
|
|
maximum number of layers (pname:arrayLayers) for an image.
|
|
* [[features-limits-maxTexelBufferElements]] pname:maxTexelBufferElements
|
|
is the maximum number of addressable texels for a buffer view created on
|
|
a buffer which was created with the
|
|
ename:VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or
|
|
ename:VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set in the pname:usage
|
|
member of the sname:VkBufferCreateInfo structure.
|
|
* [[features-limits-maxUniformBufferRange]] pname:maxUniformBufferRange is
|
|
the maximum value that can: be specified in the pname:range member of
|
|
any slink:VkDescriptorBufferInfo structures passed to a call to
|
|
flink:vkUpdateDescriptorSets for descriptors of type
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC.
|
|
* [[features-limits-maxStorageBufferRange]] pname:maxStorageBufferRange is
|
|
the maximum value that can: be specified in the pname:range member of
|
|
any slink:VkDescriptorBufferInfo structures passed to a call to
|
|
flink:vkUpdateDescriptorSets for descriptors of type
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC.
|
|
* [[features-limits-maxPushConstantsSize]] pname:maxPushConstantsSize is
|
|
the maximum size, in bytes, of the pool of push constant memory. For
|
|
each of the push constant ranges indicated by the
|
|
pname:pPushConstantRanges member of the sname:VkPipelineLayoutCreateInfo
|
|
structure, pname:offset + pname:size must: be less than or equal to this
|
|
limit.
|
|
* [[features-limits-maxMemoryAllocationCount]]
|
|
pname:maxMemoryAllocationCount is the maximum number of device memory
|
|
allocations, as created by flink:vkAllocateMemory, which can:
|
|
simultaneously exist.
|
|
* [[features-limits-maxSamplerAllocationCount]]
|
|
pname:maxSamplerAllocationCount is the maximum number of sampler
|
|
objects, as created by flink:vkCreateSampler, which can: simultaneously
|
|
exist on a device.
|
|
* [[features-limits-bufferImageGranularity]] pname:bufferImageGranularity
|
|
is the granularity, in bytes, at which buffer or linear image resources,
|
|
and optimal image resources can: be bound to adjacent offsets in the same
|
|
sname:VkDeviceMemory object without aliasing. See
|
|
<<resources-bufferimagegranularity,Buffer-Image Granularity>> for more
|
|
details.
|
|
* [[features-limits-sparseAddressSpaceSize]] pname: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 size of all
|
|
sparse resources, regardless of whether any memory is bound to them.
|
|
* [[features-limits-maxBoundDescriptorSets]] pname:maxBoundDescriptorSets
|
|
is the maximum number of descriptor sets that can: be simultaneously
|
|
used by a pipeline. All code:DescriptorSet decorations in shader modules
|
|
must: have a value less than pname:maxBoundDescriptorSets. See
|
|
<<descriptorsets-sets>>.
|
|
* [[features-limits-maxPerStageDescriptorSamplers]]
|
|
pname:maxPerStageDescriptorSamplers is the maximum number of samplers
|
|
that can: be accessible to a single shader stage in a pipeline layout.
|
|
Descriptors with a type of ename:VK_DESCRIPTOR_TYPE_SAMPLER or
|
|
ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this
|
|
limit. A descriptor is accessible to a shader stage when the
|
|
pname:stageFlags member of the sname:VkDescriptorSetLayoutBinding
|
|
structure has the bit for that shader stage set. See
|
|
<<descriptorsets-sampler>> and <<descriptorsets-combinedimagesampler>>.
|
|
* [[features-limits-maxPerStageDescriptorUniformBuffers]]
|
|
pname:maxPerStageDescriptorUniformBuffers is the maximum number of
|
|
uniform buffers that can: be accessible to a single shader stage in a
|
|
pipeline layout. Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this
|
|
limit. A descriptor is accessible to a shader stage when the
|
|
pname:stageFlags member of the sname:VkDescriptorSetLayoutBinding
|
|
structure has the bit for that shader stage set. See
|
|
<<descriptorsets-uniformbuffer>> and
|
|
<<descriptorsets-uniformbufferdynamic>>.
|
|
* [[features-limits-maxPerStageDescriptorStorageBuffers]]
|
|
pname:maxPerStageDescriptorStorageBuffers is the maximum number of
|
|
storage buffers that can: be accessible to a single shader stage in a
|
|
pipeline layout. Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this
|
|
limit. A descriptor is accessible to a pipeline shader stage when the
|
|
pname:stageFlags member of the sname:VkDescriptorSetLayoutBinding
|
|
structure has the bit for that shader stage set. See
|
|
<<descriptorsets-storagebuffer>> and
|
|
<<descriptorsets-storagebufferdynamic>>.
|
|
* [[features-limits-maxPerStageDescriptorSampledImages]]
|
|
pname:maxPerStageDescriptorSampledImages is the maximum number of
|
|
sampled images that can: be accessible to a single shader stage in a
|
|
pipeline layout. Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, or
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit.
|
|
A descriptor is accessible to a pipeline shader stage when the
|
|
pname:stageFlags member of the sname:VkDescriptorSetLayoutBinding
|
|
structure has the bit for that shader stage set. See
|
|
<<descriptorsets-combinedimagesampler>>,
|
|
<<descriptorsets-sampledimage>>, and
|
|
<<descriptorsets-uniformtexelbuffer>>.
|
|
* [[features-limits-maxPerStageDescriptorStorageImages]]
|
|
pname:maxPerStageDescriptorStorageImages is the maximum number of
|
|
storage images that can: be accessible to a single shader stage in a
|
|
pipeline layout. Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit.
|
|
A descriptor is accessible to a pipeline shader stage when the
|
|
pname:stageFlags member of the sname:VkDescriptorSetLayoutBinding
|
|
structure has the bit for that shader stage set. See
|
|
<<descriptorsets-storageimage>>, and
|
|
<<descriptorsets-storagetexelbuffer>>.
|
|
* [[features-limits-maxPerStageDescriptorInputAttachments]]
|
|
pname:maxPerStageDescriptorInputAttachments is the maximum number of
|
|
input attachments that can: be accessible to a single shader stage in a
|
|
pipeline layout. Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit.
|
|
A descriptor is accessible to a pipeline shader stage when the
|
|
pname:stageFlags member of the sname:VkDescriptorSetLayoutBinding
|
|
structure has the bit for that shader stage set. These are only
|
|
supported for the fragment stage. See
|
|
<<descriptorsets-inputattachment>>.
|
|
* [[features-limits-maxPerStageResources]] pname:maxPerStageResources is
|
|
the maximum number of resources that can: be accessible to a single
|
|
shader stage in a pipeline layout. Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, or
|
|
ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. For
|
|
the fragment shader stage the framebuffer color attachments also count
|
|
against this limit.
|
|
* [[features-limits-maxDescriptorSetSamplers]]
|
|
pname:maxDescriptorSetSamplers is the maximum number of samplers that
|
|
can: be included in descriptor bindings in a pipeline layout across all
|
|
pipeline shader stages and descriptor set numbers. Descriptors with a
|
|
type of ename:VK_DESCRIPTOR_TYPE_SAMPLER or
|
|
ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this
|
|
limit. See <<descriptorsets-sampler>> and
|
|
<<descriptorsets-combinedimagesampler>>.
|
|
* [[features-limits-maxDescriptorSetUniformBuffers]]
|
|
pname:maxDescriptorSetUniformBuffers is the maximum number of uniform
|
|
buffers that can: be included in descriptor bindings in a pipeline
|
|
layout across all pipeline shader stages and descriptor set numbers.
|
|
Descriptors with a type of ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this
|
|
limit. See <<descriptorsets-uniformbuffer>> and
|
|
<<descriptorsets-uniformbufferdynamic>>.
|
|
* [[features-limits-maxDescriptorSetUniformBuffersDynamic]]
|
|
pname:maxDescriptorSetUniformBuffersDynamic is the maximum number of
|
|
dynamic uniform buffers that can: be included in descriptor bindings in
|
|
a pipeline layout across all pipeline shader stages and descriptor set
|
|
numbers. Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this
|
|
limit. See <<descriptorsets-uniformbufferdynamic>>.
|
|
* [[features-limits-maxDescriptorSetStorageBuffers]]
|
|
pname:maxDescriptorSetStorageBuffers is the maximum number of storage
|
|
buffers that can: be included in descriptor bindings in a pipeline
|
|
layout across all pipeline shader stages and descriptor set numbers.
|
|
Descriptors with a type of ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this
|
|
limit. See <<descriptorsets-storagebuffer>> and
|
|
<<descriptorsets-storagebufferdynamic>>.
|
|
* [[features-limits-maxDescriptorSetStorageBuffersDynamic]]
|
|
pname:maxDescriptorSetStorageBuffersDynamic is the maximum number of
|
|
dynamic storage buffers that can: be included in descriptor bindings
|
|
in a pipeline layout across all pipeline shader stages and descriptor
|
|
set numbers. Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this
|
|
limit. See <<descriptorsets-storagebufferdynamic>>.
|
|
* [[features-limits-maxDescriptorSetSampledImages]]
|
|
pname:maxDescriptorSetSampledImages is the maximum number of sampled
|
|
images that can: be included in descriptor bindings in a pipeline
|
|
layout across all pipeline shader stages and descriptor set numbers.
|
|
Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, or
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit.
|
|
See <<descriptorsets-combinedimagesampler>>,
|
|
<<descriptorsets-sampledimage>>, and
|
|
<<descriptorsets-uniformtexelbuffer>>.
|
|
* [[features-limits-maxDescriptorSetStorageImages]]
|
|
pname:maxDescriptorSetStorageImages is the maximum number of storage
|
|
images that can: be included in descriptor bindings in a pipeline
|
|
layout across all pipeline shader stages and descriptor set numbers.
|
|
Descriptors with a type of ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit.
|
|
See <<descriptorsets-storageimage>>, and
|
|
<<descriptorsets-storagetexelbuffer>>.
|
|
* [[features-limits-maxDescriptorSetInputAttachments]]
|
|
pname:maxDescriptorSetInputAttachments is the maximum number of input
|
|
attachments that can: be included in descriptor bindings in a
|
|
pipeline layout across all pipeline shader stages and descriptor set
|
|
numbers. Descriptors with a type of
|
|
ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. See
|
|
<<descriptorsets-inputattachment>>.
|
|
* [[features-limits-maxVertexInputAttributes]]
|
|
pname:maxVertexInputAttributes is the maximum number of vertex input
|
|
attributes that can: be specified for a graphics pipeline. These are
|
|
described in the array of sname:VkVertexInputAttributeDescription
|
|
structures that are provided at graphics pipeline creation time via the
|
|
pname:pVertexAttributeDescriptions member of the
|
|
sname:VkPipelineVertexInputStateCreateInfo structure. See
|
|
<<fxvertex-attrib>> and <<fxvertex-input>>.
|
|
* [[features-limits-maxVertexInputBindings]]
|
|
pname:maxVertexInputBindings is the maximum number of vertex buffers
|
|
that can: be specified for providing vertex attributes to a graphics
|
|
pipeline. These are described in the array of
|
|
sname:VkVertexInputBindingDescription structures that are provided at
|
|
graphics pipeline creation time via the pname:pVertexBindingDescriptions
|
|
member of the sname:VkPipelineVertexInputStateCreateInfo structure. The
|
|
pname:binding member of sname:VkVertexInputBindingDescription must: be
|
|
less than this limit. See <<fxvertex-input>>.
|
|
* [[features-limits-maxVertexInputAttributeOffset]]
|
|
pname:maxVertexInputAttributeOffset is the maximum vertex input
|
|
attribute offset that can: be added to the vertex input binding stride.
|
|
The pname:offset member of the sname:VkVertexInputAttributeDescription
|
|
structure must: be less than or equal to this limit. See
|
|
<<fxvertex-input>>.
|
|
* [[features-limits-maxVertexInputBindingStride]]
|
|
pname:maxVertexInputBindingStride is the maximum vertex input binding
|
|
stride that can: be specified in a vertex input binding. The
|
|
pname:stride member of the sname:VkVertexInputBindingDescription
|
|
structure must: be less than or equal to this limit. See
|
|
<<fxvertex-input>>.
|
|
* [[features-limits-maxVertexOutputComponents]]
|
|
pname:maxVertexOutputComponents is the maximum number of components of
|
|
output variables which can: be output by a vertex shader. See
|
|
<<shaders-vertex>>.
|
|
* [[features-limits-maxTessellationGenerationLevel]]
|
|
pname:maxTessellationGenerationLevel is the maximum tessellation
|
|
generation level supported by the fixed-function tessellation primitive
|
|
generator. See <<tessellation>>.
|
|
* [[features-limits-maxTessellationPatchSize]]
|
|
pname:maxTessellationPatchSize is the maximum patch size, in vertices,
|
|
of patches that can: be processed by the tessellation control shader and
|
|
tessellation primitive generator. The
|
|
pname:patchControlPoints member of the
|
|
sname:VkPipelineTessellationStateCreateInfo structure specified at
|
|
pipeline creation time and the value provided in the code:OutputVertices
|
|
execution mode of shader modules must: be less than or equal to this
|
|
limit. See <<tessellation>>.
|
|
* [[features-limits-maxTessellationControlPerVertexInputComponents]]
|
|
pname:maxTessellationControlPerVertexInputComponents is the maximum
|
|
number of components of input variables which can: be provided as
|
|
per-vertex inputs to the tessellation control shader stage.
|
|
* [[features-limits-maxTessellationControlPerVertexOutputComponents]]
|
|
pname:maxTessellationControlPerVertexOutputComponents is the maximum
|
|
number of components of per-vertex output variables which can: be output
|
|
from the tessellation control shader stage.
|
|
* [[features-limits-maxTessellationControlPerPatchOutputComponents]]
|
|
pname:maxTessellationControlPerPatchOutputComponents is the maximum
|
|
number of components of per-patch output variables which can: be output
|
|
from the tessellation control shader stage.
|
|
* [[features-limits-maxTessellationControlTotalOutputComponents]]
|
|
pname: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.
|
|
* [[features-limits-maxTessellationEvaluationInputComponents]]
|
|
pname:maxTessellationEvaluationInputComponents is the maximum number of
|
|
components of input variables which can: be provided as per-vertex
|
|
inputs to the tessellation evaluation shader stage.
|
|
* [[features-limits-maxTessellationEvaluationOutputComponents]]
|
|
pname:maxTessellationEvaluationOutputComponents is the maximum number of
|
|
components of per-vertex output variables which can: be output from the
|
|
tessellation evaluation shader stage.
|
|
* [[features-limits-maxGeometryShaderInvocations]]
|
|
pname:maxGeometryShaderInvocations is the maximum invocation count
|
|
supported for instanced geometry shaders. The value provided in the
|
|
code:Invocations execution mode of shader modules must: be less than
|
|
or equal to this limit. See <<geometry>>.
|
|
* [[features-limits-maxGeometryInputComponents]]
|
|
pname:maxGeometryInputComponents is the maximum number of components of
|
|
input variables which can: be provided as inputs to the geometry shader
|
|
stage.
|
|
* [[features-limits-maxGeometryOutputComponents]]
|
|
pname:maxGeometryOutputComponents is the maximum number of components of
|
|
output variables which can: be output from the geometry shader stage.
|
|
* [[features-limits-maxGeometryOutputVertices]]
|
|
pname:maxGeometryOutputVertices is the maximum number of vertices which
|
|
can: be emitted by any geometry shader.
|
|
* [[features-limits-maxGeometryTotalOutputComponents]]
|
|
pname:maxGeometryTotalOutputComponents is the maximum total number of
|
|
components of output, across all emitted vertices, which can: be output
|
|
from the geometry shader stage.
|
|
* [[features-limits-maxFragmentInputComponents]]
|
|
pname:maxFragmentInputComponents is the maximum number of components of
|
|
input variables which can: be provided as inputs to the fragment shader
|
|
stage.
|
|
* [[features-limits-maxFragmentOutputAttachments]]
|
|
pname:maxFragmentOutputAttachments is the maximum number of output
|
|
attachments which can: be written to by the fragment shader stage.
|
|
* [[features-limits-maxFragmentDualSrcAttachments]]
|
|
pname: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 <<framebuffer-dsb>> and
|
|
<<features-features-dualSrcBlend,dualSrcBlend>>.
|
|
* [[features-limits-maxFragmentCombinedOutputResources]]
|
|
pname:maxFragmentCombinedOutputResources is the total number of storage
|
|
buffers, storage images, and output buffers which can: be used in the
|
|
fragment shader stage.
|
|
* [[features-limits-maxComputeSharedMemorySize]]
|
|
pname:maxComputeSharedMemorySize is the maximum total storage size, in
|
|
bytes, of all variables declared with the code:WorkgroupLocal storage
|
|
class in shader modules (or with the code:shared storage qualifier in
|
|
GLSL) in the compute shader stage.
|
|
* [[features-limits-maxComputeWorkGroupCount]]
|
|
pname:maxComputeWorkGroupCount[3] is the maximum number of local workgroups
|
|
that can: be dispatched by a single dispatch command. These three values
|
|
represent the maximum number of local workgroups for the X, Y, and Z
|
|
dimensions, respectively. The pname:x, pname:y, and pname:z parameters
|
|
to the flink:vkCmdDispatch command, or members of the
|
|
slink:VkDispatchIndirectCommand structure must: be less than or equal to
|
|
the corresponding limit. See <<dispatch>>.
|
|
* [[features-limits-maxComputeWorkGroupInvocations]]
|
|
pname:maxComputeWorkGroupInvocations is the maximum total number of
|
|
compute shader invocations in a single local workgroup. The product of
|
|
the X, Y, and Z sizes as specified by the code:LocalSize execution mode
|
|
in shader modules and by the object decorated by the code:WorkgroupSize
|
|
decoration must: be less than or equal to this limit.
|
|
* [[features-limits-maxComputeWorkGroupSize]]
|
|
pname:maxComputeWorkGroupSize[3] is the maximum size of a local compute
|
|
workgroup, per dimension. These three values represent the maximum
|
|
local workgroup size in the X, Y, and Z dimensions, respectively. The
|
|
pname:x, pname:y, and pname:z sizes specified by the code:LocalSize
|
|
execution mode and by the object decorated by the code:WorkgroupSize
|
|
decoration in shader modules must: be less than or equal to the
|
|
corresponding limit.
|
|
* [[features-limits-subPixelPrecisionBits]] pname:subPixelPrecisionBits is
|
|
the number of bits of subpixel precision in framebuffer coordinates
|
|
latexmath:[$x_f$] and latexmath:[$y_f$]. See <<primsrast>>.
|
|
* [[features-limits-subTexelPrecisionBits]] pname:subTexelPrecisionBits is
|
|
the number of bits of precision in the division along an axis of an
|
|
image used for minification and magnification filters.
|
|
latexmath:[$2^\mathit{subTexelPrecisionBits}$] is the actual number of
|
|
divisions along each axis of the image represented. The filtering
|
|
hardware will snap to these locations when computing the filtered
|
|
results.
|
|
* [[features-limits-mipmapPrecisionBits]] pname:mipmapPrecisionBits is the
|
|
number of bits of division that the LOD calculation for mipmap fetching
|
|
get snapped to when determining the contribution from each miplevel to
|
|
the mip filtered results. latexmath:[$2^\mathit{mipmapPrecisionBits}$] is
|
|
the actual number of divisions.
|
|
+
|
|
--
|
|
[NOTE]
|
|
.Note
|
|
====
|
|
For example, if this value is 2 bits then when linearly filtering between
|
|
two levels, each level could: contribute: 0%, 33%, 66%, or 100% (this is
|
|
just an example and the amount of contribution should: be covered by
|
|
different equations in the spec).
|
|
====
|
|
--
|
|
+
|
|
* [[features-limits-maxDrawIndexedIndexValue]]
|
|
pname:maxDrawIndexedIndexValue is the maximum index value that can: be
|
|
used for indexed draw calls when using 32-bit indices. This excludes the
|
|
primitive restart index value of 0xFFFFFFFF. See
|
|
<<features-features-fullDrawIndexUint32,fullDrawIndexUint32>>.
|
|
* [[features-limits-maxDrawIndirectCount]] pname:maxDrawIndirectCount is
|
|
the maximum draw count that is supported for indirect draw calls. See
|
|
<<features-features-multiDrawIndirect,multiDrawIndirect>>.
|
|
* [[features-limits-maxSamplerLodBias]] pname:maxSamplerLodBias is the
|
|
maximum absolute sampler level of detail bias. The sum of the
|
|
pname:mipLodBias member of the sname:VkSamplerCreateInfo structure and
|
|
the code:Bias operand of image sampling operations in shader modules (or
|
|
0 if no code:Bias operand is provided to an image sampling operation)
|
|
are clamped to the range
|
|
latexmath:[$[-\mathit{maxSamplerLodBias},+\mathit{maxSamplerLodBias}\]$].
|
|
See <<samplers-mipLodBias>>.
|
|
* [[features-limits-maxSamplerAnisotropy]] pname:maxSamplerAnisotropy is
|
|
the maximum degree of sampler anisotropy. The maximum degree of
|
|
anisotropic filtering used for an image sampling operation is the
|
|
minimum of the pname:maxAnisotropy member of the
|
|
sname:VkSamplerCreateInfo structure and this limit. See
|
|
<<samplers-maxAnisotropy>>.
|
|
* [[features-limits-maxViewports]] pname:maxViewports is the maximum
|
|
number of active viewports. The pname:viewportCount member of the
|
|
sname:VkPipelineViewportStateCreateInfo structure that is provided at
|
|
pipeline creation must: be less than or equal to this limit.
|
|
* [[features-limits-maxViewportDimensions]] pname: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
|
|
<<vertexpostproc-viewport,Controlling the Viewport>>.
|
|
* [[features-limits-viewportboundsrange]] pname:viewportBoundsRange[2] is
|
|
the latexmath:[$[\mathit{minimum},\mathit{maximum}\]$] range that the
|
|
corners of a viewport must: be contained in. This range must: be at
|
|
least latexmath:[$[- 2 \times \mathit{maxViewportDimensions},
|
|
2 \times \mathit{maxViewportDimensions} - 1\]$].
|
|
See <<vertexpostproc-viewport,Controlling the Viewport>>.
|
|
+
|
|
--
|
|
[NOTE]
|
|
.Note
|
|
====
|
|
The intent of the pname: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
|
|
latexmath:[$[- \mathit{maxViewportDimensions}+1,
|
|
2 \times \mathit{maxViewportDimensions} -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 smalled possible number of bits, ends up with the specified
|
|
range.
|
|
====
|
|
--
|
|
* [[features-limits-viewportSubPixelBits]] pname: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.
|
|
* [[features-limits-minMemoryMapAlignment]] pname:minMemoryMapAlignment is
|
|
the minimum required alignment, in bytes, of host visible memory
|
|
allocations within the host address space. When mapping a memory
|
|
allocation with flink:vkMapMemory, subtracting pname:offset bytes from
|
|
the returned pointer will always produce an integer multiple of this
|
|
limit. See <<memory-device-hostaccess>>.
|
|
* [[features-limits-minTexelBufferOffsetAlignment]]
|
|
pname:minTexelBufferOffsetAlignment is the minimum required alignment,
|
|
in bytes, for the pname:offset member of the
|
|
sname:VkBufferViewCreateInfo structure for texel buffers. When a buffer
|
|
view is created for a buffer which was created with
|
|
ename:VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or
|
|
ename:VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set in the pname:usage
|
|
member of the sname:VkBufferCreateInfo structure, the pname:offset must:
|
|
be an integer multiple of this limit.
|
|
* [[features-limits-minUniformBufferOffsetAlignment]]
|
|
pname:minUniformBufferOffsetAlignment is the minimum required alignment,
|
|
in bytes, for the pname:offset member of the
|
|
sname:VkDescriptorBufferInfo structure for uniform buffers. When a
|
|
descriptor of type ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC is updated, the
|
|
pname:offset must: be an integer multiple of this limit. Similarly,
|
|
dynamic offsets for uniform buffers must: be multiples of this limit.
|
|
* [[features-limits-minStorageBufferOffsetAlignment]]
|
|
pname:minStorageBufferOffsetAlignment is the minimum required alignment,
|
|
in bytes, for the pname:offset member of the
|
|
sname:VkDescriptorBufferInfo structure for storage buffers. When a
|
|
descriptor of type ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC is updated, the
|
|
pname:offset must: be an integer multiple of this limit. Similarly,
|
|
dynamic offsets for storage buffers must: be multiples of this limit.
|
|
* [[features-limits-minTexelOffset]] pname:minTexelOffset is the minimum
|
|
offset value for the code:ConstOffset image operand of any of the
|
|
code:OpImageSample* or code:OpImageFetch* image instructions.
|
|
* [[features-limits-maxTexelOffset]] pname:maxTexelOffset is the maximum
|
|
offset value for the code:ConstOffset image operand of any of the
|
|
code:OpImageSample* or code:OpImageFetch* image instructions.
|
|
* [[features-limits-minTexelGatherOffset]] pname:minTexelGatherOffset is
|
|
the minimum offset value for the code:Offset or code:ConstOffsets image
|
|
operands of any of the code:OpImage*code:Gather image instructions.
|
|
* [[features-limits-maxTexelGatherOffset]] pname:maxTexelGatherOffset is
|
|
the maximum offset value for the code:Offset or code:ConstOffsets image
|
|
operands of any of the code:OpImage*code:Gather image instructions.
|
|
* [[features-limits-minInterpolationOffset]] pname:minInterpolationOffset
|
|
is the minimum negative offset value for the code:offset operand of the
|
|
code:InterpolateAtOffset extended instruction.
|
|
* [[features-limits-maxInterpolationOffset]] pname:maxInterpolationOffset
|
|
is the maximum positive offset value for the code:offset operand of the
|
|
code:InterpolateAtOffset extended instruction.
|
|
* [[features-limits-subPixelInterpolationOffsetBits]]
|
|
pname:subPixelInterpolationOffsetBits is the number of subpixel
|
|
fractional bits that the code:x and code:y offsets to the
|
|
code:InterpolateAtOffset extended instruction may: be rounded to as
|
|
fixed-point values.
|
|
* [[features-limits-maxFramebufferWidth]] pname:maxFramebufferWidth is the
|
|
maximum width for a framebuffer. The pname:width member of the
|
|
sname:VkFramebufferCreateInfo structure must: be less than or equal to
|
|
this limit.
|
|
* [[features-limits-maxFramebufferHeight]] pname:maxFramebufferHeight is
|
|
the maximum height for a framebuffer. The pname:height member of the
|
|
sname:VkFramebufferCreateInfo structure must: be less than or equal to
|
|
this limit.
|
|
* [[features-limits-maxFramebufferLayers]] pname:maxFramebufferLayers is
|
|
the maximum layer count for a layered framebuffer. The pname:layers
|
|
member of the sname:VkFramebufferCreateInfo structure must: be less than
|
|
or equal to this limit.
|
|
* [[features-limits-framebufferColorSampleCounts]]
|
|
pname:framebufferColorSampleCounts is a bitmask^1^ of
|
|
elink:VkSampleCountFlagBits bits indicating the color sample counts that
|
|
are supported for all framebuffer color attachments.
|
|
* [[features-limits-framebufferDepthSampleCounts]]
|
|
pname:framebufferDepthSampleCounts is a bitmask^1^ of
|
|
elink:VkSampleCountFlagBits bits indicating the supported depth sample
|
|
counts for all framebuffer depth/stencil attachments, when the format
|
|
includes a depth component.
|
|
* pname:framebufferStencilSampleCounts is a bitmask^1^ of
|
|
elink:VkSampleCountFlagBits bits indicating the supported stencil sample
|
|
counts for all framebuffer depth/stencil attachments, when the format
|
|
includes a stencil component.
|
|
* pname:framebufferNoAttachmentsSampleCounts is a bitmask^1^ of
|
|
elink:VkSampleCountFlagBits bits indicating the supported sample counts
|
|
for a framebuffer with no attachments.
|
|
* [[features-limits-maxColorAttachments]] pname:maxColorAttachments is the
|
|
maximum number of color attachments that can: be used by a subpass in a
|
|
render pass. The pname:colorAttachmentCount member of the
|
|
sname:VkSubpassDescription structure must: be less than or equal to this
|
|
limit.
|
|
* [[features-limits-sampledImageColorSampleCounts]]
|
|
pname:sampledImageColorSampleCounts is a bitmask^1^ of
|
|
elink:VkSampleCountFlagBits bits indicating the sample counts supported
|
|
for all 2D images created with ename:VK_IMAGE_TILING_OPTIMAL, pname:usage
|
|
containing ename:VK_IMAGE_USAGE_SAMPLED_BIT, and a non-integer color
|
|
format.
|
|
* [[features-limits-sampledImageIntegerSampleCounts]]
|
|
pname:sampledImageIntegerSampleCounts is a bitmask^1^ of
|
|
elink:VkSampleCountFlagBits bits indicating the sample counts supported
|
|
for all 2D images created with ename:VK_IMAGE_TILING_OPTIMAL, pname:usage
|
|
containing ename:VK_IMAGE_USAGE_SAMPLED_BIT, and an integer color
|
|
format.
|
|
* [[features-limits-sampledImageDepthSampleCounts]]
|
|
pname:sampledImageDepthSampleCounts is a bitmask^1^ of
|
|
elink:VkSampleCountFlagBits bits indicating the sample counts supported
|
|
for all 2D images created with ename:VK_IMAGE_TILING_OPTIMAL, pname:usage
|
|
containing ename:VK_IMAGE_USAGE_SAMPLED_BIT, and a depth format.
|
|
* [[features-limits-sampledImageStencilSampleCounts]]
|
|
pname:sampledImageStencilSampleCounts is a bitmask^1^ of
|
|
elink:VkSampleCountFlagBits bits indicating the sample supported
|
|
for all 2D images created with ename:VK_IMAGE_TILING_OPTIMAL, pname:usage
|
|
containing ename:VK_IMAGE_USAGE_SAMPLED_BIT, and a stencil format.
|
|
* [[features-limits-storageImageSampleCounts]]
|
|
pname:storageImageSampleCounts is a bitmask^1^ of
|
|
elink:VkSampleCountFlagBits bits indicating the sample counts supported
|
|
for all 2D images created with ename:VK_IMAGE_TILING_OPTIMAL, and
|
|
pname:usage containing ename:VK_IMAGE_USAGE_STORAGE_BIT.
|
|
* [[features-limits-maxSampleMaskWords]] pname:maxSampleMaskWords is the
|
|
maximum number of array elements of a variable decorated with the
|
|
code:SampleMask built-in decoration.
|
|
* [[features-limits-timestampComputeAndGraphics]]
|
|
pname:timestampComputeAndGraphics indicates support for timestamps on
|
|
all graphics and compute queues. If this limit is set to ename:VK_TRUE,
|
|
all queues that advertise the ename:VK_QUEUE_GRAPHICS_BIT or
|
|
ename:VK_QUEUE_COMPUTE_BIT in the
|
|
sname:VkQueueFamilyProperties::pname:queueFlags support
|
|
sname:VkQueueFamilyProperties::pname:timestampValidBits of at least 36.
|
|
See <<queries-timestamps, Timestamp Queries>>.
|
|
* [[features-limits-timestampPeriod]] pname:timestampPeriod is the number
|
|
of nanoseconds required for a timestamp query to be incremented by 1.
|
|
See <<queries-timestamps, Timestamp Queries>>.
|
|
* [[features-limits-maxClipDistances]] pname:maxClipDistances is the
|
|
maximum number of clip distances that can: be used in a single shader
|
|
stage. The size of any array declared with the code:ClipDistance
|
|
built-in decoration in a shader module must: be less than or equal to
|
|
this limit.
|
|
* [[features-limits-maxCullDistances]] pname:maxCullDistances is the
|
|
maximum number of cull distances that can: be used in a single shader
|
|
stage. The size of any array declared with the code:CullDistance
|
|
built-in decoration in a shader module must: be less than or equal to
|
|
this limit.
|
|
* [[features-limits-maxCombinedClipAndCullDistances]]
|
|
pname:maxCombinedClipAndCullDistances is the maximum combined number of
|
|
clip and cull distances that can: be used in a single shader stage.
|
|
The sum of the sizes of any pair of arrays declared with the
|
|
code:ClipDistance and code:CullDistance built-in decoration used by
|
|
a single shader stage in a shader module must: be less than or equal to
|
|
this limit.
|
|
* [[features-limits-discreteQueuePriorities]]
|
|
pname:discreteQueuePriorities is the number of discrete priorities that
|
|
can: be assigned to a queue based on the value of each member of
|
|
sname:VkDeviceQueueCreateInfo::pname: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 <<devsandqueues-priority>>.
|
|
* [[features-limits-pointSizeRange]] pname:pointSizeRange[2] is the range
|
|
latexmath:[$[\mathit{minimum},\mathit{maximum}\]$] of supported sizes
|
|
for points. Values written to variables decorated with the
|
|
code:PointSize built-in decoration are clamped to this range.
|
|
* [[features-limits-lineWidthRange]] pname:lineWidthRange[2] is the range
|
|
latexmath:[$[\mathit{minimum},\mathit{maximum}\]$] of supported widths
|
|
for lines. Values specified by the pname:lineWidth member of the
|
|
sname:VkPipelineRasterizationStateCreateInfo or the pname:lineWidth
|
|
parameter to fname:vkCmdSetLineWidth are clamped to this range.
|
|
* [[features-limits-pointSizeGranularity]] pname:pointSizeGranularity is
|
|
the granularity of supported point sizes. Not all point sizes in the
|
|
range defined by pname:pointSizeRange are supported. This limit
|
|
specifies the granularity (or increment) between successive supported
|
|
point sizes.
|
|
* [[features-limits-lineWidthGranularity]] pname:lineWidthGranularity is
|
|
the granularity of supported line widths. Not all line widths in the
|
|
range defined by pname:lineWidthRange are supported. This limit
|
|
specifies the granularity (or increment) between successive supported
|
|
line widths.
|
|
* [[features-limits-strictLines]] pname:strictLines indicates whether
|
|
lines are rasterized according to the preferred method of rasterization.
|
|
If set to ename:VK_FALSE, lines may: be rasterized under a relaxed set
|
|
of rules. If set to ename:VK_TRUE, lines are rasterized as per the
|
|
strict definition. See <<primsrast-lines-basic,Basic Line Segment
|
|
Rasterization>>.
|
|
* [[features-limits-standardSampleLocations]]
|
|
pname:standardSampleLocations indicates whether rasterization uses the
|
|
standard sample locations as documented in
|
|
<<primsrast-multisampling,Multisampling>>. If set to ename:VK_TRUE, the
|
|
implementation uses the documented sample locations. If set to
|
|
ename:VK_FALSE, the implementation may: use different sample locations.
|
|
* [[features-limits-optimalBufferCopyOffsetAlignment]]
|
|
pname:optimalBufferCopyOffsetAlignment is the optimal buffer
|
|
offset alignment in bytes for fname:vkCmdCopyBufferToImage and
|
|
fname:vkCmdCopyImageToBuffer. The per texel alignment requirements are
|
|
still enforced, this is just an additional alignment recommendation for
|
|
optimal performance and power.
|
|
* [[features-limits-optimalBufferCopyRowPitchAlignment]]
|
|
pname:optimalBufferCopyRowPitchAlignment is the optimal buffer
|
|
row pitch alignment in bytes for fname:vkCmdCopyBufferToImage and
|
|
fname: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 still enforced, this
|
|
is just an additional alignment recommendation for optimal performance
|
|
and power.
|
|
* [[features-limits-nonCoherentAtomSize]]
|
|
pname:nonCoherentAtomSize is the size and alignment in bytes that bounds
|
|
concurrent access to
|
|
<<memory-device-hostaccess, host-mapped device memory>>.
|
|
|
|
|
|
Description
|
|
-----------
|
|
|
|
// End of list
|
|
|
|
1::
|
|
For all bitmasks of type elink:VkSampleCountFlags above, possible
|
|
values include:
|
|
+
|
|
--
|
|
// refBegin VkSampleCountFlagBits - Bitmask specifying sample counts supported for an image used for storage operations
|
|
include::../api/enums/VkSampleCountFlagBits.txt[]
|
|
--
|
|
+
|
|
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
|
|
flink:vkGetPhysicalDeviceImageFormatProperties as described
|
|
in <<features-supported-sample-counts, Supported Sample Counts>>.
|
|
|
|
include::../validity/structs/VkPhysicalDeviceLimits.txt[]
|
|
|
|
|
|
See Also
|
|
--------
|
|
|
|
basetype:VkBool32, basetype:VkDeviceSize, slink:VkPhysicalDeviceProperties, elink:VkSampleCountFlags
|
|
|
|
|
|
Document Notes
|
|
--------------
|
|
|
|
For more information, see the Vulkan Specification at URL
|
|
|
|
https://www.khronos.org/registry/vulkan/specs/1.0/xhtml/vkspec.html#VkPhysicalDeviceLimits
|
|
|
|
This page is extracted from the Vulkan Specification.
|
|
Fixes and changes should be made to the Specification,not directly.
|
|
|
|
include::footer.txt[]
|
|
|