4687 lines
240 KiB
Plaintext
4687 lines
240 KiB
Plaintext
// Copyright (c) 2015-2017 The Khronos Group Inc.
|
|
// Copyright notice at https://www.khronos.org/registry/speccopyright.html
|
|
|
|
[[features]]
|
|
= Features, Limits, and Formats
|
|
|
|
Vulkan is designed to support a wide range of hardware and as such there are
|
|
a number of features, limits, and formats which are not supported on all
|
|
hardware.
|
|
Features describe functionality that is not required: and which must: be
|
|
explicitly enabled.
|
|
Limits describe implementation-dependent minimums, maximums, and other
|
|
device characteristics that an application may: need to be aware of.
|
|
Supported buffer and image formats may: vary across implementations.
|
|
A minimum set of format features are guaranteed, but others must: be
|
|
explicitly queried before use to ensure they are supported by the
|
|
implementation.
|
|
|
|
[NOTE]
|
|
.Note on extensibility
|
|
====
|
|
The features and limits are reported via basic structures (that is
|
|
slink:VkPhysicalDeviceFeatures and slink:VkPhysicalDeviceLimits), as well as
|
|
extensible structures (sname:VkPhysicalDeviceFeatures2KHR and
|
|
sname:VkPhysicalDeviceProperties2KHR) which were added in
|
|
code:VK_KHR_get_physical_device_properties2.
|
|
When new features or limits are added in future Vulkan version or
|
|
extensions, each extension should: introduce one new feature structure
|
|
and/or limit structure (as needed).
|
|
These structures can: be added to the pname:pNext chain of the
|
|
sname:VkPhysicalDeviceFeatures2KHR and sname:VkPhysicalDeviceProperties2KHR
|
|
structures, respectively.
|
|
====
|
|
|
|
[[features-features]]
|
|
== Features
|
|
|
|
The Specification defines a set of fine-grained features that are not
|
|
required:, but may: be supported by a Vulkan implementation.
|
|
Support for features is reported and enabled on a per-feature basis.
|
|
Features are properties of the physical device.
|
|
|
|
// refBegin vkGetPhysicalDeviceFeatures Reports capabilities of a physical device
|
|
|
|
To query supported features, call:
|
|
|
|
include::../api/protos/vkGetPhysicalDeviceFeatures.txt[]
|
|
|
|
* pname:physicalDevice is the physical device from which to query the
|
|
supported features.
|
|
* pname:pFeatures is a pointer to a slink:VkPhysicalDeviceFeatures
|
|
structure in which the physical device features are returned.
|
|
For each feature, a value of ename:VK_TRUE indicates that the feature is
|
|
supported on this physical device, and ename:VK_FALSE indicates that the
|
|
feature is not supported.
|
|
|
|
include::../validity/protos/vkGetPhysicalDeviceFeatures.txt[]
|
|
|
|
Fine-grained features used by a logical device must: be enabled at
|
|
sname:VkDevice creation time.
|
|
If a feature is enabled that the physical device does not support,
|
|
sname:VkDevice creation will fail.
|
|
If an application uses a feature without enabling it at sname:VkDevice
|
|
creation time, the device behavior is undefined.
|
|
The validation layer will warn if features are used without being enabled.
|
|
|
|
The fine-grained features are enabled by passing a pointer to the
|
|
sname:VkPhysicalDeviceFeatures structure via the pname:pEnabledFeatures
|
|
member of the sname:VkDeviceCreateInfo structure that is passed into the
|
|
fname:vkCreateDevice call.
|
|
If a member of pname:pEnabledFeatures is set to ename:VK_TRUE or
|
|
ename:VK_FALSE, then the device will be created with the indicated feature
|
|
enabled or disabled, respectively.
|
|
ifdef::VK_KHR_get_physical_device_properties2[]
|
|
Features can: also be enabled by using the
|
|
slink:VkPhysicalDeviceFeatures2KHR structure.
|
|
endif::VK_KHR_get_physical_device_properties2[]
|
|
|
|
If an application wishes to enable all features supported by a device, it
|
|
can: simply pass in the sname:VkPhysicalDeviceFeatures structure that was
|
|
previously returned by fname:vkGetPhysicalDeviceFeatures.
|
|
To disable an individual feature, the application can: set the desired
|
|
member to ename:VK_FALSE in the same structure.
|
|
Setting pname:pEnabledFeatures to `NULL`
|
|
ifdef::VK_KHR_get_physical_device_properties2[]
|
|
and not including a slink:VkPhysicalDeviceFeatures2KHR in the pname:pNext
|
|
member of slink:VkDeviceCreateInfo
|
|
endif::VK_KHR_get_physical_device_properties2[]
|
|
is equivalent to setting all members of the structure to ename:VK_FALSE.
|
|
|
|
[NOTE]
|
|
.Note
|
|
====
|
|
Some features, such as pname:robustBufferAccess, may: incur a run-time
|
|
performance cost.
|
|
Application writers should: carefully consider the implications of enabling
|
|
all supported features.
|
|
====
|
|
|
|
ifdef::VK_KHR_get_physical_device_properties2[]
|
|
|
|
// refBegin vkGetPhysicalDeviceFeatures2KHR Reports capabilities of a physical device
|
|
|
|
To query supported features defined by the core or extensions, call:
|
|
|
|
include::../api/protos/vkGetPhysicalDeviceFeatures2KHR.txt[]
|
|
|
|
* pname:physicalDevice is the physical device from which to query the
|
|
supported features.
|
|
* pname:pFeatures is a pointer to a slink:VkPhysicalDeviceFeatures2KHR
|
|
structure in which the physical device features are returned.
|
|
|
|
Each structure in pname:pFeatures and its pname:pNext chain contain members
|
|
corresponding to fine-grained features.
|
|
fname:vkGetPhysicalDeviceFeatures2KHR writes each member to a boolean value
|
|
indicating whether that feature is supported.
|
|
|
|
include::../validity/protos/vkGetPhysicalDeviceFeatures2KHR.txt[]
|
|
|
|
// refBegin VkPhysicalDeviceFeatures2KHR Structure describing the fine-grained features that can be supported by an implementation
|
|
|
|
The sname:VkPhysicalDeviceFeatures2KHR structure is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceFeatures2KHR.txt[]
|
|
|
|
The sname:VkPhysicalDeviceFeatures2KHR structure is defined as:
|
|
|
|
* pname:sType is the type of this structure.
|
|
* pname:pNext is `NULL` or a pointer to an extension-specific structure.
|
|
* pname:features is a structure of type slink:VkPhysicalDeviceFeatures
|
|
describing the fine-grained features of the Vulkan 1.0 API.
|
|
|
|
The pname:pNext chain of this structure is used to extend the structure with
|
|
features defined by extensions.
|
|
This structure can: be used in flink:vkGetPhysicalDeviceFeatures2KHR or can:
|
|
be in the pname:pNext chain of a slink:VkDeviceCreateInfo structure, in
|
|
which case it controls which features are enabled in the device in lieu of
|
|
pname:pEnabledFeatures.
|
|
|
|
include::../validity/structs/VkPhysicalDeviceFeatures2KHR.txt[]
|
|
|
|
endif::VK_KHR_get_physical_device_properties2[]
|
|
|
|
// refBegin VkPhysicalDeviceFeatures Structure describing the fine-grained features that can be supported by an implementation
|
|
|
|
The sname:VkPhysicalDeviceFeatures structure is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceFeatures.txt[]
|
|
|
|
The members of the sname:VkPhysicalDeviceFeatures structure describe the
|
|
following features:
|
|
|
|
* [[features-features-robustBufferAccess]] pname:robustBufferAccess
|
|
indicates that accesses to buffers are bounds-checked against the range
|
|
of the buffer descriptor (as determined by
|
|
sname:VkDescriptorBufferInfo::pname:range,
|
|
sname:VkBufferViewCreateInfo::pname:range, or the size of the buffer).
|
|
Out of bounds accesses must: not cause application termination, and the
|
|
effects of shader loads, stores, and atomics must: conform to an
|
|
implementation-dependent behavior as described below.
|
|
** A buffer access is considered to be out of bounds if any of the
|
|
following are true:
|
|
*** The pointer was formed by code:OpImageTexelPointer and the coordinate
|
|
is less than zero or greater than or equal to the number of whole
|
|
elements in the bound range.
|
|
*** The pointer was not formed by code:OpImageTexelPointer and the object
|
|
pointed to is not wholly contained within the bound range.
|
|
+
|
|
--
|
|
[NOTE]
|
|
.Note
|
|
====
|
|
If a SPIR-V code:OpLoad instruction loads a structure and the tail end of
|
|
the structure is out of bounds, then all members of the structure are
|
|
considered out of bounds even if the members at the end are not statically
|
|
used.
|
|
====
|
|
--
|
|
*** If any buffer access in a given SPIR-V block is determined to be out
|
|
of bounds, then any other access of the same type (load, store, or
|
|
atomic) in the same SPIR-V block that accesses an address less than 16
|
|
bytes away from the out of bounds address may: also be considered out
|
|
of bounds.
|
|
** Out-of-bounds buffer loads will return any of the following values:
|
|
*** Values from anywhere within the memory range(s) bound to the buffer
|
|
(possibly including bytes of memory past the end of the buffer, up to
|
|
the end of the bound range).
|
|
*** Zero values, or [eq]#(0,0,0,x)# vectors for vector reads where x is a
|
|
valid value represented in the type of the vector components and may:
|
|
be any of:
|
|
**** 0, 1, or the maximum representable positive integer value, for signed
|
|
or unsigned integer components
|
|
**** 0.0 or 1.0, for floating-point components
|
|
** Out-of-bounds writes may: modify values within the memory range(s)
|
|
bound to the buffer, but must: not modify any other memory.
|
|
** Out-of-bounds atomics may: modify values within the memory range(s)
|
|
bound to the buffer, but must: not modify any other memory, and return
|
|
an undefined value.
|
|
** Vertex input attributes are considered out of bounds if the address of
|
|
the attribute plus the size of the attribute is greater than the size
|
|
of the bound buffer.
|
|
Further, if any vertex input attribute using a specific vertex input
|
|
binding is out of bounds, then all vertex input attributes using that
|
|
vertex input binding for that vertex shader invocation are considered
|
|
out of bounds.
|
|
*** If a vertex input attribute is out of bounds, it will be assigned one
|
|
of the following values:
|
|
**** Values from anywhere within the memory range(s) bound to the buffer,
|
|
converted according to the format of the attribute.
|
|
**** Zero values, format converted according to the format of the
|
|
attribute.
|
|
**** Zero values, or [eq]#(0,0,0,x)# vectors, as described above.
|
|
** If pname:robustBufferAccess is not enabled, out of bounds accesses may:
|
|
corrupt any memory within the process and cause undefined behavior up
|
|
to and including application termination.
|
|
* [[features-features-fullDrawIndexUint32]] pname:fullDrawIndexUint32
|
|
indicates the full 32-bit range of indices is supported for indexed draw
|
|
calls when using a elink:VkIndexType of ename:VK_INDEX_TYPE_UINT32.
|
|
pname:maxDrawIndexedIndexValue is the maximum index value that may: be
|
|
used (aside from the primitive restart index, which is always 2^32^-1
|
|
when the elink:VkIndexType is ename:VK_INDEX_TYPE_UINT32).
|
|
If this feature is supported, pname:maxDrawIndexedIndexValue must: be
|
|
2^32^-1; otherwise it must: be no smaller than 2^24^-1.
|
|
See
|
|
<<features-limits-maxDrawIndexedIndexValue,maxDrawIndexedIndexValue>>.
|
|
* [[features-features-imageCubeArray]] pname:imageCubeArray indicates
|
|
whether image views with a elink:VkImageViewType of
|
|
ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY can: be created, and that the
|
|
corresponding code:SampledCubeArray and code:ImageCubeArray SPIR-V
|
|
capabilities can: be used in shader code.
|
|
* [[features-features-independentBlend]] pname:independentBlend indicates
|
|
whether the sname:VkPipelineColorBlendAttachmentState settings are
|
|
controlled independently per-attachment.
|
|
If this feature is not enabled, the
|
|
sname:VkPipelineColorBlendAttachmentState settings for all color
|
|
attachments must: be identical.
|
|
Otherwise, a different sname:VkPipelineColorBlendAttachmentState can: be
|
|
provided for each bound color attachment.
|
|
* [[features-features-geometryShader]] pname:geometryShader indicates
|
|
whether geometry shaders are supported.
|
|
If this feature is not enabled, the ename:VK_SHADER_STAGE_GEOMETRY_BIT
|
|
and ename:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT enum values must: not be
|
|
used.
|
|
This also indicates whether shader modules can: declare the
|
|
code:Geometry capability.
|
|
* [[features-features-tessellationShader]] pname:tessellationShader
|
|
indicates whether tessellation control and evaluation shaders are
|
|
supported.
|
|
If this feature is not enabled, the
|
|
ename:VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
|
|
ename:VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
|
|
ename:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
|
|
ename:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, and
|
|
ename:VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO enum
|
|
values must: not be used.
|
|
This also indicates whether shader modules can: declare the
|
|
code:Tessellation capability.
|
|
* [[features-features-sampleRateShading]] pname:sampleRateShading
|
|
indicates whether per-sample shading and multisample interpolation are
|
|
supported.
|
|
If this feature is not enabled, the pname:sampleShadingEnable member of
|
|
the sname:VkPipelineMultisampleStateCreateInfo structure must: be set to
|
|
ename:VK_FALSE and the pname:minSampleShading member is ignored.
|
|
This also indicates whether shader modules can: declare the
|
|
code:SampleRateShading capability.
|
|
* [[features-features-dualSrcBlend]] pname:dualSrcBlend indicates whether
|
|
blend operations which take two sources are supported.
|
|
If this feature is not enabled, the ename:VK_BLEND_FACTOR_SRC1_COLOR,
|
|
ename:VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR,
|
|
ename:VK_BLEND_FACTOR_SRC1_ALPHA, and
|
|
ename:VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA enum values must: not be used
|
|
as source or destination blending factors.
|
|
See <<framebuffer-dsb>>.
|
|
* [[features-features-logicOp]] pname:logicOp indicates whether logic
|
|
operations are supported.
|
|
If this feature is not enabled, the pname:logicOpEnable member of the
|
|
sname:VkPipelineColorBlendStateCreateInfo structure must: be set to
|
|
ename:VK_FALSE, and the pname:logicOp member is ignored.
|
|
* [[features-features-multiDrawIndirect]] pname:multiDrawIndirect
|
|
indicates whether multiple draw indirect is supported.
|
|
If this feature is not enabled, the pname:drawCount parameter to the
|
|
fname:vkCmdDrawIndirect and fname:vkCmdDrawIndexedIndirect commands
|
|
must: be 0 or 1.
|
|
The pname:maxDrawIndirectCount member of the
|
|
sname:VkPhysicalDeviceLimits structure must: also be 1 if this feature
|
|
is not supported.
|
|
See <<features-limits-maxDrawIndirectCount,maxDrawIndirectCount>>.
|
|
* [[features-features-drawIndirectFirstInstance]]
|
|
pname:drawIndirectFirstInstance indicates whether indirect draw calls
|
|
support the pname:firstInstance parameter.
|
|
If this feature is not enabled, the pname:firstInstance member of all
|
|
sname:VkDrawIndirectCommand and sname:VkDrawIndexedIndirectCommand
|
|
structures that are provided to the fname:vkCmdDrawIndirect and
|
|
fname:vkCmdDrawIndexedIndirect commands must: be 0.
|
|
* [[features-features-depthClamp]] pname:depthClamp indicates whether
|
|
depth clamping is supported.
|
|
If this feature is not enabled, the pname:depthClampEnable member of the
|
|
sname:VkPipelineRasterizationStateCreateInfo structure must: be set to
|
|
ename:VK_FALSE.
|
|
Otherwise, setting pname:depthClampEnable to ename:VK_TRUE will enable
|
|
depth clamping.
|
|
* [[features-features-depthBiasClamp]] pname:depthBiasClamp indicates
|
|
whether depth bias clamping is supported.
|
|
If this feature is not enabled, the pname:depthBiasClamp member of the
|
|
sname:VkPipelineRasterizationStateCreateInfo structure must: be set to
|
|
0.0 unless the ename:VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state is
|
|
enabled, and the pname:depthBiasClamp parameter to
|
|
fname:vkCmdSetDepthBias must: be set to 0.0.
|
|
* [[features-features-fillModeNonSolid]] pname:fillModeNonSolid indicates
|
|
whether point and wireframe fill modes are supported.
|
|
If this feature is not enabled, the ename:VK_POLYGON_MODE_POINT and
|
|
ename:VK_POLYGON_MODE_LINE enum values must: not be used.
|
|
* [[features-features-depthBounds]] pname:depthBounds indicates whether
|
|
depth bounds tests are supported.
|
|
If this feature is not enabled, the pname:depthBoundsTestEnable member
|
|
of the sname:VkPipelineDepthStencilStateCreateInfo structure must: be
|
|
set to ename:VK_FALSE.
|
|
When pname:depthBoundsTestEnable is set to ename:VK_FALSE, the
|
|
pname:minDepthBounds and pname:maxDepthBounds members of the
|
|
sname:VkPipelineDepthStencilStateCreateInfo structure are ignored.
|
|
* [[features-features-wideLines]] pname:wideLines indicates whether lines
|
|
with width other than 1.0 are supported.
|
|
If this feature is not enabled, the pname:lineWidth member of the
|
|
sname:VkPipelineRasterizationStateCreateInfo structure must: be set to
|
|
1.0 unless the ename:VK_DYNAMIC_STATE_LINE_WIDTH dynamic state is
|
|
enabled, and the pname:lineWidth parameter to fname:vkCmdSetLineWidth
|
|
must: be set to 1.0.
|
|
When this feature is supported, the range and granularity of supported
|
|
line widths are indicated by the pname:lineWidthRange and
|
|
pname:lineWidthGranularity members of the sname:VkPhysicalDeviceLimits
|
|
structure, respectively.
|
|
* [[features-features-largePoints]] pname:largePoints indicates whether
|
|
points with size greater than 1.0 are supported.
|
|
If this feature is not enabled, only a point size of 1.0 written by a
|
|
shader is supported.
|
|
The range and granularity of supported point sizes are indicated by the
|
|
pname:pointSizeRange and pname:pointSizeGranularity members of the
|
|
sname:VkPhysicalDeviceLimits structure, respectively.
|
|
* [[features-features-alphaToOne]] pname:alphaToOne indicates whether the
|
|
implementation is able to replace the alpha value of the color fragment
|
|
output from the fragment shader with the maximum representable alpha
|
|
value for fixed-point colors or 1.0 for floating-point colors.
|
|
If this feature is not enabled, then the pname:alphaToOneEnable member
|
|
of the sname:VkPipelineMultisampleStateCreateInfo structure must: be set
|
|
to ename:VK_FALSE.
|
|
Otherwise setting pname:alphaToOneEnable to ename:VK_TRUE will enable
|
|
alpha-to-one behavior.
|
|
* [[features-features-multiViewport]] pname:multiViewport indicates
|
|
whether more than one viewport is supported.
|
|
If this feature is not enabled, the pname:viewportCount and
|
|
pname:scissorCount members of the
|
|
sname:VkPipelineViewportStateCreateInfo structure must: be set to 1.
|
|
Similarly, the pname:viewportCount parameter to the
|
|
fname:vkCmdSetViewport command and the pname:scissorCount parameter to
|
|
the fname:vkCmdSetScissor command must: be 1, and the
|
|
pname:firstViewport parameter to the fname:vkCmdSetViewport command and
|
|
the pname:firstScissor parameter to the fname:vkCmdSetScissor command
|
|
must: be 0.
|
|
* [[features-features-samplerAnisotropy]] pname:samplerAnisotropy
|
|
indicates whether anisotropic filtering is supported.
|
|
If this feature is not enabled, the pname:maxAnisotropy member of the
|
|
sname:VkSamplerCreateInfo structure must: be 1.0.
|
|
* [[features-features-textureCompressionETC2]]
|
|
pname:textureCompressionETC2 indicates whether all of the ETC2 and EAC
|
|
compressed texture formats are supported.
|
|
If this feature is enabled, then the
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
|
|
ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT and
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must:
|
|
be supported in pname:optimalTilingFeatures for the following formats:
|
|
+
|
|
--
|
|
* ename:VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
|
|
* ename:VK_FORMAT_EAC_R11_UNORM_BLOCK
|
|
* ename:VK_FORMAT_EAC_R11_SNORM_BLOCK
|
|
* ename:VK_FORMAT_EAC_R11G11_UNORM_BLOCK
|
|
* ename:VK_FORMAT_EAC_R11G11_SNORM_BLOCK
|
|
|
|
flink:vkGetPhysicalDeviceFormatProperties and
|
|
flink:vkGetPhysicalDeviceImageFormatProperties can: be used to check for
|
|
additional supported properties of individual formats.
|
|
--
|
|
* [[features-features-textureCompressionASTC_LDR]]
|
|
pname:textureCompressionASTC_LDR indicates whether all of the ASTC LDR
|
|
compressed texture formats are supported.
|
|
If this feature is enabled, then the
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
|
|
ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT and
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must:
|
|
be supported in pname:optimalTilingFeatures for the following formats:
|
|
+
|
|
--
|
|
* ename:VK_FORMAT_ASTC_4x4_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_4x4_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_5x4_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_5x4_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_5x5_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_5x5_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_6x5_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_6x5_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_6x6_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_6x6_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_8x5_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_8x5_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_8x6_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_8x6_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_8x8_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_8x8_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_10x5_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_10x5_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_10x6_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_10x6_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_10x8_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_10x8_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_10x10_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_10x10_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_12x10_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_12x10_SRGB_BLOCK
|
|
* ename:VK_FORMAT_ASTC_12x12_UNORM_BLOCK
|
|
* ename:VK_FORMAT_ASTC_12x12_SRGB_BLOCK
|
|
|
|
flink:vkGetPhysicalDeviceFormatProperties and
|
|
flink:vkGetPhysicalDeviceImageFormatProperties can: be used to check for
|
|
additional supported properties of individual formats.
|
|
--
|
|
* [[features-features-textureCompressionBC]] pname:textureCompressionBC
|
|
indicates whether all of the BC compressed texture formats are
|
|
supported.
|
|
If this feature is enabled, then the
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
|
|
ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT and
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must:
|
|
be supported in pname:optimalTilingFeatures for the following formats:
|
|
+
|
|
--
|
|
* ename:VK_FORMAT_BC1_RGB_UNORM_BLOCK
|
|
* ename:VK_FORMAT_BC1_RGB_SRGB_BLOCK
|
|
* ename:VK_FORMAT_BC1_RGBA_UNORM_BLOCK
|
|
* ename:VK_FORMAT_BC1_RGBA_SRGB_BLOCK
|
|
* ename:VK_FORMAT_BC2_UNORM_BLOCK
|
|
* ename:VK_FORMAT_BC2_SRGB_BLOCK
|
|
* ename:VK_FORMAT_BC3_UNORM_BLOCK
|
|
* ename:VK_FORMAT_BC3_SRGB_BLOCK
|
|
* ename:VK_FORMAT_BC4_UNORM_BLOCK
|
|
* ename:VK_FORMAT_BC4_SNORM_BLOCK
|
|
* ename:VK_FORMAT_BC5_UNORM_BLOCK
|
|
* ename:VK_FORMAT_BC5_SNORM_BLOCK
|
|
* ename:VK_FORMAT_BC6H_UFLOAT_BLOCK
|
|
* ename:VK_FORMAT_BC6H_SFLOAT_BLOCK
|
|
* ename:VK_FORMAT_BC7_UNORM_BLOCK
|
|
* ename:VK_FORMAT_BC7_SRGB_BLOCK
|
|
|
|
flink:vkGetPhysicalDeviceFormatProperties and
|
|
flink:vkGetPhysicalDeviceImageFormatProperties can: be used to check for
|
|
additional supported properties of individual formats.
|
|
--
|
|
* [[features-features-occlusionQueryPrecise]] pname:occlusionQueryPrecise
|
|
indicates whether occlusion queries returning actual sample counts are
|
|
supported.
|
|
Occlusion queries are created in a sname:VkQueryPool by specifying the
|
|
pname:queryType of ename:VK_QUERY_TYPE_OCCLUSION in the
|
|
sname:VkQueryPoolCreateInfo structure which is passed to
|
|
fname:vkCreateQueryPool.
|
|
If this feature is enabled, queries of this type can: enable
|
|
ename:VK_QUERY_CONTROL_PRECISE_BIT in the pname:flags parameter to
|
|
fname:vkCmdBeginQuery.
|
|
If this feature is not supported, the implementation supports only
|
|
boolean occlusion queries.
|
|
When any samples are passed, boolean queries will return a non-zero
|
|
result value, otherwise a result value of zero is returned.
|
|
When this feature is enabled and ename:VK_QUERY_CONTROL_PRECISE_BIT is
|
|
set, occlusion queries will report the actual number of samples passed.
|
|
* [[features-features-pipelineStatisticsQuery]]
|
|
pname:pipelineStatisticsQuery indicates whether the pipeline statistics
|
|
queries are supported.
|
|
If this feature is not enabled, queries of type
|
|
ename:VK_QUERY_TYPE_PIPELINE_STATISTICS cannot: be created, and none of
|
|
the elink:VkQueryPipelineStatisticFlagBits bits can: be set in the
|
|
pname:pipelineStatistics member of the sname:VkQueryPoolCreateInfo
|
|
structure.
|
|
* [[features-features-vertexPipelineStoresAndAtomics]]
|
|
pname:vertexPipelineStoresAndAtomics indicates whether storage buffers
|
|
and images support stores and atomic operations in the vertex,
|
|
tessellation, and geometry shader stages.
|
|
If this feature is not enabled, all storage image, storage texel
|
|
buffers, and storage buffer variables used by these stages in shader
|
|
modules must: be decorated with the code:NonWriteable decoration (or the
|
|
code:readonly memory qualifier in GLSL).
|
|
* [[features-features-fragmentStoresAndAtomics]]
|
|
pname:fragmentStoresAndAtomics indicates whether storage buffers and
|
|
images support stores and atomic operations in the fragment shader
|
|
stage.
|
|
If this feature is not enabled, all storage image, storage texel
|
|
buffers, and storage buffer variables used by the fragment stage in
|
|
shader modules must: be decorated with the code:NonWriteable decoration
|
|
(or the code:readonly memory qualifier in GLSL).
|
|
* [[features-features-shaderTessellationAndGeometryPointSize]]
|
|
pname:shaderTessellationAndGeometryPointSize indicates whether the
|
|
code:PointSize built-in decoration is available in the tessellation
|
|
control, tessellation evaluation, and geometry shader stages.
|
|
If this feature is not enabled, members decorated with the
|
|
code:PointSize built-in decoration must: not be read from or written to
|
|
and all points written from a tessellation or geometry shader will have
|
|
a size of 1.0.
|
|
This also indicates whether shader modules can: declare the
|
|
code:TessellationPointSize capability for tessellation control and
|
|
evaluation shaders, or if the shader modules can: declare the
|
|
code:GeometryPointSize capability for geometry shaders.
|
|
An implementation supporting this feature must: also support one or both
|
|
of the <<features-features-tessellationShader,pname:tessellationShader>>
|
|
or <<features-features-geometryShader,pname:geometryShader>> features.
|
|
* [[features-features-shaderImageGatherExtended]]
|
|
pname:shaderImageGatherExtended indicates whether the extended set of
|
|
image gather instructions are available in shader code.
|
|
If this feature is not enabled, the code:OpImage*code:Gather
|
|
instructions do not support the code:Offset and code:ConstOffsets
|
|
operands.
|
|
This also indicates whether shader modules can: declare the
|
|
code:ImageGatherExtended capability.
|
|
* [[features-features-shaderStorageImageExtendedFormats]]
|
|
pname:shaderStorageImageExtendedFormats indicates whether the extended
|
|
storage image formats are available in shader code.
|
|
If this feature is not enabled, the formats requiring the
|
|
code:StorageImageExtendedFormats capability are not supported for
|
|
storage images.
|
|
This also indicates whether shader modules can: declare the
|
|
code:StorageImageExtendedFormats capability.
|
|
* [[features-features-shaderStorageImageMultisample]]
|
|
pname:shaderStorageImageMultisample indicates whether multisampled
|
|
storage images are supported.
|
|
If this feature is not enabled, images that are created with a
|
|
pname:usage that includes ename:VK_IMAGE_USAGE_STORAGE_BIT must: be
|
|
created with pname:samples equal to ename:VK_SAMPLE_COUNT_1_BIT.
|
|
This also indicates whether shader modules can: declare the
|
|
code:StorageImageMultisample capability.
|
|
* [[features-features-shaderStorageImageReadWithoutFormat]]
|
|
pname:shaderStorageImageReadWithoutFormat indicates whether storage
|
|
images require a format qualifier to be specified when reading from
|
|
storage images.
|
|
If this feature is not enabled, the code:OpImageRead instruction must:
|
|
not have an code:OpTypeImage of code:Unknown.
|
|
This also indicates whether shader modules can: declare the
|
|
code:StorageImageReadWithoutFormat capability.
|
|
* [[features-features-shaderStorageImageWriteWithoutFormat]]
|
|
pname:shaderStorageImageWriteWithoutFormat indicates whether storage
|
|
images require a format qualifier to be specified when writing to
|
|
storage images.
|
|
If this feature is not enabled, the code:OpImageWrite instruction must:
|
|
not have an code:OpTypeImage of code:Unknown.
|
|
This also indicates whether shader modules can: declare the
|
|
code:StorageImageWriteWithoutFormat capability.
|
|
* [[features-features-shaderUniformBufferArrayDynamicIndexing]]
|
|
pname:shaderUniformBufferArrayDynamicIndexing indicates whether arrays
|
|
of uniform buffers can: be indexed by _dynamically uniform_ integer
|
|
expressions in shader code.
|
|
If this feature is not enabled, resources with a descriptor type of
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must: be indexed only by
|
|
constant integral expressions when aggregated into arrays in shader
|
|
code.
|
|
This also indicates whether shader modules can: declare the
|
|
code:UniformBufferArrayDynamicIndexing capability.
|
|
* [[features-features-shaderSampledImageArrayDynamicIndexing]]
|
|
pname:shaderSampledImageArrayDynamicIndexing indicates whether arrays of
|
|
samplers or sampled images can: be indexed by dynamically uniform
|
|
integer expressions in shader code.
|
|
If this feature is not enabled, resources with a descriptor type of
|
|
ename:VK_DESCRIPTOR_TYPE_SAMPLER,
|
|
ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or
|
|
ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must: be indexed only by constant
|
|
integral expressions when aggregated into arrays in shader code.
|
|
This also indicates whether shader modules can: declare the
|
|
code:SampledImageArrayDynamicIndexing capability.
|
|
* [[features-features-shaderStorageBufferArrayDynamicIndexing]]
|
|
pname:shaderStorageBufferArrayDynamicIndexing indicates whether arrays
|
|
of storage buffers can: be indexed by dynamically uniform integer
|
|
expressions in shader code.
|
|
If this feature is not enabled, resources with a descriptor type of
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must: be indexed only by
|
|
constant integral expressions when aggregated into arrays in shader
|
|
code.
|
|
This also indicates whether shader modules can: declare the
|
|
code:StorageBufferArrayDynamicIndexing capability.
|
|
* [[features-features-shaderStorageImageArrayDynamicIndexing]]
|
|
pname:shaderStorageImageArrayDynamicIndexing indicates whether arrays of
|
|
storage images can: be indexed by dynamically uniform integer
|
|
expressions in shader code.
|
|
If this feature is not enabled, resources with a descriptor type of
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must: be indexed only by constant
|
|
integral expressions when aggregated into arrays in shader code.
|
|
This also indicates whether shader modules can: declare the
|
|
code:StorageImageArrayDynamicIndexing capability.
|
|
* [[features-features-shaderClipDistance]] pname:shaderClipDistance
|
|
indicates whether clip distances are supported in shader code.
|
|
If this feature is not enabled, any members decorated with the
|
|
code:ClipDistance built-in decoration must: not be read from or written
|
|
to in shader modules.
|
|
This also indicates whether shader modules can: declare the
|
|
code:ClipDistance capability.
|
|
* [[features-features-shaderCullDistance]] pname:shaderCullDistance
|
|
indicates whether cull distances are supported in shader code.
|
|
If this feature is not enabled, any members decorated with the
|
|
code:CullDistance built-in decoration must: not be read from or written
|
|
to in shader modules.
|
|
This also indicates whether shader modules can: declare the
|
|
code:CullDistance capability.
|
|
* [[features-features-shaderFloat64]] pname:shaderFloat64 indicates
|
|
whether 64-bit floats (doubles) are supported in shader code.
|
|
If this feature is not enabled, 64-bit floating-point types must: not be
|
|
used in shader code.
|
|
This also indicates whether shader modules can: declare the code:Float64
|
|
capability.
|
|
* [[features-features-shaderInt64]] pname:shaderInt64 indicates whether
|
|
64-bit integers (signed and unsigned) are supported in shader code.
|
|
If this feature is not enabled, 64-bit integer types must: not be used
|
|
in shader code.
|
|
This also indicates whether shader modules can: declare the code:Int64
|
|
capability.
|
|
* [[features-features-shaderInt16]] pname:shaderInt16 indicates whether
|
|
16-bit integers (signed and unsigned) are supported in shader code.
|
|
If this feature is not enabled, 16-bit integer types must: not be used
|
|
in shader code.
|
|
This also indicates whether shader modules can: declare the code:Int16
|
|
capability.
|
|
* [[features-features-shaderResourceResidency]]
|
|
pname:shaderResourceResidency indicates whether image operations that
|
|
return resource residency information are supported in shader code.
|
|
If this feature is not enabled, the code:OpImageSparse* instructions
|
|
must: not be used in shader code.
|
|
This also indicates whether shader modules can: declare the
|
|
code:SparseResidency capability.
|
|
The feature requires at least one of the ptext:sparseResidency* features
|
|
to be supported.
|
|
* [[features-features-shaderResourceMinLod]] pname:shaderResourceMinLod
|
|
indicates whether image operations that specify the minimum resource
|
|
level-of-detail (LOD) are supported in shader code.
|
|
If this feature is not enabled, the code:MinLod image operand must: not
|
|
be used in shader code.
|
|
This also indicates whether shader modules can: declare the code:MinLod
|
|
capability.
|
|
* [[features-features-sparseBinding]] pname:sparseBinding indicates
|
|
whether resource memory can: be managed at opaque sparse block level
|
|
instead of at the object level.
|
|
If this feature is not enabled, resource memory must: be bound only on a
|
|
per-object basis using the fname:vkBindBufferMemory and
|
|
fname:vkBindImageMemory commands.
|
|
In this case, buffers and images must: not be created with
|
|
ename:VK_BUFFER_CREATE_SPARSE_BINDING_BIT and
|
|
ename:VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in the pname:flags member
|
|
of the sname:VkBufferCreateInfo and sname:VkImageCreateInfo structures,
|
|
respectively.
|
|
Otherwise resource memory can: be managed as described in
|
|
<<sparsememory-sparseresourcefeatures,Sparse Resource Features>>.
|
|
* [[features-features-sparseResidencyBuffer]] pname:sparseResidencyBuffer
|
|
indicates whether the device can: access partially resident buffers.
|
|
If this feature is not enabled, buffers must: not be created with
|
|
ename:VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT set in the pname:flags
|
|
member of the sname:VkBufferCreateInfo structure.
|
|
* [[features-features-sparseResidencyImage2D]]
|
|
pname:sparseResidencyImage2D indicates whether the device can: access
|
|
partially resident 2D images with 1 sample per pixel.
|
|
If this feature is not enabled, images with an pname:imageType of
|
|
ename:VK_IMAGE_TYPE_2D and pname:samples set to
|
|
ename:VK_SAMPLE_COUNT_1_BIT must: not be created with
|
|
ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the pname:flags member
|
|
of the sname:VkImageCreateInfo structure.
|
|
* [[features-features-sparseResidencyImage3D]]
|
|
pname:sparseResidencyImage3D indicates whether the device can: access
|
|
partially resident 3D images.
|
|
If this feature is not enabled, images with an pname:imageType of
|
|
ename:VK_IMAGE_TYPE_3D must: not be created with
|
|
ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the pname:flags member
|
|
of the sname:VkImageCreateInfo structure.
|
|
* [[features-features-sparseResidency2Samples]]
|
|
pname:sparseResidency2Samples indicates whether the physical device can:
|
|
access partially resident 2D images with 2 samples per pixel.
|
|
If this feature is not enabled, images with an pname:imageType of
|
|
ename:VK_IMAGE_TYPE_2D and pname:samples set to
|
|
ename:VK_SAMPLE_COUNT_2_BIT must: not be created with
|
|
ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the pname:flags member
|
|
of the sname:VkImageCreateInfo structure.
|
|
* [[features-features-sparseResidency4Samples]]
|
|
pname:sparseResidency4Samples indicates whether the physical device can:
|
|
access partially resident 2D images with 4 samples per pixel.
|
|
If this feature is not enabled, images with an pname:imageType of
|
|
ename:VK_IMAGE_TYPE_2D and pname:samples set to
|
|
ename:VK_SAMPLE_COUNT_4_BIT must: not be created with
|
|
ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the pname:flags member
|
|
of the sname:VkImageCreateInfo structure.
|
|
* [[features-features-sparseResidency8Samples]]
|
|
pname:sparseResidency8Samples indicates whether the physical device can:
|
|
access partially resident 2D images with 8 samples per pixel.
|
|
If this feature is not enabled, images with an pname:imageType of
|
|
ename:VK_IMAGE_TYPE_2D and pname:samples set to
|
|
ename:VK_SAMPLE_COUNT_8_BIT must: not be created with
|
|
ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the pname:flags member
|
|
of the sname:VkImageCreateInfo structure.
|
|
* [[features-features-sparseResidency16Samples]]
|
|
pname:sparseResidency16Samples indicates whether the physical device
|
|
can: access partially resident 2D images with 16 samples per pixel.
|
|
If this feature is not enabled, images with an pname:imageType of
|
|
ename:VK_IMAGE_TYPE_2D and pname:samples set to
|
|
ename:VK_SAMPLE_COUNT_16_BIT must: not be created with
|
|
ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the pname:flags member
|
|
of the sname:VkImageCreateInfo structure.
|
|
* [[features-features-sparseResidencyAliased]]
|
|
pname:sparseResidencyAliased indicates whether the physical device can:
|
|
correctly access data aliased into multiple locations.
|
|
If this feature is not enabled, the
|
|
ename:VK_BUFFER_CREATE_SPARSE_ALIASED_BIT and
|
|
ename:VK_IMAGE_CREATE_SPARSE_ALIASED_BIT enum values must: not be used
|
|
in pname:flags members of the sname:VkBufferCreateInfo and
|
|
sname:VkImageCreateInfo structures, respectively.
|
|
* [[features-features-variableMultisampleRate]]
|
|
pname:variableMultisampleRate indicates whether all pipelines that will
|
|
be bound to a command buffer during a subpass with no attachments must:
|
|
have the same value for
|
|
sname:VkPipelineMultisampleStateCreateInfo::pname:rasterizationSamples.
|
|
If set to ename:VK_TRUE, the implementation supports variable
|
|
multisample rates in a subpass with no attachments.
|
|
If set to ename:VK_FALSE, then all pipelines bound in such a subpass
|
|
must: have the same multisample rate.
|
|
This has no effect in situations where a subpass uses any attachments.
|
|
* [[features-features-inheritedQueries]] pname:inheritedQueries indicates
|
|
whether a secondary command buffer may: be executed while a query is
|
|
active.
|
|
|
|
.Valid Usage
|
|
****
|
|
* [[VUID-VkPhysicalDeviceFeatures-None-00579]] If any member of this structure is ename:VK_FALSE, as returned by
|
|
flink:vkGetPhysicalDeviceFeatures, then it must: be ename:VK_FALSE when
|
|
passed as part of the sname:VkDeviceCreateInfo struct when creating a
|
|
device
|
|
****
|
|
|
|
include::../validity/structs/VkPhysicalDeviceFeatures.txt[]
|
|
|
|
ifdef::VK_KHX_multiview[]
|
|
|
|
// refBegin VkPhysicalDeviceMultiviewFeaturesKHX Structure describing multiview features that can be supported by an implementation
|
|
|
|
The sname:VkPhysicalDeviceMultiviewFeaturesKHX structure is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceMultiviewFeaturesKHX.txt[]
|
|
|
|
The members of the sname:VkPhysicalDeviceMultiviewFeaturesKHX structure
|
|
describe the following features:
|
|
|
|
* [[features-features-multiview]] pname:multiview indicates whether the
|
|
implementation supports multiview rendering within a render pass.
|
|
If this feature is not enabled, the view mask of each subpass must:
|
|
always be zero.
|
|
* [[features-features-multiview-gs]] pname:multiviewGeometryShader
|
|
indicates whether the implementation supports multiview rendering within
|
|
a render pass, with <<geometry,geometry shaders>>.
|
|
If this feature is not enabled, then a pipeline compiled against a
|
|
subpass with a non-zero view mask must: not include a geometry shader.
|
|
* [[features-features-multiview-tess]] pname:multiviewTessellationShader
|
|
indicates whether the implementation supports multiview rendering within
|
|
a render pass, with <<tessellation,tessellation shaders>>.
|
|
If this feature is not enabled, then a pipeline compiled against a
|
|
subpass with a non-zero view mask must: not include any tessellation
|
|
shaders.
|
|
|
|
If the sname:VkPhysicalDeviceMultiviewFeaturesKHX structure is included in
|
|
the pname:pNext chain of flink:vkGetPhysicalDeviceFeatures2KHR, it is filled
|
|
with values indicating whether each feature is supported.
|
|
sname:VkPhysicalDeviceMultiviewFeaturesKHX can: also be used in the
|
|
pname:pNext chain of flink:vkCreateDevice to enable features.
|
|
|
|
.Valid Usage
|
|
****
|
|
* [[VUID-VkPhysicalDeviceMultiviewFeaturesKHX-multiviewGeometryShader-00580]] If pname:multiviewGeometryShader is enabled then pname:multiview must:
|
|
also be enabled.
|
|
* [[VUID-VkPhysicalDeviceMultiviewFeaturesKHX-multiviewTessellationShader-00581]] If pname:multiviewTessellationShader is enabled then pname:multiview
|
|
must: also be enabled.
|
|
****
|
|
|
|
include::../validity/structs/VkPhysicalDeviceMultiviewFeaturesKHX.txt[]
|
|
|
|
// refEnd VkPhysicalDeviceMultiviewFeaturesKHX
|
|
|
|
endif::VK_KHX_multiview[]
|
|
|
|
|
|
[[features-features-requirements]]
|
|
=== Feature Requirements
|
|
|
|
All Vulkan graphics implementations must: support the following features:
|
|
|
|
* pname:robustBufferAccess.
|
|
|
|
All other features are not required: by the Specification.
|
|
|
|
|
|
[[features-limits]]
|
|
== Limits
|
|
|
|
There are a variety of implementation-dependent limits.
|
|
|
|
The sname:VkPhysicalDeviceLimits are properties of the physical device.
|
|
These are available in the pname:limits member of the
|
|
slink:VkPhysicalDeviceProperties structure which is returned from
|
|
flink:vkGetPhysicalDeviceProperties.
|
|
|
|
// refBegin VkPhysicalDeviceLimits Structure reporting implementation-dependent physical device limits
|
|
|
|
The sname:VkPhysicalDeviceLimits structure is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceLimits.txt[]
|
|
|
|
* [[features-limits-maxImageDimension1D]] pname:maxImageDimension1D is the
|
|
maximum dimension (pname:width) supported for all images 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) supported for all images
|
|
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) supported
|
|
for all images 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) supported for all
|
|
images 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 workgroup count parameters to the dispatch commands 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
|
|
[eq]#x~f~# and [eq]#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.
|
|
[eq]#2^pname: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 mip level to
|
|
the mip filtered results.
|
|
[eq]#2^pname: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
|
|
[eq]#[-pname:maxSamplerLodBias,+pname: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 [eq]#[minimum, maximum]# range that the corners of a viewport must:
|
|
be contained in.
|
|
This range must: be at least [eq]#[-2 {times} pname:size, 2 {times}
|
|
pname:size - 1]#, where [eq]#pname:size =
|
|
max(pname:maxViewportDimensions[0], pname: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 [eq]#[-pname:size + 1, 2 {times}
|
|
pname: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.
|
|
====
|
|
--
|
|
* [[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
|
|
[eq]#[pname:minimum,pname: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
|
|
[eq]#[pname:minimum,pname: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 enforced, but applications
|
|
should: use the optimal alignment for optimal performance and power use.
|
|
* [[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 enforced, but applications
|
|
should: use the optimal alignment for optimal performance and power use.
|
|
* [[features-limits-nonCoherentAtomSize]] pname:nonCoherentAtomSize is the
|
|
size and alignment in bytes that bounds concurrent access to
|
|
<<memory-device-hostaccess, host-mapped device memory>>.
|
|
ifdef::VK_EXT_discard_rectangles[]
|
|
* [[features-limits-maxDiscardRectangles]] pname:maxDiscardRectangles is
|
|
the maximum number of active discard rectangles.
|
|
pname:maxDiscardRectangles is a member of the
|
|
slink:VkPhysicalDeviceDiscardRectanglePropertiesEXT structure.
|
|
This limit can be queried by setting the pname:pNext pointer from a
|
|
slink:VkPhysicalDeviceProperties2KHR object to an instance of
|
|
slink:VkPhysicalDeviceDiscardRectanglePropertiesEXT and using
|
|
fname:vkGetPhysicalDeviceProperties2KHR to fill out the members.
|
|
endif::VK_EXT_discard_rectangles[]
|
|
|
|
|
|
// refBody VkPhysicalDeviceLimits
|
|
|
|
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[]
|
|
|
|
ifdef::VK_KHR_push_descriptor[]
|
|
|
|
// refBegin VkPhysicalDevicePushDescriptorPropertiesKHR Structure describing push descriptor limits that can be supported by an implementation
|
|
|
|
The sname:VkPhysicalDevicePushDescriptorPropertiesKHR structure is defined
|
|
as:
|
|
|
|
include::../api/structs/VkPhysicalDevicePushDescriptorPropertiesKHR.txt[]
|
|
|
|
The members of the sname:VkPhysicalDevicePushDescriptorPropertiesKHR
|
|
structure describe the following implementation-dependent limits:
|
|
|
|
* [[features-limits-maxPushDescriptors]] pname:maxPushDescriptors is the
|
|
maximum number of descriptors that can: be used in a descriptor set
|
|
created with
|
|
ename:VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set.
|
|
|
|
include::../validity/structs/VkPhysicalDevicePushDescriptorPropertiesKHR.txt[]
|
|
|
|
// refEnd VkPhysicalDevicePushDescriptorPropertiesKHR
|
|
|
|
endif::VK_KHR_push_descriptor[]
|
|
|
|
ifdef::VK_KHX_multiview[]
|
|
|
|
// refBegin VkPhysicalDeviceMultiviewPropertiesKHX Structure describing multiview limits that can be supported by an implementation
|
|
|
|
The sname:VkPhysicalDeviceMultiviewPropertiesKHX structure is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceMultiviewPropertiesKHX.txt[]
|
|
|
|
The members of the sname:VkPhysicalDeviceMultiviewPropertiesKHX structure
|
|
describe the following implementation-dependent limits:
|
|
|
|
* [[features-limits-maxMultiviewViewCount]] pname:maxMultiviewViewCount is
|
|
one greater than the maximum view index that can: be used in a subpass.
|
|
* [[features-limits-maxMultiviewInstanceIndex]]
|
|
pname:maxMultiviewInstanceIndex is the maximum valid value of instance
|
|
index allowed to be generated by a drawing command recorded within a
|
|
subpass of a multiview render pass instance.
|
|
|
|
include::../validity/structs/VkPhysicalDeviceMultiviewPropertiesKHX.txt[]
|
|
|
|
If the sname:VkPhysicalDeviceMultiviewPropertiesKHX structure is included in
|
|
the pname:pNext chain of flink:VkPhysicalDeviceProperties2KHR, it is filled
|
|
with the implementation-dependent limits.
|
|
|
|
// refEnd VkPhysicalDeviceMultiviewPropertiesKHX
|
|
|
|
endif::VK_KHX_multiview[]
|
|
|
|
ifdef::VK_EXT_discard_rectangles[]
|
|
|
|
// refBegin VkPhysicalDeviceDiscardRectanglePropertiesEXT Structure describing discard rectangle limits that can be supported by an implementation
|
|
|
|
The sname:VkPhysicalDeviceDiscardRectanglePropertiesEXT structure is defined
|
|
as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceDiscardRectanglePropertiesEXT.txt[]
|
|
|
|
The members of the sname:VkPhysicalDeviceDiscardRectanglePropertiesEXT
|
|
structure describe the following implementation-dependent limits:
|
|
|
|
* [[features-limits-maxDiscardRectangles]] pname:maxDiscardRectangles is
|
|
the maximum number of discard rectangles that can be specified.
|
|
|
|
include::../validity/structs/VkPhysicalDeviceDiscardRectanglePropertiesEXT.txt[]
|
|
|
|
If the sname:VkPhysicalDeviceDiscardRectanglePropertiesEXT structure is
|
|
included in the pname:pNext chain of flink:VkPhysicalDeviceProperties2KHR,
|
|
it is filled with the implementation-dependent limits.
|
|
|
|
// refEnd VkPhysicalDeviceDiscardRectanglePropertiesEXT
|
|
|
|
endif::VK_EXT_discard_rectangles[]
|
|
|
|
ifdef::VK_NVX_multiview_per_view_attributes[]
|
|
|
|
// refBegin VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX Structure describing multiview limits that can be supported by an implementation
|
|
|
|
The sname:VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX structure
|
|
is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.txt[]
|
|
|
|
The members of the
|
|
sname:VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX structure
|
|
describe the following implementation-dependent limits:
|
|
|
|
* [[features-limits-perViewPositionAllComponents]]
|
|
pname:perViewPositionAllComponents is ename:VK_TRUE if the
|
|
implementation supports per-view position values that differ in
|
|
components other than the X component.
|
|
|
|
include::../validity/structs/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.txt[]
|
|
|
|
If the sname:VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
|
|
structure is included in the pname:pNext chain of
|
|
flink:VkPhysicalDeviceProperties2KHR, it is filled with the
|
|
implementation-dependent limits.
|
|
|
|
// refEnd VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
|
|
|
|
endif::VK_NVX_multiview_per_view_attributes[]
|
|
|
|
|
|
[[features-limits-minmax]]
|
|
=== 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.
|
|
|
|
[[features-limits-types]]
|
|
.Required Limit Types
|
|
[width="100%",cols="<20%,<50%,<30%",options="header"]
|
|
|====
|
|
| Type | Limit | Feature
|
|
| code:uint32_t | pname:maxImageDimension1D | -
|
|
| code:uint32_t | pname:maxImageDimension2D | -
|
|
| code:uint32_t | pname:maxImageDimension3D | -
|
|
| code:uint32_t | pname:maxImageDimensionCube | -
|
|
| code:uint32_t | pname:maxImageArrayLayers | -
|
|
| code:uint32_t | pname:maxTexelBufferElements | -
|
|
| code:uint32_t | pname:maxUniformBufferRange | -
|
|
| code:uint32_t | pname:maxStorageBufferRange | -
|
|
| code:uint32_t | pname:maxPushConstantsSize | -
|
|
| code:uint32_t | pname:maxMemoryAllocationCount | -
|
|
| code:uint32_t | pname:maxSamplerAllocationCount | -
|
|
| basetype:VkDeviceSize | pname:bufferImageGranularity | -
|
|
| basetype:VkDeviceSize | pname:sparseAddressSpaceSize | sparseBinding
|
|
| code:uint32_t | pname:maxBoundDescriptorSets | -
|
|
| code:uint32_t | pname:maxPerStageDescriptorSamplers | -
|
|
| code:uint32_t | pname:maxPerStageDescriptorUniformBuffers | -
|
|
| code:uint32_t | pname:maxPerStageDescriptorStorageBuffers | -
|
|
| code:uint32_t | pname:maxPerStageDescriptorSampledImages | -
|
|
| code:uint32_t | pname:maxPerStageDescriptorStorageImages | -
|
|
| code:uint32_t | pname:maxPerStageDescriptorInputAttachments| -
|
|
| code:uint32_t | pname:maxPerStageResources | -
|
|
| code:uint32_t | pname:maxDescriptorSetSamplers | -
|
|
| code:uint32_t | pname:maxDescriptorSetUniformBuffers | -
|
|
| code:uint32_t | pname:maxDescriptorSetUniformBuffersDynamic| -
|
|
| code:uint32_t | pname:maxDescriptorSetStorageBuffers | -
|
|
| code:uint32_t | pname:maxDescriptorSetStorageBuffersDynamic| -
|
|
| code:uint32_t | pname:maxDescriptorSetSampledImages | -
|
|
| code:uint32_t | pname:maxDescriptorSetStorageImages | -
|
|
| code:uint32_t | pname:maxDescriptorSetInputAttachments | -
|
|
| code:uint32_t | pname:maxVertexInputAttributes | -
|
|
| code:uint32_t | pname:maxVertexInputBindings | -
|
|
| code:uint32_t | pname:maxVertexInputAttributeOffset | -
|
|
| code:uint32_t | pname:maxVertexInputBindingStride | -
|
|
| code:uint32_t | pname:maxVertexOutputComponents | -
|
|
| code:uint32_t | pname:maxTessellationGenerationLevel | pname:tessellationShader
|
|
| code:uint32_t | pname:maxTessellationPatchSize | pname:tessellationShader
|
|
| code:uint32_t | pname:maxTessellationControlPerVertexInputComponents | pname:tessellationShader
|
|
| code:uint32_t | pname:maxTessellationControlPerVertexOutputComponents | pname:tessellationShader
|
|
| code:uint32_t | pname:maxTessellationControlPerPatchOutputComponents | pname:tessellationShader
|
|
| code:uint32_t | pname:maxTessellationControlTotalOutputComponents | pname:tessellationShader
|
|
| code:uint32_t | pname:maxTessellationEvaluationInputComponents | pname:tessellationShader
|
|
| code:uint32_t | pname:maxTessellationEvaluationOutputComponents | pname:tessellationShader
|
|
| code:uint32_t | pname:maxGeometryShaderInvocations | pname:geometryShader
|
|
| code:uint32_t | pname:maxGeometryInputComponents | pname:geometryShader
|
|
| code:uint32_t | pname:maxGeometryOutputComponents | pname:geometryShader
|
|
| code:uint32_t | pname:maxGeometryOutputVertices | pname:geometryShader
|
|
| code:uint32_t | pname:maxGeometryTotalOutputComponents | pname:geometryShader
|
|
| code:uint32_t | pname:maxFragmentInputComponents | -
|
|
| code:uint32_t | pname:maxFragmentOutputAttachments | -
|
|
| code:uint32_t | pname:maxFragmentDualSrcAttachments | pname:dualSrcBlend
|
|
| code:uint32_t | pname:maxFragmentCombinedOutputResources | -
|
|
| code:uint32_t | pname:maxComputeSharedMemorySize | -
|
|
| 3 {times} code:uint32_t | pname:maxComputeWorkGroupCount | -
|
|
| code:uint32_t | pname:maxComputeWorkGroupInvocations | -
|
|
| 3 {times} code:uint32_t | pname:maxComputeWorkGroupSize | -
|
|
| code:uint32_t | pname:subPixelPrecisionBits | -
|
|
| code:uint32_t | pname:subTexelPrecisionBits | -
|
|
| code:uint32_t | pname:mipmapPrecisionBits | -
|
|
| code:uint32_t | pname:maxDrawIndexedIndexValue | pname:fullDrawIndexUint32
|
|
| code:uint32_t | pname:maxDrawIndirectCount | pname:multiDrawIndirect
|
|
| code:float | pname:maxSamplerLodBias | -
|
|
| code:float | pname:maxSamplerAnisotropy | pname:samplerAnisotropy
|
|
| code:uint32_t | pname:maxViewports | pname:multiViewport
|
|
| 2 {times} code:uint32_t | pname:maxViewportDimensions | -
|
|
| 2 {times} code:float | pname:viewportBoundsRange | -
|
|
| code:uint32_t | pname:viewportSubPixelBits | -
|
|
| code:size_t | pname:minMemoryMapAlignment | -
|
|
| basetype:VkDeviceSize | pname:minTexelBufferOffsetAlignment | -
|
|
| basetype:VkDeviceSize | pname:minUniformBufferOffsetAlignment | -
|
|
| basetype:VkDeviceSize | pname:minStorageBufferOffsetAlignment | -
|
|
| code:int32_t | pname:minTexelOffset | -
|
|
| code:uint32_t | pname:maxTexelOffset | -
|
|
| code:int32_t | pname:minTexelGatherOffset | pname:shaderImageGatherExtended
|
|
| code:uint32_t | pname:maxTexelGatherOffset | pname:shaderImageGatherExtended
|
|
| code:float | pname:minInterpolationOffset | pname:sampleRateShading
|
|
| code:float | pname:maxInterpolationOffset | pname:sampleRateShading
|
|
| code:uint32_t | pname:subPixelInterpolationOffsetBits | pname:sampleRateShading
|
|
| code:uint32_t | pname:maxFramebufferWidth | -
|
|
| code:uint32_t | pname:maxFramebufferHeight | -
|
|
| code:uint32_t | pname:maxFramebufferLayers | -
|
|
| elink:VkSampleCountFlags | pname:framebufferColorSampleCounts | -
|
|
| elink:VkSampleCountFlags | pname:framebufferDepthSampleCounts | -
|
|
| elink:VkSampleCountFlags | pname:framebufferStencilSampleCounts | -
|
|
| elink:VkSampleCountFlags | pname:framebufferNoAttachmentsSampleCounts | -
|
|
| code:uint32_t | pname:maxColorAttachments | -
|
|
| elink:VkSampleCountFlags | pname:sampledImageColorSampleCounts | -
|
|
| elink:VkSampleCountFlags | pname:sampledImageIntegerSampleCounts | -
|
|
| elink:VkSampleCountFlags | pname:sampledImageDepthSampleCounts | -
|
|
| elink:VkSampleCountFlags | pname:sampledImageStencilSampleCounts | -
|
|
| elink:VkSampleCountFlags | pname:storageImageSampleCounts | pname:shaderStorageImageMultisample
|
|
| code:uint32_t | pname:maxSampleMaskWords | -
|
|
| basetype:VkBool32 | pname:timestampComputeAndGraphics | -
|
|
| code:float | pname:timestampPeriod | -
|
|
| code:uint32_t | pname:maxClipDistances | pname:shaderClipDistance
|
|
| code:uint32_t | pname:maxCullDistances | pname:shaderCullDistance
|
|
| code:uint32_t | pname:maxCombinedClipAndCullDistances | pname:shaderCullDistance
|
|
| code:uint32_t | pname:discreteQueuePriorities | -
|
|
| 2 {times} code:float | pname:pointSizeRange | pname:largePoints
|
|
| 2 {times} code:float | pname:lineWidthRange | pname:wideLines
|
|
| code:float | pname:pointSizeGranularity | pname:largePoints
|
|
| code:float | pname:lineWidthGranularity | pname:wideLines
|
|
| basetype:VkBool32 | pname:strictLines | -
|
|
| basetype:VkBool32 | pname:standardSampleLocations | -
|
|
| basetype:VkDeviceSize | pname:optimalBufferCopyOffsetAlignment | -
|
|
| basetype:VkDeviceSize | pname:optimalBufferCopyRowPitchAlignment | -
|
|
| basetype:VkDeviceSize | pname:nonCoherentAtomSize | -
|
|
ifdef::VK_EXT_discard_rectangles[]
|
|
| basetype:uint32_t | pname:maxDiscardRectangles | VK_EXT_discard_rectangles
|
|
endif::VK_EXT_discard_rectangles[]
|
|
|====
|
|
|
|
[[features-limits-required]]
|
|
.Required Limits
|
|
[width="100%",cols="<35,<9,<14,<11",options="header"]
|
|
|====
|
|
| Limit | Unsupported Limit | Supported Limit | Limit Type^1^
|
|
| pname:maxImageDimension1D | - | 4096 | min
|
|
| pname:maxImageDimension2D | - | 4096 | min
|
|
| pname:maxImageDimension3D | - | 256 | min
|
|
| pname:maxImageDimensionCube | - | 4096 | min
|
|
| pname:maxImageArrayLayers | - | 256 | min
|
|
| pname:maxTexelBufferElements | - | 65536 | min
|
|
| pname:maxUniformBufferRange | - | 16384 | min
|
|
| pname:maxStorageBufferRange | - | 2^27^ | min
|
|
| pname:maxPushConstantsSize | - | 128 | min
|
|
| pname:maxMemoryAllocationCount | - | 4096 | min
|
|
| pname:maxSamplerAllocationCount | - | 4000 | min
|
|
| pname:bufferImageGranularity | - | 131072 | max
|
|
| pname:sparseAddressSpaceSize | 0 | 2^31^ | min
|
|
| pname:maxBoundDescriptorSets | - | 4 | min
|
|
| pname:maxPerStageDescriptorSamplers | - | 16 | min
|
|
| pname:maxPerStageDescriptorUniformBuffers | - | 12 | min
|
|
| pname:maxPerStageDescriptorStorageBuffers | - | 4 | min
|
|
| pname:maxPerStageDescriptorSampledImages | - | 16 | min
|
|
| pname:maxPerStageDescriptorStorageImages | - | 4 | min
|
|
| pname:maxPerStageDescriptorInputAttachments| - | 4 | min
|
|
| pname:maxPerStageResources | - | 128 ^2^ | min
|
|
| pname:maxDescriptorSetSamplers | - | 96 ^8^ | min, _n_ {times} PerStage
|
|
| pname:maxDescriptorSetUniformBuffers | - | 72 ^8^ | min, _n_ {times} PerStage
|
|
| pname:maxDescriptorSetUniformBuffersDynamic| - | 8 | min
|
|
| pname:maxDescriptorSetStorageBuffers | - | 24 ^8^ | min, _n_ {times} PerStage
|
|
| pname:maxDescriptorSetStorageBuffersDynamic| - | 4 | min
|
|
| pname:maxDescriptorSetSampledImages | - | 96 ^8^ | min, _n_ {times} PerStage
|
|
| pname:maxDescriptorSetStorageImages | - | 24 ^8^ | min, _n_ {times} PerStage
|
|
| pname:maxDescriptorSetInputAttachments | - | 4 | min
|
|
| pname:maxVertexInputAttributes | - | 16 | min
|
|
| pname:maxVertexInputBindings | - | 16 | min
|
|
| pname:maxVertexInputAttributeOffset | - | 2047 | min
|
|
| pname:maxVertexInputBindingStride | - | 2048 | min
|
|
| pname:maxVertexOutputComponents | - | 64 | min
|
|
| pname:maxTessellationGenerationLevel | 0 | 64 | min
|
|
| pname:maxTessellationPatchSize | 0 | 32 | min
|
|
| pname:maxTessellationControlPerVertexInputComponents | 0 |64 | min
|
|
| pname:maxTessellationControlPerVertexOutputComponents | 0 |64 | min
|
|
| pname:maxTessellationControlPerPatchOutputComponents | 0 |120 | min
|
|
| pname:maxTessellationControlTotalOutputComponents | 0 |2048 | min
|
|
| pname:maxTessellationEvaluationInputComponents | 0 |64 | min
|
|
| pname:maxTessellationEvaluationOutputComponents | 0 |64 | min
|
|
| pname:maxGeometryShaderInvocations | 0 | 32 | min
|
|
| pname:maxGeometryInputComponents | 0 | 64 | min
|
|
| pname:maxGeometryOutputComponents | 0 | 64 | min
|
|
| pname:maxGeometryOutputVertices | 0 | 256 | min
|
|
| pname:maxGeometryTotalOutputComponents | 0 | 1024 | min
|
|
| pname:maxFragmentInputComponents | - | 64 | min
|
|
| pname:maxFragmentOutputAttachments | - | 4 | min
|
|
| pname:maxFragmentDualSrcAttachments | 0 | 1 | min
|
|
| pname:maxFragmentCombinedOutputResources | - | 4 | min
|
|
| pname:maxComputeSharedMemorySize | - | 16384 | min
|
|
| pname:maxComputeWorkGroupCount | - | (65535,65535,65535) | min
|
|
| pname:maxComputeWorkGroupInvocations | - | 128 | min
|
|
| pname:maxComputeWorkGroupSize | - | (128,128,64) | min
|
|
| pname:subPixelPrecisionBits | - | 4 | min
|
|
| pname:subTexelPrecisionBits | - | 4 | min
|
|
| pname:mipmapPrecisionBits | - | 4 | min
|
|
| pname:maxDrawIndexedIndexValue | 2^24^-1 | 2^32^-1 | min
|
|
| pname:maxDrawIndirectCount | 1 | 2^16^-1 | min
|
|
| pname:maxSamplerLodBias | - | 2 | min
|
|
| pname:maxSamplerAnisotropy | 1 | 16 | min
|
|
| pname:maxViewports | 1 | 16 | min
|
|
| pname:maxViewportDimensions | - | (4096,4096) ^3^ | min
|
|
| pname:viewportBoundsRange | - | (-8192,8191) ^4^ | (max,min)
|
|
| pname:viewportSubPixelBits | - | 0 | min
|
|
| pname:minMemoryMapAlignment | - | 64 | min
|
|
| pname:minTexelBufferOffsetAlignment | - | 256 | max
|
|
| pname:minUniformBufferOffsetAlignment | - | 256 | max
|
|
| pname:minStorageBufferOffsetAlignment | - | 256 | max
|
|
| pname:minTexelOffset | - | -8 | max
|
|
| pname:maxTexelOffset | - | 7 | min
|
|
| pname:minTexelGatherOffset | 0 | -8 | max
|
|
| pname:maxTexelGatherOffset | 0 | 7 | min
|
|
| pname:minInterpolationOffset |0.0| -0.5 ^5^ | max
|
|
| pname:maxInterpolationOffset |0.0| 0.5 - (1 ULP) ^5^ | min
|
|
| pname:subPixelInterpolationOffsetBits | 0 | 4 ^5^ | min
|
|
| pname:maxFramebufferWidth | - | 4096 | min
|
|
| pname:maxFramebufferHeight | - | 4096 | min
|
|
| pname:maxFramebufferLayers | - | 256 | min
|
|
| pname:framebufferColorSampleCounts | - | (ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT) | min
|
|
| pname:framebufferDepthSampleCounts | - | (ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT) | min
|
|
| pname:framebufferStencilSampleCounts | - | (ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT) | min
|
|
| pname:framebufferNoAttachmentsSampleCounts | - | (ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT) | min
|
|
| pname:maxColorAttachments | - | 4 | min
|
|
| pname:sampledImageColorSampleCounts | - | (ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT) | min
|
|
| pname:sampledImageIntegerSampleCounts | - | ename:VK_SAMPLE_COUNT_1_BIT | min
|
|
| pname:sampledImageDepthSampleCounts | - | (ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT) | min
|
|
| pname:sampledImageStencilSampleCounts | - | (ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT) | min
|
|
| pname:storageImageSampleCounts | ename:VK_SAMPLE_COUNT_1_BIT | (ename:VK_SAMPLE_COUNT_1_BIT \| ename:VK_SAMPLE_COUNT_4_BIT) | min
|
|
| pname:maxSampleMaskWords | - | 1 | min
|
|
| pname:timestampComputeAndGraphics | - | - |implementation dependent
|
|
| pname:timestampPeriod | - | - |duration
|
|
| pname:maxClipDistances | 0 | 8 | min
|
|
| pname:maxCullDistances | 0 | 8 | min
|
|
| pname:maxCombinedClipAndCullDistances | 0 | 8 | min
|
|
| pname:discreteQueuePriorities | - | 2 | min
|
|
| pname:pointSizeRange | (1.0,1.0) | (1.0,64.0 - ULP)^6^| (max,min)
|
|
| pname:lineWidthRange | (1.0,1.0) | (1.0,8.0 - ULP)^7^ | (max,min)
|
|
| pname:pointSizeGranularity | 0.0 | 1.0 ^6^ | max, fixed point increment
|
|
| pname:lineWidthGranularity | 0.0 | 1.0 ^7^ | max, fixed point increment
|
|
| pname:strictLines | - | - | implementation dependent
|
|
| pname:standardSampleLocations | - | - | implementation dependent
|
|
| pname:optimalBufferCopyOffsetAlignment | - | - | recommendation
|
|
| pname:optimalBufferCopyRowPitchAlignment | - | - | recommendation
|
|
| pname:nonCoherentAtomSize | - | 256 | max
|
|
ifdef::VK_KHR_push_descriptor[]
|
|
| pname:maxPushDescriptors | - | 32 | min
|
|
endif::VK_KHR_push_descriptor[]
|
|
ifdef::VK_KHX_multiview[]
|
|
| pname:maxMultiviewViewCount | - | 6 | min
|
|
| pname:maxMultiviewInstanceIndex | - | 2^27^-1 | min
|
|
endif::VK_KHX_multiview[]
|
|
ifdef::VK_EXT_discard_rectangles[]
|
|
| pname:maxDiscardRectangles | 0 | 4 | min
|
|
endif::VK_EXT_discard_rectangles[]
|
|
ifdef::VK_NVX_multiview_per_view_attributes[]
|
|
| pname:perViewPositionAllComponents | - | - | implementation dependent
|
|
endif::VK_NVX_multiview_per_view_attributes[]
|
|
|====
|
|
|
|
1::
|
|
The *Limit Type* column indicates the limit is either the minimum limit
|
|
all implementations must: support or the maximum limit 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 pname:maxPerStageResources must: be at least the smallest of the
|
|
following:
|
|
|
|
* the sum of the pname:maxPerStageDescriptorUniformBuffers,
|
|
pname:maxPerStageDescriptorStorageBuffers,
|
|
pname:maxPerStageDescriptorSampledImages,
|
|
pname:maxPerStageDescriptorStorageImages,
|
|
pname:maxPerStageDescriptorInputAttachments, pname:maxColorAttachments
|
|
limits, or
|
|
* 128.
|
|
|
|
It may: not be possible to reach this limit in every stage.
|
|
--
|
|
|
|
3::
|
|
See
|
|
<<features-limits-maxViewportDimensions,pname:maxViewportDimensions>>
|
|
for the required: relationship to other limits.
|
|
|
|
4::
|
|
See <<features-limits-viewportboundsrange,pname:viewportBoundsRange>>
|
|
for the required: relationship to other limits.
|
|
|
|
5::
|
|
The values pname:minInterpolationOffset and pname:maxInterpolationOffset
|
|
describe the closed interval of supported interpolation offsets:
|
|
[pname:minInterpolationOffset, pname:maxInterpolationOffset].
|
|
The ULP is determined by pname:subPixelInterpolationOffsetBits.
|
|
If pname:subPixelInterpolationOffsetBits is 4, this provides increments
|
|
of (1/2^4^) = 0.0625, and thus the range of supported interpolation
|
|
offsets would be [eq]#[-0.5, 0.4375]#.
|
|
|
|
6::
|
|
The point size ULP is determined by pname:pointSizeGranularity.
|
|
If the pname:pointSizeGranularity is 0.125, the range of supported point
|
|
sizes must: be at least [1.0, 63.875].
|
|
|
|
7::
|
|
The line width ULP is determined by pname:lineWidthGranularity.
|
|
If the pname:lineWidthGranularity is 0.0625, the range of supported line
|
|
widths must: be at least [1.0, 7.9375].
|
|
|
|
8:: The ptext:maxDescriptorSet* limit is _n_ times the corresponding
|
|
ptext:maxPerStageDescriptor* limit, where _n_ is the number of shader
|
|
stages supported by the VkPhysicalDevice.
|
|
If all shader stages are supported, _n_ = 6 (vertex, tessellation
|
|
control, tessellation evaluation, geometry, fragment, compute).
|
|
|
|
|
|
[[features-formats]]
|
|
== Formats
|
|
|
|
The features for the set of formats (elink:VkFormat) supported by the
|
|
implementation are queried individually using the
|
|
flink:vkGetPhysicalDeviceFormatProperties command.
|
|
|
|
|
|
[[features-formats-definition]]
|
|
=== Format Definition
|
|
|
|
// refBegin VkFormat Available image formats
|
|
|
|
The available formats are defined by the elink:VkFormat enumeration:
|
|
|
|
include::../api/enums/VkFormat.txt[]
|
|
|
|
ename:VK_FORMAT_UNDEFINED::
|
|
The format is not specified.
|
|
|
|
ename:VK_FORMAT_R4G4_UNORM_PACK8::
|
|
A two-component, 8-bit packed unsigned normalized format that has a
|
|
4-bit R component in bits 4..7, and a 4-bit G component in bits 0..3.
|
|
|
|
ename:VK_FORMAT_R4G4B4A4_UNORM_PACK16::
|
|
A four-component, 16-bit packed unsigned normalized format that has a
|
|
4-bit R component in bits 12..15, a 4-bit G component in bits 8..11, a
|
|
4-bit B component in bits 4..7, and a 4-bit A component in bits 0..3.
|
|
|
|
ename:VK_FORMAT_B4G4R4A4_UNORM_PACK16::
|
|
A four-component, 16-bit packed unsigned normalized format that has a
|
|
4-bit B component in bits 12..15, a 4-bit G component in bits 8..11, a
|
|
4-bit R component in bits 4..7, and a 4-bit A component in bits 0..3.
|
|
|
|
ename:VK_FORMAT_R5G6B5_UNORM_PACK16::
|
|
A three-component, 16-bit packed unsigned normalized format that has a
|
|
5-bit R component in bits 11..15, a 6-bit G component in bits 5..10, and
|
|
a 5-bit B component in bits 0..4.
|
|
|
|
ename:VK_FORMAT_B5G6R5_UNORM_PACK16::
|
|
A three-component, 16-bit packed unsigned normalized format that has a
|
|
5-bit B component in bits 11..15, a 6-bit G component in bits 5..10, and
|
|
a 5-bit R component in bits 0..4.
|
|
|
|
ename:VK_FORMAT_R5G5B5A1_UNORM_PACK16::
|
|
A four-component, 16-bit packed unsigned normalized format that has a
|
|
5-bit R component in bits 11..15, a 5-bit G component in bits 6..10, a
|
|
5-bit B component in bits 1..5, and a 1-bit A component in bit 0.
|
|
|
|
ename:VK_FORMAT_B5G5R5A1_UNORM_PACK16::
|
|
A four-component, 16-bit packed unsigned normalized format that has a
|
|
5-bit B component in bits 11..15, a 5-bit G component in bits 6..10, a
|
|
5-bit R component in bits 1..5, and a 1-bit A component in bit 0.
|
|
|
|
ename:VK_FORMAT_A1R5G5B5_UNORM_PACK16::
|
|
A four-component, 16-bit packed unsigned normalized format that has a
|
|
1-bit A component in bit 15, a 5-bit R component in bits 10..14, a 5-bit
|
|
G component in bits 5..9, and a 5-bit B component in bits 0..4.
|
|
|
|
ename:VK_FORMAT_R8_UNORM::
|
|
A one-component, 8-bit unsigned normalized format that has a single
|
|
8-bit R component.
|
|
|
|
ename:VK_FORMAT_R8_SNORM::
|
|
A one-component, 8-bit signed normalized format that has a single 8-bit
|
|
R component.
|
|
|
|
ename:VK_FORMAT_R8_USCALED::
|
|
A one-component, 8-bit unsigned scaled integer format that has a single
|
|
8-bit R component.
|
|
|
|
ename:VK_FORMAT_R8_SSCALED::
|
|
A one-component, 8-bit signed scaled integer format that has a single
|
|
8-bit R component.
|
|
|
|
ename:VK_FORMAT_R8_UINT::
|
|
A one-component, 8-bit unsigned integer format that has a single 8-bit R
|
|
component.
|
|
|
|
ename:VK_FORMAT_R8_SINT::
|
|
A one-component, 8-bit signed integer format that has a single 8-bit R
|
|
component.
|
|
|
|
ename:VK_FORMAT_R8_SRGB::
|
|
A one-component, 8-bit unsigned normalized format that has a single
|
|
8-bit R component stored with sRGB nonlinear encoding.
|
|
|
|
ename:VK_FORMAT_R8G8_UNORM::
|
|
A two-component, 16-bit unsigned normalized format that has an 8-bit R
|
|
component in byte 0, and an 8-bit G component in byte 1.
|
|
|
|
ename:VK_FORMAT_R8G8_SNORM::
|
|
A two-component, 16-bit signed normalized format that has an 8-bit R
|
|
component in byte 0, and an 8-bit G component in byte 1.
|
|
|
|
ename:VK_FORMAT_R8G8_USCALED::
|
|
A two-component, 16-bit unsigned scaled integer format that has an 8-bit
|
|
R component in byte 0, and an 8-bit G component in byte 1.
|
|
|
|
ename:VK_FORMAT_R8G8_SSCALED::
|
|
A two-component, 16-bit signed scaled integer format that has an 8-bit R
|
|
component in byte 0, and an 8-bit G component in byte 1.
|
|
|
|
ename:VK_FORMAT_R8G8_UINT::
|
|
A two-component, 16-bit unsigned integer format that has an 8-bit R
|
|
component in byte 0, and an 8-bit G component in byte 1.
|
|
|
|
ename:VK_FORMAT_R8G8_SINT::
|
|
A two-component, 16-bit signed integer format that has an 8-bit R
|
|
component in byte 0, and an 8-bit G component in byte 1.
|
|
|
|
ename:VK_FORMAT_R8G8_SRGB::
|
|
A two-component, 16-bit unsigned normalized format that has an 8-bit R
|
|
component stored with sRGB nonlinear encoding in byte 0, and an 8-bit G
|
|
component stored with sRGB nonlinear encoding in byte 1.
|
|
|
|
ename:VK_FORMAT_R8G8B8_UNORM::
|
|
A three-component, 24-bit unsigned normalized format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit B
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_R8G8B8_SNORM::
|
|
A three-component, 24-bit signed normalized format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit B
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_R8G8B8_USCALED::
|
|
A three-component, 24-bit unsigned scaled format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit B
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_R8G8B8_SSCALED::
|
|
A three-component, 24-bit signed scaled format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit B
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_R8G8B8_UINT::
|
|
A three-component, 24-bit unsigned integer format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit B
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_R8G8B8_SINT::
|
|
A three-component, 24-bit signed integer format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit B
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_R8G8B8_SRGB::
|
|
A three-component, 24-bit unsigned normalized format that has an 8-bit R
|
|
component stored with sRGB nonlinear encoding in byte 0, an 8-bit G
|
|
component stored with sRGB nonlinear encoding in byte 1, and an 8-bit B
|
|
component stored with sRGB nonlinear encoding in byte 2.
|
|
|
|
ename:VK_FORMAT_B8G8R8_UNORM::
|
|
A three-component, 24-bit unsigned normalized format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit R
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_B8G8R8_SNORM::
|
|
A three-component, 24-bit signed normalized format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit R
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_B8G8R8_USCALED::
|
|
A three-component, 24-bit unsigned scaled format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit R
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_B8G8R8_SSCALED::
|
|
A three-component, 24-bit signed scaled format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit R
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_B8G8R8_UINT::
|
|
A three-component, 24-bit unsigned integer format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit R
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_B8G8R8_SINT::
|
|
A three-component, 24-bit signed integer format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, and an 8-bit R
|
|
component in byte 2.
|
|
|
|
ename:VK_FORMAT_B8G8R8_SRGB::
|
|
A three-component, 24-bit unsigned normalized format that has an 8-bit B
|
|
component stored with sRGB nonlinear encoding in byte 0, an 8-bit G
|
|
component stored with sRGB nonlinear encoding in byte 1, and an 8-bit R
|
|
component stored with sRGB nonlinear encoding in byte 2.
|
|
|
|
ename:VK_FORMAT_R8G8B8A8_UNORM::
|
|
A four-component, 32-bit unsigned normalized format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit B
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_R8G8B8A8_SNORM::
|
|
A four-component, 32-bit signed normalized format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit B
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_R8G8B8A8_USCALED::
|
|
A four-component, 32-bit unsigned scaled format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit B
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_R8G8B8A8_SSCALED::
|
|
A four-component, 32-bit signed scaled format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit B
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_R8G8B8A8_UINT::
|
|
A four-component, 32-bit unsigned integer format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit B
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_R8G8B8A8_SINT::
|
|
A four-component, 32-bit signed integer format that has an 8-bit R
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit B
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_R8G8B8A8_SRGB::
|
|
A four-component, 32-bit unsigned normalized format that has an 8-bit R
|
|
component stored with sRGB nonlinear encoding in byte 0, an 8-bit G
|
|
component stored with sRGB nonlinear encoding in byte 1, an 8-bit B
|
|
component stored with sRGB nonlinear encoding in byte 2, and an 8-bit A
|
|
component in byte 3.
|
|
|
|
ename:VK_FORMAT_B8G8R8A8_UNORM::
|
|
A four-component, 32-bit unsigned normalized format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit R
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_B8G8R8A8_SNORM::
|
|
A four-component, 32-bit signed normalized format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit R
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_B8G8R8A8_USCALED::
|
|
A four-component, 32-bit unsigned scaled format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit R
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_B8G8R8A8_SSCALED::
|
|
A four-component, 32-bit signed scaled format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit R
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_B8G8R8A8_UINT::
|
|
A four-component, 32-bit unsigned integer format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit R
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_B8G8R8A8_SINT::
|
|
A four-component, 32-bit signed integer format that has an 8-bit B
|
|
component in byte 0, an 8-bit G component in byte 1, an 8-bit R
|
|
component in byte 2, and an 8-bit A component in byte 3.
|
|
|
|
ename:VK_FORMAT_B8G8R8A8_SRGB::
|
|
A four-component, 32-bit unsigned normalized format that has an 8-bit B
|
|
component stored with sRGB nonlinear encoding in byte 0, an 8-bit G
|
|
component stored with sRGB nonlinear encoding in byte 1, an 8-bit R
|
|
component stored with sRGB nonlinear encoding in byte 2, and an 8-bit A
|
|
component in byte 3.
|
|
|
|
ename:VK_FORMAT_A8B8G8R8_UNORM_PACK32::
|
|
A four-component, 32-bit packed unsigned normalized format that has an
|
|
8-bit A component in bits 24..31, an 8-bit B component in bits 16..23,
|
|
an 8-bit G component in bits 8..15, and an 8-bit R component in bits
|
|
0..7.
|
|
|
|
ename:VK_FORMAT_A8B8G8R8_SNORM_PACK32::
|
|
A four-component, 32-bit packed signed normalized format that has an
|
|
8-bit A component in bits 24..31, an 8-bit B component in bits 16..23,
|
|
an 8-bit G component in bits 8..15, and an 8-bit R component in bits
|
|
0..7.
|
|
|
|
ename:VK_FORMAT_A8B8G8R8_USCALED_PACK32::
|
|
A four-component, 32-bit packed unsigned scaled integer format that has
|
|
an 8-bit A component in bits 24..31, an 8-bit B component in bits
|
|
16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in
|
|
bits 0..7.
|
|
|
|
ename:VK_FORMAT_A8B8G8R8_SSCALED_PACK32::
|
|
A four-component, 32-bit packed signed scaled integer format that has an
|
|
8-bit A component in bits 24..31, an 8-bit B component in bits 16..23,
|
|
an 8-bit G component in bits 8..15, and an 8-bit R component in bits
|
|
0..7.
|
|
|
|
ename:VK_FORMAT_A8B8G8R8_UINT_PACK32::
|
|
A four-component, 32-bit packed unsigned integer format that has an
|
|
8-bit A component in bits 24..31, an 8-bit B component in bits 16..23,
|
|
an 8-bit G component in bits 8..15, and an 8-bit R component in bits
|
|
0..7.
|
|
|
|
ename:VK_FORMAT_A8B8G8R8_SINT_PACK32::
|
|
A four-component, 32-bit packed signed integer format that has an 8-bit
|
|
A component in bits 24..31, an 8-bit B component in bits 16..23, an
|
|
8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.
|
|
|
|
ename:VK_FORMAT_A8B8G8R8_SRGB_PACK32::
|
|
A four-component, 32-bit packed unsigned normalized format that has an
|
|
8-bit A component in bits 24..31, an 8-bit B component stored with sRGB
|
|
nonlinear encoding in bits 16..23, an 8-bit G component stored with sRGB
|
|
nonlinear encoding in bits 8..15, and an 8-bit R component stored with
|
|
sRGB nonlinear encoding in bits 0..7.
|
|
|
|
ename:VK_FORMAT_A2R10G10B10_UNORM_PACK32::
|
|
A four-component, 32-bit packed unsigned normalized format that has a
|
|
2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a
|
|
10-bit G component in bits 10..19, and a 10-bit B component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2R10G10B10_SNORM_PACK32::
|
|
A four-component, 32-bit packed signed normalized format that has a
|
|
2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a
|
|
10-bit G component in bits 10..19, and a 10-bit B component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2R10G10B10_USCALED_PACK32::
|
|
A four-component, 32-bit packed unsigned scaled integer format that has
|
|
a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29,
|
|
a 10-bit G component in bits 10..19, and a 10-bit B component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2R10G10B10_SSCALED_PACK32::
|
|
A four-component, 32-bit packed signed scaled integer format that has a
|
|
2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a
|
|
10-bit G component in bits 10..19, and a 10-bit B component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2R10G10B10_UINT_PACK32::
|
|
A four-component, 32-bit packed unsigned integer format that has a 2-bit
|
|
A component in bits 30..31, a 10-bit R component in bits 20..29, a
|
|
10-bit G component in bits 10..19, and a 10-bit B component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2R10G10B10_SINT_PACK32::
|
|
A four-component, 32-bit packed signed integer format that has a 2-bit A
|
|
component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit
|
|
G component in bits 10..19, and a 10-bit B component in bits 0..9.
|
|
|
|
ename:VK_FORMAT_A2B10G10R10_UNORM_PACK32::
|
|
A four-component, 32-bit packed unsigned normalized format that has a
|
|
2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a
|
|
10-bit G component in bits 10..19, and a 10-bit R component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2B10G10R10_SNORM_PACK32::
|
|
A four-component, 32-bit packed signed normalized format that has a
|
|
2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a
|
|
10-bit G component in bits 10..19, and a 10-bit R component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2B10G10R10_USCALED_PACK32::
|
|
A four-component, 32-bit packed unsigned scaled integer format that has
|
|
a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29,
|
|
a 10-bit G component in bits 10..19, and a 10-bit R component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2B10G10R10_SSCALED_PACK32::
|
|
A four-component, 32-bit packed signed scaled integer format that has a
|
|
2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a
|
|
10-bit G component in bits 10..19, and a 10-bit R component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2B10G10R10_UINT_PACK32::
|
|
A four-component, 32-bit packed unsigned integer format that has a 2-bit
|
|
A component in bits 30..31, a 10-bit B component in bits 20..29, a
|
|
10-bit G component in bits 10..19, and a 10-bit R component in bits
|
|
0..9.
|
|
|
|
ename:VK_FORMAT_A2B10G10R10_SINT_PACK32::
|
|
A four-component, 32-bit packed signed integer format that has a 2-bit A
|
|
component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit
|
|
G component in bits 10..19, and a 10-bit R component in bits 0..9.
|
|
|
|
ename:VK_FORMAT_R16_UNORM::
|
|
A one-component, 16-bit unsigned normalized format that has a single
|
|
16-bit R component.
|
|
|
|
ename:VK_FORMAT_R16_SNORM::
|
|
A one-component, 16-bit signed normalized format that has a single
|
|
16-bit R component.
|
|
|
|
ename:VK_FORMAT_R16_USCALED::
|
|
A one-component, 16-bit unsigned scaled integer format that has a single
|
|
16-bit R component.
|
|
|
|
ename:VK_FORMAT_R16_SSCALED::
|
|
A one-component, 16-bit signed scaled integer format that has a single
|
|
16-bit R component.
|
|
|
|
ename:VK_FORMAT_R16_UINT::
|
|
A one-component, 16-bit unsigned integer format that has a single 16-bit
|
|
R component.
|
|
|
|
ename:VK_FORMAT_R16_SINT::
|
|
A one-component, 16-bit signed integer format that has a single 16-bit R
|
|
component.
|
|
|
|
ename:VK_FORMAT_R16_SFLOAT::
|
|
A one-component, 16-bit signed floating-point format that has a single
|
|
16-bit R component.
|
|
|
|
ename:VK_FORMAT_R16G16_UNORM::
|
|
A two-component, 32-bit unsigned normalized format that has a 16-bit R
|
|
component in bytes 0..1, and a 16-bit G component in bytes 2..3.
|
|
|
|
ename:VK_FORMAT_R16G16_SNORM::
|
|
A two-component, 32-bit signed normalized format that has a 16-bit R
|
|
component in bytes 0..1, and a 16-bit G component in bytes 2..3.
|
|
|
|
ename:VK_FORMAT_R16G16_USCALED::
|
|
A two-component, 32-bit unsigned scaled integer format that has a 16-bit
|
|
R component in bytes 0..1, and a 16-bit G component in bytes 2..3.
|
|
|
|
ename:VK_FORMAT_R16G16_SSCALED::
|
|
A two-component, 32-bit signed scaled integer format that has a 16-bit R
|
|
component in bytes 0..1, and a 16-bit G component in bytes 2..3.
|
|
|
|
ename:VK_FORMAT_R16G16_UINT::
|
|
A two-component, 32-bit unsigned integer format that has a 16-bit R
|
|
component in bytes 0..1, and a 16-bit G component in bytes 2..3.
|
|
|
|
ename:VK_FORMAT_R16G16_SINT::
|
|
A two-component, 32-bit signed integer format that has a 16-bit R
|
|
component in bytes 0..1, and a 16-bit G component in bytes 2..3.
|
|
|
|
ename:VK_FORMAT_R16G16_SFLOAT::
|
|
A two-component, 32-bit signed floating-point format that has a 16-bit R
|
|
component in bytes 0..1, and a 16-bit G component in bytes 2..3.
|
|
|
|
ename:VK_FORMAT_R16G16B16_UNORM::
|
|
A three-component, 48-bit unsigned normalized format that has a 16-bit R
|
|
component in bytes 0..1, a 16-bit G component in bytes 2..3, and a
|
|
16-bit B component in bytes 4..5.
|
|
|
|
ename:VK_FORMAT_R16G16B16_SNORM::
|
|
A three-component, 48-bit signed normalized format that has a 16-bit R
|
|
component in bytes 0..1, a 16-bit G component in bytes 2..3, and a
|
|
16-bit B component in bytes 4..5.
|
|
|
|
ename:VK_FORMAT_R16G16B16_USCALED::
|
|
A three-component, 48-bit unsigned scaled integer format that has a
|
|
16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3,
|
|
and a 16-bit B component in bytes 4..5.
|
|
|
|
ename:VK_FORMAT_R16G16B16_SSCALED::
|
|
A three-component, 48-bit signed scaled integer format that has a 16-bit
|
|
R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a
|
|
16-bit B component in bytes 4..5.
|
|
|
|
ename:VK_FORMAT_R16G16B16_UINT::
|
|
A three-component, 48-bit unsigned integer format that has a 16-bit R
|
|
component in bytes 0..1, a 16-bit G component in bytes 2..3, and a
|
|
16-bit B component in bytes 4..5.
|
|
|
|
ename:VK_FORMAT_R16G16B16_SINT::
|
|
A three-component, 48-bit signed integer format that has a 16-bit R
|
|
component in bytes 0..1, a 16-bit G component in bytes 2..3, and a
|
|
16-bit B component in bytes 4..5.
|
|
|
|
ename:VK_FORMAT_R16G16B16_SFLOAT::
|
|
A three-component, 48-bit signed floating-point format that has a 16-bit
|
|
R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a
|
|
16-bit B component in bytes 4..5.
|
|
|
|
ename:VK_FORMAT_R16G16B16A16_UNORM::
|
|
A four-component, 64-bit unsigned normalized format that has a 16-bit R
|
|
component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B
|
|
component in bytes 4..5, and a 16-bit A component in bytes 6..7.
|
|
|
|
ename:VK_FORMAT_R16G16B16A16_SNORM::
|
|
A four-component, 64-bit signed normalized format that has a 16-bit R
|
|
component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B
|
|
component in bytes 4..5, and a 16-bit A component in bytes 6..7.
|
|
|
|
ename:VK_FORMAT_R16G16B16A16_USCALED::
|
|
A four-component, 64-bit unsigned scaled integer format that has a
|
|
16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a
|
|
16-bit B component in bytes 4..5, and a 16-bit A component in bytes
|
|
6..7.
|
|
|
|
ename:VK_FORMAT_R16G16B16A16_SSCALED::
|
|
A four-component, 64-bit signed scaled integer format that has a 16-bit
|
|
R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit
|
|
B component in bytes 4..5, and a 16-bit A component in bytes 6..7.
|
|
|
|
ename:VK_FORMAT_R16G16B16A16_UINT::
|
|
A four-component, 64-bit unsigned integer format that has a 16-bit R
|
|
component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B
|
|
component in bytes 4..5, and a 16-bit A component in bytes 6..7.
|
|
|
|
ename:VK_FORMAT_R16G16B16A16_SINT::
|
|
A four-component, 64-bit signed integer format that has a 16-bit R
|
|
component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B
|
|
component in bytes 4..5, and a 16-bit A component in bytes 6..7.
|
|
|
|
ename:VK_FORMAT_R16G16B16A16_SFLOAT::
|
|
A four-component, 64-bit signed floating-point format that has a 16-bit
|
|
R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit
|
|
B component in bytes 4..5, and a 16-bit A component in bytes 6..7.
|
|
|
|
ename:VK_FORMAT_R32_UINT::
|
|
A one-component, 32-bit unsigned integer format that has a single 32-bit
|
|
R component.
|
|
|
|
ename:VK_FORMAT_R32_SINT::
|
|
A one-component, 32-bit signed integer format that has a single 32-bit R
|
|
component.
|
|
|
|
ename:VK_FORMAT_R32_SFLOAT::
|
|
A one-component, 32-bit signed floating-point format that has a single
|
|
32-bit R component.
|
|
|
|
ename:VK_FORMAT_R32G32_UINT::
|
|
A two-component, 64-bit unsigned integer format that has a 32-bit R
|
|
component in bytes 0..3, and a 32-bit G component in bytes 4..7.
|
|
|
|
ename:VK_FORMAT_R32G32_SINT::
|
|
A two-component, 64-bit signed integer format that has a 32-bit R
|
|
component in bytes 0..3, and a 32-bit G component in bytes 4..7.
|
|
|
|
ename:VK_FORMAT_R32G32_SFLOAT::
|
|
A two-component, 64-bit signed floating-point format that has a 32-bit R
|
|
component in bytes 0..3, and a 32-bit G component in bytes 4..7.
|
|
|
|
ename:VK_FORMAT_R32G32B32_UINT::
|
|
A three-component, 96-bit unsigned integer format that has a 32-bit R
|
|
component in bytes 0..3, a 32-bit G component in bytes 4..7, and a
|
|
32-bit B component in bytes 8..11.
|
|
|
|
ename:VK_FORMAT_R32G32B32_SINT::
|
|
A three-component, 96-bit signed integer format that has a 32-bit R
|
|
component in bytes 0..3, a 32-bit G component in bytes 4..7, and a
|
|
32-bit B component in bytes 8..11.
|
|
|
|
ename:VK_FORMAT_R32G32B32_SFLOAT::
|
|
A three-component, 96-bit signed floating-point format that has a 32-bit
|
|
R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a
|
|
32-bit B component in bytes 8..11.
|
|
|
|
ename:VK_FORMAT_R32G32B32A32_UINT::
|
|
A four-component, 128-bit unsigned integer format that has a 32-bit R
|
|
component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B
|
|
component in bytes 8..11, and a 32-bit A component in bytes 12..15.
|
|
|
|
ename:VK_FORMAT_R32G32B32A32_SINT::
|
|
A four-component, 128-bit signed integer format that has a 32-bit R
|
|
component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B
|
|
component in bytes 8..11, and a 32-bit A component in bytes 12..15.
|
|
|
|
ename:VK_FORMAT_R32G32B32A32_SFLOAT::
|
|
A four-component, 128-bit signed floating-point format that has a 32-bit
|
|
R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit
|
|
B component in bytes 8..11, and a 32-bit A component in bytes 12..15.
|
|
|
|
ename:VK_FORMAT_R64_UINT::
|
|
A one-component, 64-bit unsigned integer format that has a single 64-bit
|
|
R component.
|
|
|
|
ename:VK_FORMAT_R64_SINT::
|
|
A one-component, 64-bit signed integer format that has a single 64-bit R
|
|
component.
|
|
|
|
ename:VK_FORMAT_R64_SFLOAT::
|
|
A one-component, 64-bit signed floating-point format that has a single
|
|
64-bit R component.
|
|
|
|
ename:VK_FORMAT_R64G64_UINT::
|
|
A two-component, 128-bit unsigned integer format that has a 64-bit R
|
|
component in bytes 0..7, and a 64-bit G component in bytes 8..15.
|
|
|
|
ename:VK_FORMAT_R64G64_SINT::
|
|
A two-component, 128-bit signed integer format that has a 64-bit R
|
|
component in bytes 0..7, and a 64-bit G component in bytes 8..15.
|
|
|
|
ename:VK_FORMAT_R64G64_SFLOAT::
|
|
A two-component, 128-bit signed floating-point format that has a 64-bit
|
|
R component in bytes 0..7, and a 64-bit G component in bytes 8..15.
|
|
|
|
ename:VK_FORMAT_R64G64B64_UINT::
|
|
A three-component, 192-bit unsigned integer format that has a 64-bit R
|
|
component in bytes 0..7, a 64-bit G component in bytes 8..15, and a
|
|
64-bit B component in bytes 16..23.
|
|
|
|
ename:VK_FORMAT_R64G64B64_SINT::
|
|
A three-component, 192-bit signed integer format that has a 64-bit R
|
|
component in bytes 0..7, a 64-bit G component in bytes 8..15, and a
|
|
64-bit B component in bytes 16..23.
|
|
|
|
ename:VK_FORMAT_R64G64B64_SFLOAT::
|
|
A three-component, 192-bit signed floating-point format that has a
|
|
64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15,
|
|
and a 64-bit B component in bytes 16..23.
|
|
|
|
ename:VK_FORMAT_R64G64B64A64_UINT::
|
|
A four-component, 256-bit unsigned integer format that has a 64-bit R
|
|
component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B
|
|
component in bytes 16..23, and a 64-bit A component in bytes 24..31.
|
|
|
|
ename:VK_FORMAT_R64G64B64A64_SINT::
|
|
A four-component, 256-bit signed integer format that has a 64-bit R
|
|
component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B
|
|
component in bytes 16..23, and a 64-bit A component in bytes 24..31.
|
|
|
|
ename:VK_FORMAT_R64G64B64A64_SFLOAT::
|
|
A four-component, 256-bit signed floating-point format that has a 64-bit
|
|
R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit
|
|
B component in bytes 16..23, and a 64-bit A component in bytes 24..31.
|
|
|
|
ename:VK_FORMAT_B10G11R11_UFLOAT_PACK32::
|
|
A three-component, 32-bit packed unsigned floating-point format that has
|
|
a 10-bit B component in bits 22..31, an 11-bit G component in bits
|
|
11..21, an 11-bit R component in bits 0..10.
|
|
See <<fundamentals-fp10>> and <<fundamentals-fp11>>.
|
|
|
|
ename:VK_FORMAT_E5B9G9R9_UFLOAT_PACK32::
|
|
A three-component, 32-bit packed unsigned floating-point format that has
|
|
a 5-bit shared exponent in bits 27..31, a 9-bit B component mantissa in
|
|
bits 18..26, a 9-bit G component mantissa in bits 9..17, and a 9-bit R
|
|
component mantissa in bits 0..8.
|
|
|
|
ename:VK_FORMAT_D16_UNORM::
|
|
A one-component, 16-bit unsigned normalized format that has a single
|
|
16-bit depth component.
|
|
|
|
ename:VK_FORMAT_X8_D24_UNORM_PACK32::
|
|
A two-component, 32-bit format that has 24 unsigned normalized bits in
|
|
the depth component and, optionally:, 8 bits that are unused.
|
|
|
|
ename:VK_FORMAT_D32_SFLOAT::
|
|
A one-component, 32-bit signed floating-point format that has 32-bits in
|
|
the depth component.
|
|
|
|
ename:VK_FORMAT_S8_UINT::
|
|
A one-component, 8-bit unsigned integer format that has 8-bits in the
|
|
stencil component.
|
|
|
|
ename:VK_FORMAT_D16_UNORM_S8_UINT::
|
|
A two-component, 24-bit format that has 16 unsigned normalized bits in
|
|
the depth component and 8 unsigned integer bits in the stencil
|
|
component.
|
|
|
|
ename:VK_FORMAT_D24_UNORM_S8_UINT::
|
|
A two-component, 32-bit packed format that has 8 unsigned integer bits
|
|
in the stencil component, and 24 unsigned normalized bits in the depth
|
|
component.
|
|
|
|
ename:VK_FORMAT_D32_SFLOAT_S8_UINT::
|
|
A two-component format that has 32 signed float bits in the depth
|
|
component and 8 unsigned integer bits in the stencil component.
|
|
There are optionally: 24-bits that are unused.
|
|
|
|
ename:VK_FORMAT_BC1_RGB_UNORM_BLOCK::
|
|
A three-component, block-compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGB texel
|
|
data.
|
|
This format has no alpha and is considered opaque.
|
|
|
|
ename:VK_FORMAT_BC1_RGB_SRGB_BLOCK::
|
|
A three-component, block-compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGB texel
|
|
data with sRGB nonlinear encoding.
|
|
This format has no alpha and is considered opaque.
|
|
|
|
ename:VK_FORMAT_BC1_RGBA_UNORM_BLOCK::
|
|
A four-component, block-compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGB texel
|
|
data, and provides 1 bit of alpha.
|
|
|
|
ename:VK_FORMAT_BC1_RGBA_SRGB_BLOCK::
|
|
A four-component, block-compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGB texel
|
|
data with sRGB nonlinear encoding, and provides 1 bit of alpha.
|
|
|
|
ename:VK_FORMAT_BC2_UNORM_BLOCK::
|
|
A four-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data with the first 64 bits encoding alpha values followed by 64 bits
|
|
encoding RGB values.
|
|
|
|
ename:VK_FORMAT_BC2_SRGB_BLOCK::
|
|
A four-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data with the first 64 bits encoding alpha values followed by 64 bits
|
|
encoding RGB values with sRGB nonlinear encoding.
|
|
|
|
ename:VK_FORMAT_BC3_UNORM_BLOCK::
|
|
A four-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data with the first 64 bits encoding alpha values followed by 64 bits
|
|
encoding RGB values.
|
|
|
|
ename:VK_FORMAT_BC3_SRGB_BLOCK::
|
|
A four-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data with the first 64 bits encoding alpha values followed by 64 bits
|
|
encoding RGB values with sRGB nonlinear encoding.
|
|
|
|
ename:VK_FORMAT_BC4_UNORM_BLOCK::
|
|
A one-component, block-compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized red texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_BC4_SNORM_BLOCK::
|
|
A one-component, block-compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of signed normalized red texel data.
|
|
|
|
ename:VK_FORMAT_BC5_UNORM_BLOCK::
|
|
A two-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RG texel data
|
|
with the first 64 bits encoding red values followed by 64 bits encoding
|
|
green values.
|
|
|
|
ename:VK_FORMAT_BC5_SNORM_BLOCK::
|
|
A two-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of signed normalized RG texel data
|
|
with the first 64 bits encoding red values followed by 64 bits encoding
|
|
green values.
|
|
|
|
ename:VK_FORMAT_BC6H_UFLOAT_BLOCK::
|
|
A three-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned floating-point RGB texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_BC6H_SFLOAT_BLOCK::
|
|
A three-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of signed floating-point RGB texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_BC7_UNORM_BLOCK::
|
|
A four-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_BC7_SRGB_BLOCK::
|
|
A four-component, block-compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK::
|
|
A three-component, ETC2 compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGB texel
|
|
data.
|
|
This format has no alpha and is considered opaque.
|
|
|
|
ename:VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK::
|
|
A three-component, ETC2 compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGB texel
|
|
data with sRGB nonlinear encoding.
|
|
This format has no alpha and is considered opaque.
|
|
|
|
ename:VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK::
|
|
A four-component, ETC2 compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGB texel
|
|
data, and provides 1 bit of alpha.
|
|
|
|
ename:VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK::
|
|
A four-component, ETC2 compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGB texel
|
|
data with sRGB nonlinear encoding, and provides 1 bit of alpha.
|
|
|
|
ename:VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK::
|
|
A four-component, ETC2 compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data with the first 64 bits encoding alpha values followed by 64 bits
|
|
encoding RGB values.
|
|
|
|
ename:VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK::
|
|
A four-component, ETC2 compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data with the first 64 bits encoding alpha values followed by 64 bits
|
|
encoding RGB values with sRGB nonlinear encoding applied.
|
|
|
|
ename:VK_FORMAT_EAC_R11_UNORM_BLOCK::
|
|
A one-component, ETC2 compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized red texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_EAC_R11_SNORM_BLOCK::
|
|
A one-component, ETC2 compressed format where each 64-bit compressed
|
|
texel block encodes a 4x4 rectangle of signed normalized red texel data.
|
|
|
|
ename:VK_FORMAT_EAC_R11G11_UNORM_BLOCK::
|
|
A two-component, ETC2 compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RG texel data
|
|
with the first 64 bits encoding red values followed by 64 bits encoding
|
|
green values.
|
|
|
|
ename:VK_FORMAT_EAC_R11G11_SNORM_BLOCK::
|
|
A two-component, ETC2 compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of signed normalized RG texel data
|
|
with the first 64 bits encoding red values followed by 64 bits encoding
|
|
green values.
|
|
|
|
ename:VK_FORMAT_ASTC_4x4_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_4x4_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 4x4 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_5x4_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 5x4 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_5x4_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 5x4 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_5x5_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 5x5 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_5x5_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 5x5 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_6x5_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 6x5 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_6x5_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 6x5 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_6x6_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 6x6 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_6x6_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 6x6 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_8x5_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes an 8x5 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_8x5_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes an 8x5 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_8x6_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes an 8x6 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_8x6_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes an 8x6 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_8x8_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes an 8x8 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_8x8_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes an 8x8 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_10x5_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 10x5 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_10x5_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 10x5 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_10x6_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 10x6 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_10x6_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 10x6 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_10x8_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 10x8 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_10x8_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 10x8 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_10x10_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 10x10 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_10x10_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 10x10 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_12x10_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 12x10 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_12x10_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 12x10 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
ename:VK_FORMAT_ASTC_12x12_UNORM_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 12x12 rectangle of unsigned normalized RGBA texel
|
|
data.
|
|
|
|
ename:VK_FORMAT_ASTC_12x12_SRGB_BLOCK::
|
|
A four-component, ASTC compressed format where each 128-bit compressed
|
|
texel block encodes a 12x12 rectangle of unsigned normalized RGBA texel
|
|
data with sRGB nonlinear encoding applied to the RGB components.
|
|
|
|
// refEnd VkFormat
|
|
|
|
|
|
[[features-formats-packed]]
|
|
==== Packed Formats
|
|
|
|
For the purposes of address alignment when accessing buffer memory
|
|
containing vertex attribute or texel data, the following formats are
|
|
considered _packed_ - whole texels or attributes are stored in a single data
|
|
element, rather than individual components occupying a single data element:
|
|
|
|
* <<features-formats-packed-8-bit,Packed into 8-bit data types>>:
|
|
** ename:VK_FORMAT_R4G4_UNORM_PACK8
|
|
* <<features-formats-packed-16-bit,Packed into 16-bit data types>>:
|
|
** ename:VK_FORMAT_R4G4B4A4_UNORM_PACK16
|
|
** ename:VK_FORMAT_B4G4R4A4_UNORM_PACK16
|
|
** ename:VK_FORMAT_R5G6B5_UNORM_PACK16
|
|
** ename:VK_FORMAT_B5G6R5_UNORM_PACK16
|
|
** ename:VK_FORMAT_R5G5B5A1_UNORM_PACK16
|
|
** ename:VK_FORMAT_B5G5R5A1_UNORM_PACK16
|
|
** ename:VK_FORMAT_A1R5G5B5_UNORM_PACK16
|
|
* <<features-formats-packed-32-bit,Packed into 32-bit data types>>:
|
|
** ename:VK_FORMAT_A8B8G8R8_UNORM_PACK32
|
|
** ename:VK_FORMAT_A8B8G8R8_SNORM_PACK32
|
|
** ename:VK_FORMAT_A8B8G8R8_USCALED_PACK32
|
|
** ename:VK_FORMAT_A8B8G8R8_SSCALED_PACK32
|
|
** ename:VK_FORMAT_A8B8G8R8_UINT_PACK32
|
|
** ename:VK_FORMAT_A8B8G8R8_SINT_PACK32
|
|
** ename:VK_FORMAT_A8B8G8R8_SRGB_PACK32
|
|
** ename:VK_FORMAT_A2R10G10B10_UNORM_PACK32
|
|
** ename:VK_FORMAT_A2R10G10B10_SNORM_PACK32
|
|
** ename:VK_FORMAT_A2R10G10B10_USCALED_PACK32
|
|
** ename:VK_FORMAT_A2R10G10B10_SSCALED_PACK32
|
|
** ename:VK_FORMAT_A2R10G10B10_UINT_PACK32
|
|
** ename:VK_FORMAT_A2R10G10B10_SINT_PACK32
|
|
** ename:VK_FORMAT_A2B10G10R10_UNORM_PACK32
|
|
** ename:VK_FORMAT_A2B10G10R10_SNORM_PACK32
|
|
** ename:VK_FORMAT_A2B10G10R10_USCALED_PACK32
|
|
** ename:VK_FORMAT_A2B10G10R10_SSCALED_PACK32
|
|
** ename:VK_FORMAT_A2B10G10R10_UINT_PACK32
|
|
** ename:VK_FORMAT_A2B10G10R10_SINT_PACK32
|
|
** ename:VK_FORMAT_B10G11R11_UFLOAT_PACK32
|
|
** ename:VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
|
|
** ename:VK_FORMAT_X8_D24_UNORM_PACK32
|
|
|
|
|
|
==== Identification of Formats
|
|
|
|
A "`format`" is represented by a single enum value.
|
|
The name of a format is usually built up by using the following pattern:
|
|
|
|
etext:VK_FORMAT_{component-format|compression-scheme}_{numeric-format}
|
|
|
|
The component-format specifies either the size of the R, G, B, and A
|
|
components (if they are present) in the case of a color format, or the size
|
|
of the depth (D) and stencil (S) components (if they are present) in the
|
|
case of a depth/stencil format (see below).
|
|
An X indicates a component that is unused, but may: be present for padding.
|
|
|
|
<<<
|
|
|
|
[[features-formats-numericformat]]
|
|
.Interpretation of Numeric Format
|
|
[width="95%",cols="2,10",options="header"]
|
|
|====
|
|
| Numeric format | Description
|
|
| etext:UNORM | The components are unsigned normalized values in the range [eq]#[0,1]#
|
|
| etext:SNORM | The components are signed normalized values in the range [eq]#[-1,1]#
|
|
| etext:USCALED | The components are unsigned integer values that get converted to floating-point in the range [0,2^n^-1]
|
|
| etext:SSCALED | The components are signed integer values that get converted to floating-point in the range [-2^n-1^,2^n-1^-1]
|
|
| etext:UINT | The components are unsigned integer values in the range [0,2^n^-1]
|
|
| etext:SINT | The components are signed integer values in the range [-2^n-1^,2^n-1^-1]
|
|
| etext:UFLOAT | The components are unsigned floating-point numbers (used by packed, shared exponent, and some compressed formats)
|
|
| etext:SFLOAT | The components are signed floating-point numbers
|
|
| etext:SRGB | The R, G, and B components are unsigned normalized values that represent values using sRGB nonlinear encoding, while the A component (if one exists) is a regular unsigned normalized value
|
|
|====
|
|
|
|
The suffix etext:_PACKnn indicates that the format is packed into an
|
|
underlying type with nn bits.
|
|
|
|
The suffix etext:_BLOCK indicates that the format is a block-compressed
|
|
format, with the representation of multiple pixels encoded interdependently
|
|
within a region.
|
|
|
|
[[features-formats-compressionscheme]]
|
|
.Interpretation of Compression Scheme
|
|
[width="95%",cols="2,10",options="header"]
|
|
|====
|
|
| Compression scheme | Description
|
|
| etext:BC | Block Compression. See <<appendix-compressedtex-bc>>.
|
|
| etext:ETC2 | Ericsson Texture Compression. See <<appendix-compressedtex-etc2>>.
|
|
| etext:EAC | ETC2 Alpha Compression. See <<appendix-compressedtex-etc2>>.
|
|
| etext:ASTC | Adaptive Scalable Texture Compression (LDR Profile). See <<appendix-compressedtex-astc>>.
|
|
|====
|
|
|
|
|
|
==== Representation
|
|
|
|
Color formats must: be represented in memory in exactly the form indicated
|
|
by the format's name.
|
|
This means that promoting one format to another with more bits per component
|
|
and/or additional components must: not occur for color formats.
|
|
Depth/stencil formats have more relaxed requirements as discussed
|
|
<<features-formats-depth-stencil,below>>.
|
|
Each format has an _element size_, the number of bytes used to stored one
|
|
element or one compressed block, with the value of the element size listed
|
|
in slink:VkFormat.
|
|
|
|
The representation of non-packed formats is that the first component
|
|
specified in the name of the format is in the lowest memory addresses and
|
|
the last component specified is in the highest memory addresses.
|
|
See <<features-formats-non-packed,Byte mappings for non-packed/compressed
|
|
color formats>>.
|
|
The in-memory ordering of bytes within a component is determined by the host
|
|
endianness.
|
|
|
|
[[features-formats-non-packed]]
|
|
.Byte mappings for non-packed/compressed color formats
|
|
[options="header",cols="16*1,23",width="100%"]
|
|
|====
|
|
>|0 >|1 >|2 >|3 >|4 >|5 >|6 >|7 >|8 >|9 >|10 >|11 >|12 >|13 >|14 >|15 ^| {leftarrow} Byte
|
|
^|R 16+>s|etext:VK_FORMAT_R8_*
|
|
^|R ^|G 15+>s|etext:VK_FORMAT_R8G8_*
|
|
^|R ^|G ^|B 14+>s|etext:VK_FORMAT_R8G8B8_*
|
|
^|B ^|G ^|R 14+>s|etext:VK_FORMAT_B8G8R8_*
|
|
^|R ^|G ^|B ^|A 13+>s|etext:VK_FORMAT_R8G8B8A8_*
|
|
^|B ^|G ^|R ^|A 13+>s|etext:VK_FORMAT_B8G8R8A8_*
|
|
2+^|R 15+>s|etext:VK_FORMAT_R16_*
|
|
2+^|R 2+^|G 13+>s|etext:VK_FORMAT_R16G16_*
|
|
2+^|R 2+^|G 2+^|B 11+>s|etext:VK_FORMAT_R16G16B16_*
|
|
2+^|R 2+^|G 2+^|B 2+^|A 9+>s|etext:VK_FORMAT_R16G16B16A16_*
|
|
4+^|R 13+>s|etext:VK_FORMAT_R32_*
|
|
4+^|R 4+^|G 9+>s|etext:VK_FORMAT_R32G32_*
|
|
4+^|R 4+^|G 4+^|B 5+>s|etext:VK_FORMAT_R32G32B32_*
|
|
4+^|R 4+^|G 4+^|B 4+^|A >s|etext:VK_FORMAT_R32G32B32A32_*
|
|
8+^|R 9+>s|etext:VK_FORMAT_R64_*
|
|
8+^|R 8+^|G >s|etext:VK_FORMAT_R64G64_*
|
|
17+^s|etext:VK_FORMAT_R64G64B64_* as etext:VK_FORMAT_R64G64_* but with B in bytes 16-23
|
|
17+^s|etext:VK_FORMAT_R64G64B64A64_* as etext:VK_FORMAT_R64G64B64_* but with A in bytes 24-31
|
|
|====
|
|
|
|
Packed formats store multiple components within one underlying type.
|
|
The bit representation is that the first component specified in the name of
|
|
the format is in the most-significant bits and the last component specified
|
|
is in the least-significant bits of the underlying type.
|
|
The in-memory ordering of bytes comprising the underlying type is determined
|
|
by the host endianness.
|
|
|
|
[[features-formats-packed-8-bit]]
|
|
.Bit mappings for packed 8-bit formats
|
|
[options="header",cols="8*1",width="100%"]
|
|
|====
|
|
8+^h| Bit
|
|
>|~7~ >|~6~ >|~5~ >|~4~ >|~3~ >|~2~ >|~1~ >|~0~
|
|
8+^h| ename:VK_FORMAT_R4G4_UNORM_PACK8
|
|
4+^s|R 4+^s|G
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
|====
|
|
|
|
[[features-formats-packed-16-bit]]
|
|
.Bit mappings for packed 16-bit formats
|
|
[options="header",cols="16*1",width="100%"]
|
|
|====
|
|
16+^h| Bit
|
|
>|~15~ >|~14~ >|~13~ >|~12~ >|~11~ >|~10~ >|~9~ >|~8~ >|~7~ >|~6~ >|~5~ >|~4~ >|~3~ >|~2~ >|~1~ >|~0~
|
|
16+^h|ename:VK_FORMAT_R4G4B4A4_UNORM_PACK16
|
|
4+^s|R 4+^s|G 4+^s|B 4+^s|A
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
16+^h|ename:VK_FORMAT_B4G4R4A4_UNORM_PACK16
|
|
4+^s|B 4+^s|G 4+^s|R 4+^s|A
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
16+^h|ename:VK_FORMAT_R5G6B5_UNORM_PACK16
|
|
5+^s|R 6+^s|G 5+^s|B
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~5~ ^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
16+^h|ename:VK_FORMAT_B5G6R5_UNORM_PACK16
|
|
5+^s|B 6+^s|G 5+^s|R
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~5~ ^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
16+^h|ename:VK_FORMAT_R5G5B5A1_UNORM_PACK16
|
|
5+^s|R 5+^s|G 5+^s|B 1+^s|A
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~0~
|
|
16+^h|ename:VK_FORMAT_B5G5R5A1_UNORM_PACK16
|
|
5+^s|B 5+^s|G 5+^s|R 1+^s|A
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~0~
|
|
16+^h|ename:VK_FORMAT_A1R5G5B5_UNORM_PACK16
|
|
1+^s|A 5+^s|R 5+^s|G 5+^s|B
|
|
^| ~0~
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
^| ~4~ ^| ~3~ ^| ~2~ ^| ~1~ ^| ~0~
|
|
|====
|
|
|
|
[[features-formats-packed-32-bit]]
|
|
.Bit mappings for packed 32-bit formats
|
|
[cols="32*1",options="header"]
|
|
|====
|
|
32+^h|Bit
|
|
>|~31~ >|~30~ >|~29~ >|~28~ >|~27~ >|~26~ >|~25~ >|~24~ >|~23~ >|~22~ >|~21~ >|~20~ >|~19~ >|~18~ >|~17~ >|~16~
|
|
>|~15~ >|~14~ >|~13~ >|~12~ >|~11~ >|~10~ >|~9~ >|~8~ >|~7~ >|~6~ >|~5~ >|~4~ >|~3~ >|~2~ >|~1~ >|~0~
|
|
32+^h|etext:VK_FORMAT_A8B8G8R8_*_PACK32
|
|
8+^s|A 8+^s|B 8+^s|G 8+^s|R
|
|
^|~7~ ^|~6~ ^|~5~ ^|~4~
|
|
^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~7~ ^|~6~ ^|~5~ ^|~4~
|
|
^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~7~ ^|~6~ ^|~5~ ^|~4~
|
|
^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~7~ ^|~6~ ^|~5~ ^|~4~
|
|
^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
32+^h|etext:VK_FORMAT_A2R10G10B10_*_PACK32
|
|
2+^s|A 10+^s|R 10+^s|G 10+^s|B
|
|
^|~1~ ^|~0~
|
|
^|~9~ ^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~9~ ^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~9~ ^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
32+^h|etext:VK_FORMAT_A2B10G10R10_*_PACK32
|
|
2+^s|A 10+^s|B 10+^s|G 10+^s|R
|
|
^|~1~ ^|~0~
|
|
^|~9~ ^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~9~ ^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~9~ ^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
32+^h|ename:VK_FORMAT_B10G11R11_UFLOAT_PACK32
|
|
10+^s|B 11+^s|G 11+^s|R
|
|
^|~9~ ^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~10~ ^|~9~ ^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~10~ ^|~9~ ^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
32+^h|ename:VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
|
|
5+^s|E 9+^s|B 9+^s|G 9+^s|R
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~8~ ^|~7~ ^|~6~ ^|~5~
|
|
^|~4~ ^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
32+^h|ename:VK_FORMAT_X8_D24_UNORM_PACK32
|
|
8+^s|X 24+^s|D
|
|
^|~7~ ^|~6~ ^|~5~ ^|~4~
|
|
^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
^|~23~ ^|~22~ ^|~21~ ^|~20~
|
|
^|~19~ ^|~18~ ^|~17~ ^|~16~
|
|
^|~15~ ^|~14~ ^|~13~ ^|~12~
|
|
^|~11~ ^|~10~ ^|~9~ ^|~8~
|
|
^|~7~ ^|~6~ ^|~5~ ^|~4~
|
|
^|~3~ ^|~2~ ^|~1~ ^|~0~
|
|
|====
|
|
|
|
|
|
[[features-formats-depth-stencil]]
|
|
==== Depth/Stencil Formats
|
|
|
|
Depth/stencil formats are considered opaque and need not be stored in the
|
|
exact number of bits per texel or component ordering indicated by the format
|
|
enum.
|
|
However, implementations must: not substitute a different depth or stencil
|
|
precision than that described in the format (e.g. D16 must: not be
|
|
implemented as D24 or D32).
|
|
|
|
|
|
[[features-formats-compatibility-classes]]
|
|
==== Format Compatibility Classes
|
|
|
|
Uncompressed color formats are _compatible_ with each other if they occupy
|
|
the same number of bits per data element.
|
|
Compressed color formats are compatible with each other if the only
|
|
difference between them is the numerical type of the uncompressed pixels
|
|
(e.g. signed vs.
|
|
unsigned, or SRGB vs.
|
|
UNORM encoding).
|
|
Each depth/stencil format is only compatible with itself.
|
|
In the <<features-formats-compatibility,following>> table, all the formats
|
|
in the same row are compatible.
|
|
|
|
|
|
[[features-formats-compatibility]]
|
|
.Compatible formats
|
|
[width="80%",cols="4,10",options="header"]
|
|
|====
|
|
| Class | Formats
|
|
| 8-bit | ename:VK_FORMAT_R4G4_UNORM_PACK8, +
|
|
ename:VK_FORMAT_R8_UNORM, +
|
|
ename:VK_FORMAT_R8_SNORM, +
|
|
ename:VK_FORMAT_R8_USCALED, +
|
|
ename:VK_FORMAT_R8_SSCALED, +
|
|
ename:VK_FORMAT_R8_UINT, +
|
|
ename:VK_FORMAT_R8_SINT, +
|
|
ename:VK_FORMAT_R8_SRGB
|
|
| 16-bit | ename:VK_FORMAT_R4G4B4A4_UNORM_PACK16, +
|
|
ename:VK_FORMAT_B4G4R4A4_UNORM_PACK16, +
|
|
ename:VK_FORMAT_R5G6B5_UNORM_PACK16, +
|
|
ename:VK_FORMAT_B5G6R5_UNORM_PACK16, +
|
|
ename:VK_FORMAT_R5G5B5A1_UNORM_PACK16, +
|
|
ename:VK_FORMAT_B5G5R5A1_UNORM_PACK16, +
|
|
ename:VK_FORMAT_A1R5G5B5_UNORM_PACK16, +
|
|
ename:VK_FORMAT_R8G8_UNORM, +
|
|
ename:VK_FORMAT_R8G8_SNORM, +
|
|
ename:VK_FORMAT_R8G8_USCALED, +
|
|
ename:VK_FORMAT_R8G8_SSCALED, +
|
|
ename:VK_FORMAT_R8G8_UINT, +
|
|
ename:VK_FORMAT_R8G8_SINT, +
|
|
ename:VK_FORMAT_R8G8_SRGB, +
|
|
ename:VK_FORMAT_R16_UNORM, +
|
|
ename:VK_FORMAT_R16_SNORM, +
|
|
ename:VK_FORMAT_R16_USCALED, +
|
|
ename:VK_FORMAT_R16_SSCALED, +
|
|
ename:VK_FORMAT_R16_UINT, +
|
|
ename:VK_FORMAT_R16_SINT, +
|
|
ename:VK_FORMAT_R16_SFLOAT
|
|
| 24-bit | ename:VK_FORMAT_R8G8B8_UNORM, +
|
|
ename:VK_FORMAT_R8G8B8_SNORM, +
|
|
ename:VK_FORMAT_R8G8B8_USCALED, +
|
|
ename:VK_FORMAT_R8G8B8_SSCALED, +
|
|
ename:VK_FORMAT_R8G8B8_UINT, +
|
|
ename:VK_FORMAT_R8G8B8_SINT, +
|
|
ename:VK_FORMAT_R8G8B8_SRGB, +
|
|
ename:VK_FORMAT_B8G8R8_UNORM, +
|
|
ename:VK_FORMAT_B8G8R8_SNORM, +
|
|
ename:VK_FORMAT_B8G8R8_USCALED, +
|
|
ename:VK_FORMAT_B8G8R8_SSCALED, +
|
|
ename:VK_FORMAT_B8G8R8_UINT, +
|
|
ename:VK_FORMAT_B8G8R8_SINT, +
|
|
ename:VK_FORMAT_B8G8R8_SRGB
|
|
| 32-bit | ename:VK_FORMAT_R8G8B8A8_UNORM, +
|
|
ename:VK_FORMAT_R8G8B8A8_SNORM, +
|
|
ename:VK_FORMAT_R8G8B8A8_USCALED, +
|
|
ename:VK_FORMAT_R8G8B8A8_SSCALED, +
|
|
ename:VK_FORMAT_R8G8B8A8_UINT, +
|
|
ename:VK_FORMAT_R8G8B8A8_SINT, +
|
|
ename:VK_FORMAT_R8G8B8A8_SRGB, +
|
|
ename:VK_FORMAT_B8G8R8A8_UNORM, +
|
|
ename:VK_FORMAT_B8G8R8A8_SNORM, +
|
|
ename:VK_FORMAT_B8G8R8A8_USCALED, +
|
|
ename:VK_FORMAT_B8G8R8A8_SSCALED, +
|
|
ename:VK_FORMAT_B8G8R8A8_UINT, +
|
|
ename:VK_FORMAT_B8G8R8A8_SINT, +
|
|
ename:VK_FORMAT_B8G8R8A8_SRGB, +
|
|
ename:VK_FORMAT_A8B8G8R8_UNORM_PACK32, +
|
|
ename:VK_FORMAT_A8B8G8R8_SNORM_PACK32, +
|
|
ename:VK_FORMAT_A8B8G8R8_USCALED_PACK32, +
|
|
ename:VK_FORMAT_A8B8G8R8_SSCALED_PACK32, +
|
|
ename:VK_FORMAT_A8B8G8R8_UINT_PACK32, +
|
|
ename:VK_FORMAT_A8B8G8R8_SINT_PACK32, +
|
|
ename:VK_FORMAT_A8B8G8R8_SRGB_PACK32, +
|
|
ename:VK_FORMAT_A2R10G10B10_UNORM_PACK32, +
|
|
ename:VK_FORMAT_A2R10G10B10_SNORM_PACK32, +
|
|
ename:VK_FORMAT_A2R10G10B10_USCALED_PACK32, +
|
|
ename:VK_FORMAT_A2R10G10B10_SSCALED_PACK32, +
|
|
ename:VK_FORMAT_A2R10G10B10_UINT_PACK32, +
|
|
ename:VK_FORMAT_A2R10G10B10_SINT_PACK32, +
|
|
ename:VK_FORMAT_A2B10G10R10_UNORM_PACK32, +
|
|
ename:VK_FORMAT_A2B10G10R10_SNORM_PACK32, +
|
|
ename:VK_FORMAT_A2B10G10R10_USCALED_PACK32, +
|
|
ename:VK_FORMAT_A2B10G10R10_SSCALED_PACK32, +
|
|
ename:VK_FORMAT_A2B10G10R10_UINT_PACK32, +
|
|
ename:VK_FORMAT_A2B10G10R10_SINT_PACK32, +
|
|
ename:VK_FORMAT_R16G16_UNORM, +
|
|
ename:VK_FORMAT_R16G16_SNORM, +
|
|
ename:VK_FORMAT_R16G16_USCALED, +
|
|
ename:VK_FORMAT_R16G16_SSCALED, +
|
|
ename:VK_FORMAT_R16G16_UINT, +
|
|
ename:VK_FORMAT_R16G16_SINT, +
|
|
ename:VK_FORMAT_R16G16_SFLOAT, +
|
|
ename:VK_FORMAT_R32_UINT, +
|
|
ename:VK_FORMAT_R32_SINT, +
|
|
ename:VK_FORMAT_R32_SFLOAT, +
|
|
ename:VK_FORMAT_B10G11R11_UFLOAT_PACK32, +
|
|
ename:VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
|
|
| 48-bit | ename:VK_FORMAT_R16G16B16_UNORM, +
|
|
ename:VK_FORMAT_R16G16B16_SNORM, +
|
|
ename:VK_FORMAT_R16G16B16_USCALED, +
|
|
ename:VK_FORMAT_R16G16B16_SSCALED, +
|
|
ename:VK_FORMAT_R16G16B16_UINT, +
|
|
ename:VK_FORMAT_R16G16B16_SINT, +
|
|
ename:VK_FORMAT_R16G16B16_SFLOAT
|
|
| 64-bit | ename:VK_FORMAT_R16G16B16A16_UNORM, +
|
|
ename:VK_FORMAT_R16G16B16A16_SNORM, +
|
|
ename:VK_FORMAT_R16G16B16A16_USCALED, +
|
|
ename:VK_FORMAT_R16G16B16A16_SSCALED, +
|
|
ename:VK_FORMAT_R16G16B16A16_UINT, +
|
|
ename:VK_FORMAT_R16G16B16A16_SINT, +
|
|
ename:VK_FORMAT_R16G16B16A16_SFLOAT, +
|
|
ename:VK_FORMAT_R32G32_UINT, +
|
|
ename:VK_FORMAT_R32G32_SINT, +
|
|
ename:VK_FORMAT_R32G32_SFLOAT, +
|
|
ename:VK_FORMAT_R64_UINT, +
|
|
ename:VK_FORMAT_R64_SINT, +
|
|
ename:VK_FORMAT_R64_SFLOAT
|
|
| 96-bit | ename:VK_FORMAT_R32G32B32_UINT, +
|
|
ename:VK_FORMAT_R32G32B32_SINT, +
|
|
ename:VK_FORMAT_R32G32B32_SFLOAT
|
|
| 128-bit | ename:VK_FORMAT_R32G32B32A32_UINT, +
|
|
ename:VK_FORMAT_R32G32B32A32_SINT, +
|
|
ename:VK_FORMAT_R32G32B32A32_SFLOAT, +
|
|
ename:VK_FORMAT_R64G64_UINT, +
|
|
ename:VK_FORMAT_R64G64_SINT, +
|
|
ename:VK_FORMAT_R64G64_SFLOAT
|
|
| 192-bit | ename:VK_FORMAT_R64G64B64_UINT, +
|
|
ename:VK_FORMAT_R64G64B64_SINT, +
|
|
ename:VK_FORMAT_R64G64B64_SFLOAT
|
|
| 256-bit | ename:VK_FORMAT_R64G64B64A64_UINT, +
|
|
ename:VK_FORMAT_R64G64B64A64_SINT, +
|
|
ename:VK_FORMAT_R64G64B64A64_SFLOAT
|
|
| BC1_RGB | ename:VK_FORMAT_BC1_RGB_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_BC1_RGB_SRGB_BLOCK
|
|
| BC1_RGBA | ename:VK_FORMAT_BC1_RGBA_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_BC1_RGBA_SRGB_BLOCK
|
|
| BC2 | ename:VK_FORMAT_BC2_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_BC2_SRGB_BLOCK
|
|
| BC3 | ename:VK_FORMAT_BC3_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_BC3_SRGB_BLOCK
|
|
| BC4 | ename:VK_FORMAT_BC4_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_BC4_SNORM_BLOCK
|
|
| BC5 | ename:VK_FORMAT_BC5_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_BC5_SNORM_BLOCK
|
|
| BC6H | ename:VK_FORMAT_BC6H_UFLOAT_BLOCK, +
|
|
ename:VK_FORMAT_BC6H_SFLOAT_BLOCK
|
|
| BC7 | ename:VK_FORMAT_BC7_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_BC7_SRGB_BLOCK
|
|
| ETC2_RGB | ename:VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
|
|
| ETC2_RGBA | ename:VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
|
|
| ETC2_EAC_RGBA | ename:VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
|
|
| EAC_R | ename:VK_FORMAT_EAC_R11_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_EAC_R11_SNORM_BLOCK
|
|
| EAC_RG | ename:VK_FORMAT_EAC_R11G11_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_EAC_R11G11_SNORM_BLOCK
|
|
| ASTC_4x4 | ename:VK_FORMAT_ASTC_4x4_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_4x4_SRGB_BLOCK
|
|
| ASTC_5x4 | ename:VK_FORMAT_ASTC_5x4_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_5x4_SRGB_BLOCK
|
|
| ASTC_5x5 | ename:VK_FORMAT_ASTC_5x5_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_5x5_SRGB_BLOCK
|
|
| ASTC_6x5 | ename:VK_FORMAT_ASTC_6x5_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_6x5_SRGB_BLOCK
|
|
| ASTC_6x6 | ename:VK_FORMAT_ASTC_6x6_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_6x6_SRGB_BLOCK
|
|
| ASTC_8x5 | ename:VK_FORMAT_ASTC_8x5_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_8x5_SRGB_BLOCK
|
|
| ASTC_8x6 | ename:VK_FORMAT_ASTC_8x6_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_8x6_SRGB_BLOCK
|
|
| ASTC_8x8 | ename:VK_FORMAT_ASTC_8x8_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_8x8_SRGB_BLOCK
|
|
| ASTC_10x5 | ename:VK_FORMAT_ASTC_10x5_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_10x5_SRGB_BLOCK
|
|
| ASTC_10x6 | ename:VK_FORMAT_ASTC_10x6_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_10x6_SRGB_BLOCK
|
|
| ASTC_10x8 | ename:VK_FORMAT_ASTC_10x8_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_10x8_SRGB_BLOCK
|
|
| ASTC_10x10 | ename:VK_FORMAT_ASTC_10x10_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_10x10_SRGB_BLOCK
|
|
| ASTC_12x10 | ename:VK_FORMAT_ASTC_12x10_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_12x10_SRGB_BLOCK
|
|
| ASTC_12x12 | ename:VK_FORMAT_ASTC_12x12_UNORM_BLOCK, +
|
|
ename:VK_FORMAT_ASTC_12x12_SRGB_BLOCK
|
|
| D16 | ename:VK_FORMAT_D16_UNORM
|
|
| D24 | ename:VK_FORMAT_X8_D24_UNORM_PACK32
|
|
| D32 | ename:VK_FORMAT_D32_SFLOAT
|
|
| S8 | ename:VK_FORMAT_S8_UINT
|
|
| D16S8 | ename:VK_FORMAT_D16_UNORM_S8_UINT
|
|
| D24S8 | ename:VK_FORMAT_D24_UNORM_S8_UINT
|
|
| D32S8 | ename:VK_FORMAT_D32_SFLOAT_S8_UINT
|
|
|====
|
|
|
|
|
|
[[features-formats-properties]]
|
|
=== Format Properties
|
|
|
|
// refBegin vkGetPhysicalDeviceFormatProperties Lists physical device's format capabilities
|
|
|
|
To query supported format features which are properties of the physical
|
|
device, call:
|
|
|
|
include::../api/protos/vkGetPhysicalDeviceFormatProperties.txt[]
|
|
|
|
* pname:physicalDevice is the physical device from which to query the
|
|
format properties.
|
|
* pname:format is the format whose properties are queried.
|
|
* pname:pFormatProperties is a pointer to a slink:VkFormatProperties
|
|
structure in which physical device properties for pname:format are
|
|
returned.
|
|
|
|
include::../validity/protos/vkGetPhysicalDeviceFormatProperties.txt[]
|
|
|
|
// refBegin VkFormatProperties Structure specifying image format properties
|
|
|
|
The sname:VkFormatProperties structure is defined as:
|
|
|
|
include::../api/structs/VkFormatProperties.txt[]
|
|
|
|
* pname:linearTilingFeatures describes the features supported by
|
|
ename:VK_IMAGE_TILING_LINEAR.
|
|
* pname:optimalTilingFeatures describes the features supported by
|
|
ename:VK_IMAGE_TILING_OPTIMAL.
|
|
* pname:bufferFeatures describes the features supported by buffers.
|
|
|
|
Supported features are described as a set of elink:VkFormatFeatureFlagBits:
|
|
|
|
// refBegin VkFormatFeatureFlagBits Bitmask specifying features supported by a buffer
|
|
include::../api/enums/VkFormatFeatureFlagBits.txt[]
|
|
|
|
The pname:linearTilingFeatures and pname:optimalTilingFeatures members of
|
|
the sname:VkFormatProperties structure describe what features are supported
|
|
by ename:VK_IMAGE_TILING_LINEAR and ename:VK_IMAGE_TILING_OPTIMAL images,
|
|
respectively.
|
|
|
|
The following bits may: be set in pname:linearTilingFeatures and
|
|
pname:optimalTilingFeatures, indicating they are supported by images or
|
|
image views created with the queried
|
|
flink:vkGetPhysicalDeviceFormatProperties::pname:format:
|
|
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT::
|
|
sname:VkImageView can: be sampled from.
|
|
See <<descriptorsets-sampledimage, sampled images>> section.
|
|
|
|
ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT::
|
|
sname:VkImageView can: be used as storage image.
|
|
See <<descriptorsets-storageimage, storage images>> section.
|
|
|
|
ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT::
|
|
sname:VkImageView can: be used as storage image that supports atomic
|
|
operations.
|
|
|
|
ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT::
|
|
sname:VkImageView can: be used as a framebuffer color attachment and as
|
|
an input attachment.
|
|
|
|
ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT::
|
|
sname:VkImageView can: be used as a framebuffer color attachment that
|
|
supports blending and as an input attachment.
|
|
|
|
ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT::
|
|
sname:VkImageView can: be used as a framebuffer depth/stencil attachment
|
|
and as an input attachment.
|
|
|
|
ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT::
|
|
sname:VkImage can: be used as pname:srcImage for the
|
|
fname:vkCmdBlitImage command.
|
|
|
|
ename:VK_FORMAT_FEATURE_BLIT_DST_BIT::
|
|
sname:VkImage can: be used as pname:dstImage for the
|
|
fname:vkCmdBlitImage command.
|
|
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT::
|
|
If ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT is also set,
|
|
sname:VkImageView can: be used with a sampler that has either of
|
|
pname:magFilter or pname:minFilter set to ename:VK_FILTER_LINEAR, or
|
|
pname:mipmapMode set to ename:VK_SAMPLER_MIPMAP_MODE_LINEAR.
|
|
If ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT is also set, sname:VkImage can
|
|
be used as the pname:srcImage to flink:vkCmdBlitImage with a
|
|
pname:filter of ename:VK_FILTER_LINEAR.
|
|
This bit must: only be exposed for formats that also support the
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT or
|
|
ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT.
|
|
+
|
|
If the format being queried is a depth/stencil format, this bit only
|
|
indicates that the depth aspect (not the stencil aspect) of an image of this
|
|
format supports linear filtering, and that linear filtering of the depth
|
|
aspect is supported whether depth compare is enabled in the sampler or not.
|
|
If this bit is not present, linear filtering with depth compare disabled is
|
|
unsupported and linear filtering with depth compare enabled is supported,
|
|
but may: compute the filtered value in an implementation-dependent manner
|
|
which differs from the normal rules of linear filtering.
|
|
The resulting value must: be in the range [eq]#[0,1]# and should: be
|
|
proportional to, or a weighted average of, the number of comparison passes
|
|
or failures.
|
|
|
|
ifdef::VK_KHR_maintenance1[]
|
|
ename:VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR::
|
|
sname:VkImage can: be used as a source image for <<copies, copy
|
|
commands>>.
|
|
|
|
ename:VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR::
|
|
sname:VkImage can: be used as a destination image for <<copies, copy
|
|
commands>> and <<clears, clear commands>>.
|
|
endif::VK_KHR_maintenance1[]
|
|
|
|
ifdef::VK_IMG_filter_cubic[]
|
|
include::VK_IMG_filter_cubic/filter_cubic_sampled_bit_description.txt[]
|
|
endif::VK_IMG_filter_cubic[]
|
|
|
|
The following features may: appear in pname:bufferFeatures, indicating they
|
|
are supported by buffers or buffer views created with the queried
|
|
flink:vkGetPhysicalDeviceFormatProperties::pname:format:
|
|
|
|
ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT::
|
|
Format can: be used to create a sname:VkBufferView that can: be bound to
|
|
a ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER descriptor.
|
|
|
|
ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT::
|
|
Format can: be used to create a sname:VkBufferView that can: be bound to
|
|
a ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER descriptor.
|
|
|
|
ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT::
|
|
Atomic operations are supported on
|
|
ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER with this format.
|
|
|
|
ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT::
|
|
Format can: be used as a vertex attribute format
|
|
(sname:VkVertexInputAttributeDescription::pname:format).
|
|
|
|
[NOTE]
|
|
.Note
|
|
====
|
|
ifndef::VK_KHR_maintenance1[]
|
|
If no format feature flags are supported, then the only possible use would
|
|
be image transfers - which alone are not useful.
|
|
As such, if no format feature flags are supported, the format itself is not
|
|
supported, and images of that format cannot be created.
|
|
endif::VK_KHR_maintenance1[]
|
|
ifdef::VK_KHR_maintenance1[]
|
|
If no format feature flags are supported, the format itself is not
|
|
supported, and images of that format cannot be created.
|
|
endif::VK_KHR_maintenance1[]
|
|
====
|
|
|
|
If pname:format is a block-compression format, then buffers must: not
|
|
support any features for the format.
|
|
|
|
include::../validity/structs/VkFormatProperties.txt[]
|
|
|
|
ifdef::VK_KHR_get_physical_device_properties2[]
|
|
|
|
// refBegin vkGetPhysicalDeviceFormatProperties2KHR Lists physical device's format capabilities
|
|
|
|
To query supported format features which are properties of the physical
|
|
device, call:
|
|
|
|
include::../api/protos/vkGetPhysicalDeviceFormatProperties2KHR.txt[]
|
|
|
|
* pname:physicalDevice is the physical device from which to query the
|
|
format properties.
|
|
* pname:format is the format whose properties are queried.
|
|
* pname:pFormatProperties is a pointer to a slink:VkFormatProperties2KHR
|
|
structure in which physical device properties for pname:format are
|
|
returned.
|
|
|
|
fname:vkGetPhysicalDeviceFormatProperties2KHR behaves similarly to
|
|
flink:vkGetPhysicalDeviceFormatProperties, with the ability to return
|
|
extended information in a pname:pNext chain of output structures.
|
|
|
|
include::../validity/protos/vkGetPhysicalDeviceFormatProperties2KHR.txt[]
|
|
|
|
// refBegin VkFormatProperties2KHR Structure specifying image format properties
|
|
|
|
The sname:VkFormatProperties2KHR structure is defined as:
|
|
|
|
include::../api/structs/VkFormatProperties2KHR.txt[]
|
|
|
|
* pname:sType is the type of this structure.
|
|
* pname:pNext is `NULL` or a pointer to an extension-specific structure.
|
|
* pname:formatProperties is a structure of type slink:VkFormatProperties
|
|
describing features supported by the requested format.
|
|
|
|
include::../validity/structs/VkFormatProperties2KHR.txt[]
|
|
|
|
endif::VK_KHR_get_physical_device_properties2[]
|
|
|
|
|
|
[[features-required-format-support]]
|
|
=== Required Format Support
|
|
|
|
Implementations must: support at least the following set of features on the
|
|
listed formats.
|
|
For images, these features must: be supported for every elink:VkImageType
|
|
(including arrayed and cube variants) unless otherwise noted.
|
|
These features are supported on existing formats without needing to
|
|
advertise an extension or needing to explicitly enable them.
|
|
Support for additional functionality beyond the requirements listed here is
|
|
queried using the flink:vkGetPhysicalDeviceFormatProperties command.
|
|
|
|
The following tables show which feature bits must: be supported for each
|
|
format.
|
|
ifdef::VK_KHR_maintenance1[]
|
|
Formats that are required to support
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT must: also support
|
|
ename:VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR and
|
|
ename:VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR.
|
|
endif::VK_KHR_maintenance1[]
|
|
|
|
.Key for format feature tables
|
|
[width="70%",cols="1,10"]
|
|
|====
|
|
^|{sym1} | This feature must: be supported on the named format
|
|
^|{sym2} | This feature must: be supported on at least some
|
|
of the named formats, with more information in the table
|
|
where the symbol appears
|
|
|====
|
|
|
|
.Feature bits in pname:optimalTilingFeatures
|
|
[width="70%"]
|
|
|====
|
|
ifdef::VK_KHR_maintenance1[]
|
|
|ename:VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR
|
|
|ename:VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR
|
|
endif::VK_KHR_maintenance1[]
|
|
|ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
|
|
|ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT
|
|
|ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
|
|
|ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
|
|
|ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
|
|
|ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
|
|
|ename:VK_FORMAT_FEATURE_BLIT_DST_BIT
|
|
|ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
|
|
|ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
|
|
|====
|
|
|
|
.Feature bits in pname:bufferFeatures
|
|
[width="70%"]
|
|
|====
|
|
|ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
|
|
|ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
|
|
|ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
|
|
|ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-subbyte]]
|
|
.Mandatory format support: sub-byte channels
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_UNDEFINED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R4G4_UNORM_PACK8 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R4G4B4A4_UNORM_PACK16 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B4G4R4A4_UNORM_PACK16 | {sym1} | {sym1} | {sym1} | | | | | | | | | |
|
|
| ename:VK_FORMAT_R5G6B5_UNORM_PACK16 | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | | | |
|
|
| ename:VK_FORMAT_B5G6R5_UNORM_PACK16 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R5G5B5A1_UNORM_PACK16 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B5G5R5A1_UNORM_PACK16 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A1R5G5B5_UNORM_PACK16 | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | | | |
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-2byte]]
|
|
.Mandatory format support: 1-3 byte-sized channels
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_R8_UNORM | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R8_SNORM | {sym1} | {sym1} | {sym1} | | | | | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R8_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8_UINT | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R8_SINT | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R8_SRGB | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8_UNORM | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R8G8_SNORM | {sym1} | {sym1} | {sym1} | | | | | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R8G8_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8_UINT | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R8G8_SINT | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R8G8_SRGB | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8B8_UNORM | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8B8_SNORM | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8B8_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8B8_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8B8_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8B8_SINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8B8_SRGB | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8_UNORM | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8_SNORM | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8_SINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8_SRGB | | | | | | | | | | | | |
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-4byte]]
|
|
.Mandatory format support: 4 byte-sized channels
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_R8G8B8A8_UNORM | {sym1} | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R8G8B8A8_SNORM | {sym1} | {sym1} | {sym1} | {sym1} | | | | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R8G8B8A8_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8B8A8_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R8G8B8A8_UINT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R8G8B8A8_SINT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R8G8B8A8_SRGB | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | | | |
|
|
| ename:VK_FORMAT_B8G8R8A8_UNORM | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_B8G8R8A8_SNORM | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8A8_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8A8_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8A8_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8A8_SINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B8G8R8A8_SRGB | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | | | |
|
|
| ename:VK_FORMAT_A8B8G8R8_UNORM_PACK32 | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_A8B8G8R8_SNORM_PACK32 | {sym1} | {sym1} | {sym1} | | | | | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_A8B8G8R8_USCALED_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A8B8G8R8_SSCALED_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A8B8G8R8_UINT_PACK32 | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_A8B8G8R8_SINT_PACK32 | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_A8B8G8R8_SRGB_PACK32 | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | | | |
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-10bit]]
|
|
.Mandatory format support: 10-bit channels
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_A2R10G10B10_UNORM_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A2R10G10B10_SNORM_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A2R10G10B10_USCALED_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A2R10G10B10_SSCALED_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A2R10G10B10_UINT_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A2R10G10B10_SINT_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A2B10G10R10_UNORM_PACK32 | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_A2B10G10R10_SNORM_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A2B10G10R10_USCALED_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A2B10G10R10_SSCALED_PACK32 | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_A2B10G10R10_UINT_PACK32 | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | | {sym1} | |
|
|
| ename:VK_FORMAT_A2B10G10R10_SINT_PACK32 | | | | | | | | | | | | |
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-16bit]]
|
|
.Mandatory format support: 16-bit channels
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_R16_UNORM | | | | | | | | | | {sym1} | | |
|
|
| ename:VK_FORMAT_R16_SNORM | | | | | | | | | | {sym1} | | |
|
|
| ename:VK_FORMAT_R16_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16_UINT | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R16_SINT | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R16_SFLOAT | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R16G16_UNORM | | | | | | | | | | {sym1} | | |
|
|
| ename:VK_FORMAT_R16G16_SNORM | | | | | | | | | | {sym1} | | |
|
|
| ename:VK_FORMAT_R16G16_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16_UINT | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R16G16_SINT | {sym1} | {sym1} | | | | {sym1} | {sym1} | | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R16G16_SFLOAT | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | |
|
|
| ename:VK_FORMAT_R16G16B16_UNORM | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16B16_SNORM | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16B16_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16B16_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16B16_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16B16_SINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16B16_SFLOAT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16B16A16_UNORM | | | | | | | | | | {sym1} | | |
|
|
| ename:VK_FORMAT_R16G16B16A16_SNORM | | | | | | | | | | {sym1} | | |
|
|
| ename:VK_FORMAT_R16G16B16A16_USCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16B16A16_SSCALED | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R16G16B16A16_UINT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R16G16B16A16_SINT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R16G16B16A16_SFLOAT | {sym1} | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | {sym1} | | {sym1} | {sym1} | {sym1} |
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-32bit]]
|
|
.Mandatory format support: 32-bit channels
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_R32_UINT | {sym1} | {sym1} | | {sym1} | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | {sym1}
|
|
| ename:VK_FORMAT_R32_SINT | {sym1} | {sym1} | | {sym1} | {sym1} | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} | {sym1}
|
|
| ename:VK_FORMAT_R32_SFLOAT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R32G32_UINT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R32G32_SINT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R32G32_SFLOAT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R32G32B32_UINT | | | | | | | | | | {sym1} | | |
|
|
| ename:VK_FORMAT_R32G32B32_SINT | | | | | | | | | | {sym1} | | |
|
|
| ename:VK_FORMAT_R32G32B32_SFLOAT | | | | | | | | | | {sym1} | | |
|
|
| ename:VK_FORMAT_R32G32B32A32_UINT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R32G32B32A32_SINT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
| ename:VK_FORMAT_R32G32B32A32_SFLOAT | {sym1} | {sym1} | | {sym1} | | {sym1} | {sym1} | | | {sym1} | {sym1} | {sym1} |
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-64bit]]
|
|
.Mandatory format support: 64-bit/uneven channels
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_R64_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64_SINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64_SFLOAT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64G64_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64G64_SINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64G64_SFLOAT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64G64B64_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64G64B64_SINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64G64B64_SFLOAT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64G64B64A64_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64G64B64A64_SINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_R64G64B64A64_SFLOAT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_B10G11R11_UFLOAT_PACK32 | {sym1} | {sym1} | {sym1} | | | | | | | | {sym1} | |
|
|
| ename:VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 | {sym1} | {sym1} | {sym1} | | | | | | | | | |
|
|
|====
|
|
|
|
[[features-formats-mandatory-features-depth-stencil]]
|
|
.Mandatory format support: depth/stencil with elink:VkImageType ename:VK_IMAGE_TYPE_2D
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_D16_UNORM | {sym1} | {sym1} | | | | | | | {sym1} | | | |
|
|
| ename:VK_FORMAT_X8_D24_UNORM_PACK32 | | | | | | | | | {sym2} | | | |
|
|
| ename:VK_FORMAT_D32_SFLOAT | {sym1} | {sym1} | | | | | | | {sym2} | | | |
|
|
| ename:VK_FORMAT_S8_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_D16_UNORM_S8_UINT | | | | | | | | | | | | |
|
|
| ename:VK_FORMAT_D24_UNORM_S8_UINT | | | | | | | | | {sym2} | | | |
|
|
| ename:VK_FORMAT_D32_SFLOAT_S8_UINT | | | | | | | | | {sym2} | | | |
|
|
14+| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT feature must: be
|
|
supported for at least one of ename:VK_FORMAT_X8_D24_UNORM_PACK32 and
|
|
ename:VK_FORMAT_D32_SFLOAT, and must: be supported for at least one of
|
|
ename:VK_FORMAT_D24_UNORM_S8_UINT and ename:VK_FORMAT_D32_SFLOAT_S8_UINT.
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-bcn]]
|
|
.Mandatory format support: BC compressed formats with elink:VkImageType ename:VK_IMAGE_TYPE_2D and ename:VK_IMAGE_TYPE_3D
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_BC1_RGB_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC1_RGB_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC1_RGBA_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC1_RGBA_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC2_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC2_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC3_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC3_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC4_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC4_SNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC5_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC5_SNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC6H_UFLOAT_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC6H_SFLOAT_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC7_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_BC7_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
14+| The ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
|
|
ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT and
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must: be
|
|
supported in pname:optimalTilingFeatures for all the formats in at least
|
|
one of: this table, <<features-formats-mandatory-features-etc>>, or
|
|
<<features-formats-mandatory-features-astc>>.
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-etc]]
|
|
.Mandatory format support: ETC2 and EAC compressed formats with elink:VkImageType ename:VK_IMAGE_TYPE_2D
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_EAC_R11_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_EAC_R11_SNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_EAC_R11G11_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_EAC_R11G11_SNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
14+|The ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
|
|
ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT and
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must: be
|
|
supported in pname:optimalTilingFeatures for all the formats in at least
|
|
one of: this table, <<features-formats-mandatory-features-bcn>>, or
|
|
<<features-formats-mandatory-features-astc>>.
|
|
|====
|
|
|
|
<<<
|
|
|
|
[[features-formats-mandatory-features-astc]]
|
|
.Mandatory format support: ASTC LDR compressed formats with elink:VkImageType ename:VK_IMAGE_TYPE_2D
|
|
[width="100%",cols="10,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1,^1",options="unbreakable"]
|
|
|====
|
|
14+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
|
|
13+>| ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT .13+^.^| {downarrow}
|
|
12+>| ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT .12+^.^| {downarrow}
|
|
11+>| ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT .11+^.^| {downarrow}
|
|
10+>| ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT .10+^.^| {downarrow}
|
|
9+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT .9+^.^| {downarrow}
|
|
8+>| ename:VK_FORMAT_FEATURE_BLIT_DST_BIT .8+^.^| {downarrow}
|
|
7+>| ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT .7+^.^| {downarrow}
|
|
6+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT .6+^.^| {downarrow}
|
|
5+>| ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT .5+^.^| {downarrow}
|
|
4+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT .4+^.^| {downarrow}
|
|
3+>| ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT .3+^.^| {downarrow}
|
|
2+>| ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT .2+^.^| {downarrow}
|
|
s| Format ^.^| {downarrow}
|
|
| ename:VK_FORMAT_ASTC_4x4_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_4x4_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_5x4_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_5x4_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_5x5_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_5x5_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_6x5_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_6x5_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_6x6_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_6x6_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_8x5_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_8x5_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_8x6_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_8x6_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_8x8_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_8x8_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_10x5_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_10x5_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_10x6_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_10x6_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_10x8_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_10x8_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_10x10_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_10x10_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_12x10_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_12x10_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_12x12_UNORM_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
| ename:VK_FORMAT_ASTC_12x12_SRGB_BLOCK | {sym2} | {sym2} | {sym2} | | | | | | | | | |
|
|
14+|The ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
|
|
ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT and
|
|
ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must: be
|
|
supported in pname:optimalTilingFeatures for all the formats in at least
|
|
one of: this table, <<features-formats-mandatory-features-bcn>>, or
|
|
<<features-formats-mandatory-features-etc>>.
|
|
|====
|
|
|
|
ifdef::VK_IMG_filter_cubic[]
|
|
include::VK_IMG_filter_cubic/supported_formats.txt[]
|
|
endif::VK_IMG_filter_cubic[]
|
|
|
|
== Additional Image Capabilities
|
|
|
|
In addition to the minimum capabilities described in the previous sections
|
|
(<<features-limits,Limits>> and <<features-formats,Formats>>),
|
|
implementations may: support additional capabilities for certain types of
|
|
images.
|
|
For example, larger dimensions or additional sample counts for certain image
|
|
types, or additional capabilities for _linear_ tiling format images.
|
|
|
|
// refBegin vkGetPhysicalDeviceImageFormatProperties Lists physical device's image format capabilities
|
|
|
|
To query additional capabilities specific to image types, call:
|
|
|
|
include::../api/protos/vkGetPhysicalDeviceImageFormatProperties.txt[]
|
|
|
|
* pname:physicalDevice is the physical device from which to query the
|
|
image capabilities.
|
|
* pname:format is the image format, corresponding to
|
|
slink:VkImageCreateInfo::pname:format.
|
|
* pname:type is the image type, corresponding to
|
|
slink:VkImageCreateInfo::pname:imageType.
|
|
* pname:tiling is the image tiling, corresponding to
|
|
slink:VkImageCreateInfo::pname:tiling.
|
|
* pname:usage is the intended usage of the image, corresponding to
|
|
slink:VkImageCreateInfo::pname:usage.
|
|
* pname:flags is a bitmask describing additional parameters of the image,
|
|
corresponding to slink:VkImageCreateInfo::pname:flags.
|
|
* pname:pImageFormatProperties points to an instance of the
|
|
slink:VkImageFormatProperties structure in which capabilities are
|
|
returned.
|
|
|
|
The pname:format, pname:type, pname:tiling, pname:usage, and pname:flags
|
|
parameters correspond to parameters that would be consumed by
|
|
flink:vkCreateImage (as members of sname:VkImageCreateInfo).
|
|
|
|
If pname:format is not a supported image format, or if the combination of
|
|
pname:format, pname:type, pname:tiling, pname:usage, and pname:flags is not
|
|
supported for images, then fname:vkGetPhysicalDeviceImageFormatProperties
|
|
returns ename:VK_ERROR_FORMAT_NOT_SUPPORTED.
|
|
|
|
The limitations on an image format that are reported by
|
|
fname:vkGetPhysicalDeviceImageFormatProperties have the following property:
|
|
if code:usage1 and code:usage2 of type elink:VkImageUsageFlags are such that
|
|
the bits set in code:usage1 are a subset of the bits set in code:usage2, and
|
|
code:flags1 and code:flags2 of type elink:VkImageCreateFlags are such that
|
|
the bits set in code:flags1 are a subset of the bits set in code:flags2,
|
|
then the limitations for code:usage1 and code:flags1 must: be no more strict
|
|
than the limitations for code:usage2 and code:flags2, for all values of
|
|
pname:format, pname:type, and pname:tiling.
|
|
|
|
include::../validity/protos/vkGetPhysicalDeviceImageFormatProperties.txt[]
|
|
|
|
// refBegin VkImageFormatProperties Structure specifying a image format properties
|
|
|
|
The sname:VkImageFormatProperties structure is defined as:
|
|
|
|
include::../api/structs/VkImageFormatProperties.txt[]
|
|
|
|
* pname:maxExtent are the maximum image dimensions.
|
|
See the <<features-extentperimagetype,Allowed Extent Values>> section
|
|
below for how these values are constrained by pname:type.
|
|
* pname:maxMipLevels is the maximum number of mipmap levels.
|
|
pname:maxMipLevels must: either be equal to 1 (valid only if
|
|
pname:tiling is ename:VK_IMAGE_TILING_LINEAR) or be equal to
|
|
[eq]#{lceil}log~2~(max(pname:width, pname:height, pname:depth)){rceil}
|
|
{plus} 1#.
|
|
[eq]#pname:width#, [eq]#pname:height#, and [eq]#pname:depth# are taken
|
|
from the corresponding members of pname:maxExtent.
|
|
* pname:maxArrayLayers is the maximum number of array layers.
|
|
pname:maxArrayLayers must: either be equal to 1 or be greater than or
|
|
equal to the pname:maxImageArrayLayers member of
|
|
slink:VkPhysicalDeviceLimits.
|
|
A value of 1 is valid only if pname:tiling is
|
|
ename:VK_IMAGE_TILING_LINEAR or if pname:type is ename:VK_IMAGE_TYPE_3D.
|
|
* pname:sampleCounts is a bitmask of elink:VkSampleCountFlagBits
|
|
specifying all the supported sample counts for this image as described
|
|
<<features-supported-sample-counts, below>>.
|
|
* pname:maxResourceSize is an upper bound on the total image size in
|
|
bytes, inclusive of all image subresources.
|
|
Implementations may: have an address space limit on total size of a
|
|
resource, which is advertised by this property.
|
|
pname:maxResourceSize must: be at least 2^31^.
|
|
|
|
[NOTE]
|
|
.Note
|
|
====
|
|
There is no mechanism to query the size of an image before creating it, to
|
|
compare that size against pname:maxResourceSize.
|
|
If an application attempts to create an image that exceeds this limit, the
|
|
creation will fail or the image will be invalid.
|
|
While the advertised limit must: be at least 2^31^, it may: not be possible
|
|
to create an image that approaches that size, particularly for
|
|
ename:VK_IMAGE_TYPE_1D.
|
|
====
|
|
|
|
If the combination of parameters to
|
|
fname:vkGetPhysicalDeviceImageFormatProperties is not supported by the
|
|
implementation for use in flink:vkCreateImage, then all members of
|
|
sname:VkImageFormatProperties will be filled with zero.
|
|
|
|
include::../validity/structs/VkImageFormatProperties.txt[]
|
|
|
|
ifdef::VK_NV_external_memory_capabilities[]
|
|
include::./VK_NV_external_memory_capabilities/external_image_format.txt[]
|
|
endif::VK_NV_external_memory_capabilities[]
|
|
|
|
ifdef::VK_KHR_get_physical_device_properties2[]
|
|
|
|
// refBegin vkGetPhysicalDeviceImageFormatProperties2KHR Lists physical device's image format capabilities
|
|
|
|
To query additional capabilities specific to image types, call:
|
|
|
|
include::../api/protos/vkGetPhysicalDeviceImageFormatProperties2KHR.txt[]
|
|
|
|
* pname:physicalDevice is the physical device from which to query the
|
|
image capabilities.
|
|
* pname:pImageFormatInfo points to an instance of the
|
|
slink:VkPhysicalDeviceImageFormatInfo2KHR structure, describing the
|
|
parameters that would be consumed by flink:vkCreateImage.
|
|
* pname:pImageFormatProperties points to an instance of the
|
|
slink:VkImageFormatProperties2KHR structure in which capabilities are
|
|
returned.
|
|
|
|
fname:vkGetPhysicalDeviceImageFormatProperties2KHR behaves similarly to
|
|
flink:vkGetPhysicalDeviceImageFormatProperties, with the ability to return
|
|
extended information in a pname:pNext chain of output structures.
|
|
|
|
If the loader implementation emulates
|
|
fname:vkGetPhysicalDeviceImageFormatProperties2KHR on a device that does not
|
|
support the extension, and the query involves a structure the loader does
|
|
not support, fname:vkGetPhysicalDeviceImageFormatProperties2KHR returns
|
|
ename:VK_ERROR_FORMAT_NOT_SUPPORTED.
|
|
|
|
include::../validity/protos/vkGetPhysicalDeviceImageFormatProperties2KHR.txt[]
|
|
|
|
// refBegin VkPhysicalDeviceImageFormatInfo2KHR Structure specifying image creation parameters
|
|
|
|
The sname:VkPhysicalDeviceImageFormatInfo2KHR structure is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceImageFormatInfo2KHR.txt[]
|
|
|
|
* pname:sType is the type of this structure.
|
|
* pname:pNext is `NULL` or a pointer to an extension-specific structure.
|
|
* pname:format is the image format, corresponding to
|
|
slink:VkImageCreateInfo::pname:format.
|
|
* pname:type is the image type, corresponding to
|
|
slink:VkImageCreateInfo::pname:imageType.
|
|
* pname:tiling is the image tiling, corresponding to
|
|
slink:VkImageCreateInfo::pname:tiling.
|
|
* pname:usage is the intended usage of the image, corresponding to
|
|
slink:VkImageCreateInfo::pname:usage.
|
|
* pname:flags is a bitmask describing additional parameters of the image,
|
|
corresponding to slink:VkImageCreateInfo::pname:flags.
|
|
|
|
The members of sname:VkPhysicalDeviceImageFormatInfo2KHR correspond to the
|
|
arguments to flink:vkGetPhysicalDeviceImageFormatProperties, with
|
|
pname:sType and pname:pNext added for extensibility.
|
|
|
|
include::../validity/structs/VkPhysicalDeviceImageFormatInfo2KHR.txt[]
|
|
|
|
// refBegin VkImageFormatProperties2KHR Structure specifying a image format properties
|
|
|
|
The sname:VkImageFormatProperties2KHR structure is defined as:
|
|
|
|
include::../api/structs/VkImageFormatProperties2KHR.txt[]
|
|
|
|
* pname:sType is the type of this structure.
|
|
* pname:pNext is `NULL` or a pointer to an extension-specific structure.
|
|
* pname:imageFormatProperties is an instance of a
|
|
slink:VkImageFormatProperties structure in which capabilities are
|
|
returned.
|
|
|
|
If the combination of parameters to
|
|
fname:vkGetPhysicalDeviceImageFormatProperties2KHR is not supported by the
|
|
implementation for use in flink:vkCreateImage, then all members of
|
|
pname:imageFormatProperties will be filled with zero.
|
|
|
|
include::../validity/structs/VkImageFormatProperties2KHR.txt[]
|
|
|
|
ifdef::VK_KHX_external_memory_capabilities[]
|
|
// refBegin VkPhysicalDeviceExternalImageFormatInfoKHX Structure specifying external image creation parameters
|
|
|
|
To determine the image capabilities compatible with an external memory
|
|
handle type, add slink:VkPhysicalDeviceExternalImageFormatInfoKHX to the
|
|
pname:pNext chain of the slink:VkPhysicalDeviceImageFormatInfo2KHR structure
|
|
and sname:VkExternalImageFormatPropertiesKHX to the pname:pNext chain of the
|
|
slink:VkImageFormatProperties2KHR structure.
|
|
|
|
The sname:VkPhysicalDeviceExternalImageFormatInfoKHX structure is defined
|
|
as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceExternalImageFormatInfoKHX.txt[]
|
|
|
|
* pname:sType is the type of this structure.
|
|
* pname:pNext is `NULL` or a pointer to an extension-specific structure.
|
|
* pname:handleType is a bit indicating a memory handle type that will be
|
|
used with the memory associated with the image.
|
|
Bits which can be set include:
|
|
+
|
|
--
|
|
// refBegin VkExternalMemoryHandleTypeFlagBitsKHX - Bitmask of valid external memory handle types
|
|
include::../api/enums/VkExternalMemoryHandleTypeFlagBitsKHX.txt[]
|
|
|
|
** ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX is a POSIX file
|
|
descriptor handle that has only limited valid usage outside of Vulkan
|
|
and other compatible APIs.
|
|
It must: be compatible with the POSIX system calls fname:dup,
|
|
fname:dup2, fname:close, and the non-standard system call fname:dup3.
|
|
Additionally, it must: be transportable over a socket using an
|
|
ename:SCM_RIGHTS control message.
|
|
It owns a reference to the underlying memory resource represented by
|
|
its Vulkan memory object.
|
|
** ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_WIN32_BIT_KHX is an NT handle that
|
|
has only limited valid usage outside of Vulkan and other compatible
|
|
APIs.
|
|
It must: be compatible with the functions fname:DuplicateHandle,
|
|
fname:CloseHandle, fname:CompareObjectHandles,
|
|
fname:GetHandleInformation, and fname:SetHandleInformation.
|
|
It owns a reference to the underlying memory resource represented by
|
|
its Vulkan memory object.
|
|
** ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX is a
|
|
global share handle that has only limited valid usage outside of Vulkan
|
|
and other compatible APIs.
|
|
It is not compatible with any native APIs.
|
|
It does not own own a reference to the underlying memory resource
|
|
represented its Vulkan memory object, and will therefore become invalid
|
|
when all Vulkan memory objects associated with it are destroyed.
|
|
** ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX is an NT
|
|
handle returned by sname:IDXGIResource1::fname:CreateSharedHandle
|
|
referring to a Direct3D 10 or 11 texture resource.
|
|
It owns a reference to the memory used by the Direct3D resource.
|
|
** ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX is a
|
|
global share handle returned by
|
|
sname:IDXGIResource::fname:GetSharedHandle referring to a Direct3D 10
|
|
or 11 texture resource.
|
|
It does not own own a reference to the underlying Direct3D resource,
|
|
and will therefore become invalid when all Vulkan memory objects and
|
|
Direct3D resources associated with it are destroyed.
|
|
** ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX is an NT handle
|
|
returned by sname:ID3D12Device::fname:CreateSharedHandle referring to a
|
|
Direct3D 12 heap resource.
|
|
It owns a reference to the resources used by the Direct3D heap.
|
|
** ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX is an NT
|
|
handle returned by sname:ID3D12Device::fname:CreateSharedHandle
|
|
referring to a Direct3D 12 committed resource.
|
|
It owns a reference to the memory used by the Direct3D resource.
|
|
--
|
|
|
|
If pname:handleType is 0, flink:vkGetPhysicalDeviceImageFormatProperties2KHR
|
|
will behave as if slink:VkPhysicalDeviceExternalImageFormatInfoKHX was not
|
|
present and slink:VkExternalImageFormatPropertiesKHX will be ignored.
|
|
|
|
If pname:handleType is not compatible with the pname:format, pname:type,
|
|
pname:tiling, pname:usage, and pname:flags specified in
|
|
slink:VkPhysicalDeviceImageFormatInfo2KHR, then
|
|
flink:vkGetPhysicalDeviceImageFormatProperties2KHR returns
|
|
ename:VK_ERROR_FORMAT_NOT_SUPPORTED.
|
|
|
|
include::../validity/structs/VkPhysicalDeviceExternalImageFormatInfoKHX.txt[]
|
|
|
|
// refBegin VkExternalImageFormatPropertiesKHX Structure specifying supported external handle properties
|
|
|
|
The sname:VkExternalImageFormatPropertiesKHX structure is defined as:
|
|
|
|
include::../api/structs/VkExternalImageFormatPropertiesKHX.txt[]
|
|
|
|
* pname:sType is the type of this structure.
|
|
* pname:pNext is `NULL` or a pointer to an extension-specific structure.
|
|
* pname:externalMemoryProperties is an instance of the
|
|
slink:VkExternalMemoryPropertiesKHX structure specifying various
|
|
capabilities of the external handle type when used with the specified
|
|
image creation parameters.
|
|
|
|
include::../validity/structs/VkExternalImageFormatPropertiesKHX.txt[]
|
|
|
|
// refBegin VkExternalMemoryPropertiesKHX Structure specifying external memory handle type capabilities
|
|
|
|
The sname:VkExternalMemoryPropertiesKHX structure is defined as:
|
|
|
|
include::../api/structs/VkExternalMemoryPropertiesKHX.txt[]
|
|
|
|
* pname:externalMemoryFeatures is a bitmask describing the features of
|
|
pname:handleType.
|
|
See elink:VkExternalMemoryFeatureFlagBitsKHX below for a description of
|
|
the possible bits.
|
|
* pname:exportFromImportedHandleTypes is a bitmask specifying handle types
|
|
that can be used to import objects from which pname:handleType can be
|
|
exported.
|
|
* pname:compatibleHandleTypes is a bitmask specifying handle types which
|
|
can be specified at the same time as pname:handleType when creating an
|
|
image compatible with external memory.
|
|
|
|
pname:compatibleHandleTypes must: include at least pname:handleType.
|
|
Inclusion of a handle type in pname:compatibleHandleTypes does not imply the
|
|
values returned in slink:VkImageFormatProperties2KHR will be the same when
|
|
slink:VkPhysicalDeviceExternalImageFormatInfoKHX::pname:handleType is set to
|
|
that type.
|
|
The application is responsible for querying the capabilities of all handle
|
|
types intended for concurrent use in a single image and intersecting them to
|
|
obtain the compatible set of capabilities.
|
|
|
|
include::../validity/structs/VkExternalMemoryPropertiesKHX.txt[]
|
|
|
|
// refBegin VkExternalMemoryFeatureFlagBitsKHX Bitmask specifying features of an external memory handle type
|
|
|
|
The features of an external memory handle type are returned in
|
|
slink:VkExternalMemoryPropertiesKHX::pname:externalMemoryFeatures.
|
|
Bits which may: be set include:
|
|
|
|
include::../api/enums/VkExternalMemoryFeatureFlagBitsKHX.txt[]
|
|
|
|
These bits have the following meanings:
|
|
|
|
* ename:VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX indicates that
|
|
images or buffers created with the specified parameters and handle type
|
|
must: use the mechanisms defined in the ename:VK_NV_dedicated_allocation
|
|
to create (or import) a dedicated allocation for the image or buffer.
|
|
|
|
* ename:VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX indicates handles of
|
|
this type can: be exported from Vulkan memory objects.
|
|
|
|
* ename:VK_INTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX indicates handles of
|
|
this type can: be imported as Vulkan memory objects.
|
|
|
|
Because their semantics in external APIs roughly align with that of an image
|
|
or buffer with a dedicated allocation in Vulkan, implementations are
|
|
required: to report ename:VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX
|
|
for the following external handle types:
|
|
|
|
* ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX
|
|
* ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX
|
|
* ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX
|
|
|
|
// refEnd VkExternalMemoryFeatureFlagBitsKHX
|
|
|
|
endif::VK_KHX_external_memory_capabilities[]
|
|
|
|
endif::VK_KHR_get_physical_device_properties2[]
|
|
|
|
|
|
[[features-supported-sample-counts]]
|
|
=== Supported Sample Counts
|
|
fname:vkGetPhysicalDeviceImageFormatProperties returns a bitmask of
|
|
elink:VkSampleCountFlagBits in pname:sampleCounts specifying the supported
|
|
sample counts for the image parameters.
|
|
|
|
pname:sampleCounts will be set to ename:VK_SAMPLE_COUNT_1_BIT if at least
|
|
one of the following conditions is true:
|
|
|
|
* pname:tiling is ename:VK_IMAGE_TILING_LINEAR
|
|
* pname:type is not ename:VK_IMAGE_TYPE_2D
|
|
* pname:flags contains ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
|
|
* Neither the ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag nor the
|
|
ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in
|
|
sname:VkFormatProperties::pname:optimalTilingFeatures returned by
|
|
flink:vkGetPhysicalDeviceFormatProperties is set
|
|
|
|
Otherwise, the bits set in pname:sampleCounts will be the sample counts
|
|
supported for the specified values of pname:usage and pname:format.
|
|
For each bit set in pname:usage, the supported sample counts relate to the
|
|
limits in sname:VkPhysicalDeviceLimits as follows:
|
|
|
|
* If pname:usage includes ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, a
|
|
superset of
|
|
sname:VkPhysicalDeviceLimits::pname:framebufferColorSampleCounts
|
|
* If pname:usage includes
|
|
ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and pname:format
|
|
includes a depth aspect, a superset of
|
|
sname:VkPhysicalDeviceLimits::pname:framebufferDepthSampleCounts
|
|
* If pname:usage includes
|
|
ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and pname:format
|
|
includes a stencil aspect, a superset of
|
|
sname:VkPhysicalDeviceLimits::pname:framebufferStencilSampleCounts
|
|
* If pname:usage includes ename:VK_IMAGE_USAGE_SAMPLED_BIT, and
|
|
pname:format includes a color aspect, a superset of
|
|
sname:VkPhysicalDeviceLimits::pname:sampledImageColorSampleCounts
|
|
* If pname:usage includes ename:VK_IMAGE_USAGE_SAMPLED_BIT, and
|
|
pname:format includes a depth aspect, a superset of
|
|
sname:VkPhysicalDeviceLimits::pname:sampledImageDepthSampleCounts
|
|
* If pname:usage includes ename:VK_IMAGE_USAGE_SAMPLED_BIT, and
|
|
pname:format is an integer format, a superset of
|
|
sname:VkPhysicalDeviceLimits::pname:sampledImageIntegerSampleCounts
|
|
* If pname:usage includes ename:VK_IMAGE_USAGE_STORAGE_BIT, a superset of
|
|
sname:VkPhysicalDeviceLimits::pname:storageImageSampleCounts
|
|
|
|
If multiple bits are set in pname:usage, pname:sampleCounts will be the
|
|
intersection of the per-usage values described above.
|
|
|
|
If none of the bits described above are set in pname:usage, then there is no
|
|
corresponding limit in sname:VkPhysicalDeviceLimits.
|
|
In this case, pname:sampleCounts must: include at least
|
|
ename:VK_SAMPLE_COUNT_1_BIT.
|
|
|
|
|
|
[[features-extentperimagetype]]
|
|
=== Allowed Extent Values Based On Image Type
|
|
|
|
Implementations may: support extent values larger than the
|
|
<<features-limits-minmax, required minimum/maximum values>> for certain
|
|
types of images subject to the constraints below.
|
|
|
|
[NOTE]
|
|
.Note
|
|
====
|
|
Implementations must: support images with dimensions up to the
|
|
<<features-limits-minmax, required minimum/maximum values>> for all types of
|
|
images.
|
|
It follows that the query for additional capabilities must: return extent
|
|
values that are at least as large as the required values.
|
|
====
|
|
|
|
For ename:VK_IMAGE_TYPE_1D:
|
|
|
|
* [eq]#pname:maxExtent.width {geq}
|
|
slink:VkPhysicalDeviceLimits.pname:maxImageDimension1D#
|
|
* [eq]#pname:maxExtent.height = 1#
|
|
* [eq]#pname:maxExtent.depth = 1#
|
|
|
|
For ename:VK_IMAGE_TYPE_2D when pname:flags does not contain
|
|
ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT:
|
|
|
|
* [eq]#pname:maxExtent.width {geq}
|
|
slink:VkPhysicalDeviceLimits.pname:maxImageDimension2D#
|
|
* [eq]#pname:maxExtent.height {geq}
|
|
slink:VkPhysicalDeviceLimits.pname:maxImageDimension2D#
|
|
* [eq]#pname:maxExtent.depth = 1#
|
|
|
|
For ename:VK_IMAGE_TYPE_2D when pname:flags contains
|
|
ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT:
|
|
|
|
* [eq]#pname:maxExtent.width {geq}
|
|
slink:VkPhysicalDeviceLimits.pname:maxImageDimensionCube#
|
|
* [eq]#pname:maxExtent.height {geq}
|
|
slink:VkPhysicalDeviceLimits.pname:maxImageDimensionCube#
|
|
* [eq]#pname:maxExtent.depth = 1#
|
|
|
|
For ename:VK_IMAGE_TYPE_3D:
|
|
|
|
* [eq]#pname:maxExtent.width {geq}
|
|
slink:VkPhysicalDeviceLimits.pname:maxImageDimension3D#
|
|
* [eq]#pname:maxExtent.height {geq}
|
|
slink:VkPhysicalDeviceLimits.pname:maxImageDimension3D#
|
|
* [eq]#pname:maxExtent.depth {geq}
|
|
slink:VkPhysicalDeviceLimits.pname:maxImageDimension3D#
|
|
|
|
|
|
ifdef::VK_KHX_external_memory_capabilities[]
|
|
== Additional Buffer Capabilities
|
|
|
|
In addition to the capabilities described in the previous sections
|
|
(<<features-limits,Limits>> and <<features-formats,Formats>>),
|
|
implementations may support additional buffer capabilities.
|
|
|
|
To query the external handle types supported by buffers, call:
|
|
|
|
include::../api/protos/vkGetPhysicalDeviceExternalBufferPropertiesKHX.txt[]
|
|
|
|
* pname:physicalDevice is the physical device from which to query the
|
|
buffer capabilities.
|
|
* pname:pExternalBufferInfo points to an instance of the
|
|
slink:VkPhysicalDeviceExternalBufferInfoKHX structure, describing the
|
|
parameters that would be consumed by flink:vkCreateBuffer.
|
|
* pname:pExternalBufferProperties points to an instance of the
|
|
slink:VkExternalBufferPropertiesKHX structure in which capabilities are
|
|
returned.
|
|
|
|
include::../validity/protos/vkGetPhysicalDeviceExternalBufferPropertiesKHX.txt[]
|
|
|
|
// refBegin VkPhysicalDeviceExternalBufferInfoKHX Structure specifying buffer creation parameters
|
|
|
|
The sname:VkPhysicalDeviceExternalBufferInfoKHX structure is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceExternalBufferInfoKHX.txt[]
|
|
|
|
* pname:sType is the type of this structure
|
|
* pname:pNext is NULL or a pointer to an extension-specific structure.
|
|
* pname:flags is a bitmask describing additional parameters of the buffer,
|
|
corresponding to slink:VkBufferCreateInfo::pname:flags.
|
|
* pname:usage is a bitmask describing the intended usage of the buffer,
|
|
corresponding to slink:VkBufferCreateInfo::pname:usage.
|
|
* pname:handleType is a bit indicating a memory handle type that will be
|
|
used with the memory associated with the buffer.
|
|
See elink:VkExternalMemoryHandleTypeFlagBitsKHX for details.
|
|
|
|
include::../validity/structs/VkPhysicalDeviceExternalBufferInfoKHX.txt[]
|
|
|
|
// refBegin VkExternalBufferPropertiesKHX Structure specifying supported external handle capabilities
|
|
|
|
The sname:VkExternalBufferPropertiesKHX structure is defined as:
|
|
|
|
include::../api/structs/VkExternalBufferPropertiesKHX.txt[]
|
|
|
|
* pname:sType is the type of this structure
|
|
* pname:pNext is NULL or a pointer to an extension-specific structure.
|
|
* pname:externalMemoryProperties is an instance of the
|
|
slink:VkExternalMemoryPropertiesKHX structure specifying various
|
|
capabilities of the external handle type when used with the specified
|
|
buffer creation parameters.
|
|
|
|
include::../validity/structs/VkExternalBufferPropertiesKHX.txt[]
|
|
|
|
endif::VK_KHX_external_memory_capabilities[]
|
|
|
|
ifdef::VK_KHX_external_semaphore_capabilities[]
|
|
== Optional Semaphore Capabilities
|
|
|
|
// refBegin vkGetPhysicalDeviceExternalSemaphorePropertiesKHX Function for querying external semaphore handle capabilities.
|
|
|
|
Semaphores may: support import and export of external semaphore handles.
|
|
To query the external handle types supported by semaphores, call:
|
|
|
|
include::../api/protos/vkGetPhysicalDeviceExternalSemaphorePropertiesKHX.txt[]
|
|
|
|
* pname:physicalDevice is the physical device from which to query the
|
|
semaphore capabilities.
|
|
* pname:pExternalSemaphoreInfo points to an instance of the
|
|
slink:VkPhysicalDeviceExternalSemaphoreInfoKHX structure, describing the
|
|
parameters that would be consumed by flink:vkCreateSemaphore.
|
|
* pname:pExternalSemaphoreProperties points to an instance of the
|
|
slink:VkExternalSemaphorePropertiesKHX structure in which capabilities
|
|
are returned.
|
|
|
|
include::../validity/protos/vkGetPhysicalDeviceExternalSemaphorePropertiesKHX.txt[]
|
|
|
|
// refBegin VkPhysicalDeviceExternalSemaphoreInfoKHX Structure specifying semaphore creation parameters.
|
|
|
|
The sname:VkPhysicalDeviceExternalSemaphoreInfoKHX structure is defined as:
|
|
|
|
include::../api/structs/VkPhysicalDeviceExternalSemaphoreInfoKHX.txt[]
|
|
|
|
* pname:sType is the type of this structure
|
|
* pname:pNext is NULL or a pointer to an extension-specific structure.
|
|
* pname:handleType is a bit indicating an external semaphore handle type
|
|
for which capabilities will be returned.
|
|
Bits which can be set include:
|
|
+
|
|
--
|
|
// refBegin VkExternalSemaphoreHandleTypeFlagBitsKHX - Bitmask of valid external semaphore handle types
|
|
include::../api/enums/VkExternalSemaphoreHandleTypeFlagBitsKHX.txt[]
|
|
|
|
** ename:VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX is a POSIX
|
|
file descriptor handle that has only limited valid usage outside of
|
|
Vulkan and other compatible APIs.
|
|
It must: be compatible with the POSIX system calls fname:dup,
|
|
fname:dup2, fname:close, and the non-standard system call fname:dup3.
|
|
Additionally, it must: be transportable over a socket using an
|
|
ename:SCM_RIGHTS control message.
|
|
It owns a reference to the underlying synchronization primitive
|
|
represented by its Vulkan semaphore object.
|
|
** ename:VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_WIN32_BIT_KHX is an NT handle
|
|
that has only limited valid usage outside of Vulkan and other
|
|
compatible APIs.
|
|
It must: be compatible with the functions fname:DuplicateHandle,
|
|
fname:CloseHandle, fname:CompareObjectHandles,
|
|
fname:GetHandleInformation, and fname:SetHandleInformation.
|
|
It owns a reference to the underlying synchronization primitive
|
|
represented by its Vulkan semaphore object.
|
|
** ename:VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX is a
|
|
global share handle that has only limited valid usage outside of Vulkan
|
|
and other compatible APIs.
|
|
It is not compatible with any native APIs.
|
|
It does not own own a reference to the underlying synchronization
|
|
primitive represented its Vulkan semaphore object, and will therefore
|
|
become invalid when all Vulkan semaphore objects associated with it are
|
|
destroyed.
|
|
** ename:VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX is an NT
|
|
handle returned by sname:ID3D12Device::fname:CreateSharedHandle
|
|
referring to a Direct3D 12 fence.
|
|
It owns a reference to the underlying synchronization primitive
|
|
associated with the Direct3D fence.
|
|
** ename:VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX is a POSIX
|
|
file descriptor handle to a Linux or Android Fence object.
|
|
It can be used with any native API accepting a valid fence object file
|
|
descriptor as input.
|
|
It owns a reference to the underlying synchronization primitive
|
|
associated with the file descriptor.
|
|
Implementations which support importing this handle type must: accept
|
|
any type of fence FD supported by the native system they are running
|
|
on.
|
|
--
|
|
|
|
[NOTE]
|
|
.Note
|
|
====
|
|
Applications must: not perform operations on handles of type
|
|
ename:VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX that are specific
|
|
to only one of Linux Fences or Android Fences.
|
|
Implementations are free to return either type of file descriptor using this
|
|
handle type.
|
|
While most userspace functions accepting a fence FD are compatible with
|
|
either type of fence, attempting to use the file descriptors directly with
|
|
system calls compatible with only one of the fence types may: result in
|
|
undefined behavior.
|
|
====
|
|
|
|
include::../validity/structs/VkPhysicalDeviceExternalSemaphoreInfoKHX.txt[]
|
|
|
|
// refBegin VkExternalSemaphorePropertiesKHX Structure describing supported external semaphore handle features
|
|
|
|
The sname:VkExternalSemaphorePropertiesKHX structure is defined as:
|
|
|
|
include::../api/structs/VkExternalSemaphorePropertiesKHX.txt[]
|
|
|
|
* pname:exportFromImportedHandleTypes is a bitmask specifying handle types
|
|
that can be used to import objects from which pname:handleType can be
|
|
exported.
|
|
* pname:compatibleHandleTypes is a bitmask specifying handle types which
|
|
can be specified at the same time as pname:handleType when creating a
|
|
semaphore.
|
|
* pname:externalSemaphoreFeatures is a bitmask describing the features of
|
|
pname:handleType.
|
|
See elink:VkExternalSemaphoreFeatureFlagBitsKHX below for a description
|
|
of the possible bits.
|
|
|
|
If pname:handleType is not supported by the implementation, then
|
|
slink:VkExternalSemaphorePropertiesKHX::pname:externalSemaphoreFeatures will
|
|
be set to zero.
|
|
|
|
include::../validity/structs/VkExternalSemaphorePropertiesKHX.txt[]
|
|
|
|
// refBegin VkExternalSemaphoreFeatureFlagBitsKHX Bitfield describing features of an external semaphore handle type
|
|
|
|
Features which a semaphore external handle type may support include:
|
|
|
|
include::../api/enums/VkExternalSemaphoreFeatureFlagBitsKHX.txt[]
|
|
|
|
* ename:VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX indicates handles
|
|
of this type can: be exported from Vulkan semaphore objects.
|
|
|
|
* ename:VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX indicates handles
|
|
of this type can: be imported as Vulkan semaphore objects.
|
|
|
|
endif::VK_KHX_external_semaphore_capabilities[]
|