mirror of
https://github.com/status-im/Vulkan-Docs.git
synced 2025-01-12 15:04:10 +00:00
85184f305a
* Bump API patch number and header version number to 25 for this update.
* Structurally change the specification so that multiple extensions are
included in the +1.0+ git branch, and specifications will include or not
include those extensions at build time based on options passed to the
Makefile. See +doc/specs/vulkan/README.html+ and the ``Layers and
Extensions'' section of the ``Vulkan Documentation and Extensions''
document for more information on this change.
* Register and publish new extensions in the single-branch form:
** +VK_NV_external_memory_capabilities+
** +VK_NV_external_memory+
** +VK_NV_external_memory_win32+
** +VK_NV_win32_keyed_mutex+
Github Issues:
* Clarify description of GetInstanceProcAddr and GetDeviceProcAddr (public
issue 212).
* Add SPIR-V <<textures-operation-validation, instruction validation>> for
single-sampled images (public issue 316).
* Fix spelling of ``tesselation'' in a few places and note it as an
exception to the American spelling rules convention (public issue
327).
* Fix Makefile to create output directory for ``styleguide''
target (public issue 329).
* Fix numerous minor issues with incorrectly tags on enumerant names and
table titles (public issue 330).
* Generate specversion.txt date in UTC time and RFC 2822 format
(public issue 335).
* Convert link to the SPIR-V Specification for
flink:VkShaderModuleCreateInfo into an internal link to the normative
reference (public issue 336).
* Add ename:VK_ERROR_OUT_OF_MEMORY error code to
flink:vkCreateDebugReportCallbackEXT (public issue 337).
Internal Issues:
* Update style guide regarding use of code:NULL and dname:VK_NULL_HANDLE
(internal issue 393).
* Change the definition of latexmath:[$q$] in the
<<textures-image-level-selection,texture image level selection>> section
to be the index of the maximum defined level for the view, not the
number of levels in the view (internal issue 406).
* Allow developers to override dname:VK_DEFINE_NON_DISPATCHABLE_HANDLE
with their own binary-compatible definition (internal issue 439).
* Fix +vk_platform.h+ conditional logic causing compile failure with some
Android compilers (internal issue 441).
* Implement the single-branch model as described above (internal issue
461).
Other Issues:
579 lines
32 KiB
Plaintext
579 lines
32 KiB
Plaintext
// Copyright (c) 2014-2016 Khronos Group. This work is licensed under a
|
|
// Creative Commons Attribution 4.0 International License; see
|
|
// http://creativecommons.org/licenses/by/4.0/
|
|
|
|
VkPhysicalDeviceFeatures(3)
|
|
===========================
|
|
|
|
Name
|
|
----
|
|
VkPhysicalDeviceFeatures - Structure describing the fine-grained features that can be supported by an implementation.
|
|
|
|
C Specification
|
|
---------------
|
|
|
|
// 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[]
|
|
|
|
|
|
Members
|
|
-------
|
|
|
|
The members of the sname:VkPhysicalDeviceFeatures structure describe the
|
|
following features:
|
|
|
|
|
|
Description
|
|
-----------
|
|
|
|
* [[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 mustnot: 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 (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 mustnot: modify any other memory.
|
|
** Out-of-bounds atomics may: modify values within the memory range(s) bound
|
|
to the buffer, but mustnot: 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 (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 behaviour 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 behaviour.
|
|
* [[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 the ETC2 and EAC
|
|
compressed texture formats are supported. If this feature is not
|
|
enabled, the following formats mustnot: be used to create images:
|
|
+
|
|
--
|
|
* 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 is used to
|
|
check for the supported properties of individual formats.
|
|
+
|
|
* [[features-features-textureCompressionASTC_LDR]]
|
|
pname:textureCompressionASTC_LDR indicates whether the ASTC LDR
|
|
compressed texture formats are supported. If this feature is not
|
|
enabled, the following formats mustnot: be used to create images:
|
|
+
|
|
--
|
|
* 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 is used to
|
|
check for the supported properties of individual formats.
|
|
+
|
|
* [[features-features-textureCompressionBC]] pname:textureCompressionBC
|
|
indicates whether the BC compressed texture formats are supported. If
|
|
this feature is not enabled, the following formats mustnot: be used to
|
|
create images:
|
|
+
|
|
--
|
|
* 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 is used to
|
|
check for the 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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
|
|
mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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 mustnot: 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.
|
|
|
|
include::../validity/structs/VkPhysicalDeviceFeatures.txt[]
|
|
|
|
|
|
See Also
|
|
--------
|
|
|
|
basetype:VkBool32, slink:VkDeviceCreateInfo, flink:vkGetPhysicalDeviceFeatures
|
|
|
|
|
|
Document Notes
|
|
--------------
|
|
|
|
For more information, see the Vulkan Specification at URL
|
|
|
|
https://www.khronos.org/registry/vulkan/specs/1.0/xhtml/vkspec.html#VkPhysicalDeviceFeatures
|
|
|
|
This page is extracted from the Vulkan Specification.
|
|
Fixes and changes should be made to the Specification,not directly.
|
|
|
|
include::footer.txt[]
|
|
|