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.
To query supported features, call:
void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
physicalDevice
is the physical device from which to query the
supported features.
pFeatures
is a pointer to a VkPhysicalDeviceFeatures
structure in which the physical device features are returned.
For each feature, a value of VK_TRUE
indicates that the feature is
supported on this physical device, and VK_FALSE
indicates that the
feature is not supported.
Fine-grained features used by a logical device must be enabled at
VkDevice
creation time.
If a feature is enabled that the physical device does not support,
VkDevice
creation will fail.
If an application uses a feature without enabling it at 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
VkPhysicalDeviceFeatures
structure via the pEnabledFeatures
member of the VkDeviceCreateInfo
structure that is passed into the
vkCreateDevice
call.
If a member of pEnabledFeatures
is set to VK_TRUE
or
VK_FALSE
, then the device will be created with the indicated feature
enabled or disabled, respectively.
If an application wishes to enable all features supported by a device, it
can simply pass in the VkPhysicalDeviceFeatures
structure that was
previously returned by vkGetPhysicalDeviceFeatures
.
To disable an individual feature, the application can set the desired
member to VK_FALSE
in the same structure.
Setting pEnabledFeatures
to NULL
is equivalent to setting all
members of the structure to VK_FALSE
.
![]() | Note |
---|---|
Some features, such as |
The VkPhysicalDeviceFeatures
structure is defined as:
typedef struct VkPhysicalDeviceFeatures { VkBool32 robustBufferAccess; VkBool32 fullDrawIndexUint32; VkBool32 imageCubeArray; VkBool32 independentBlend; VkBool32 geometryShader; VkBool32 tessellationShader; VkBool32 sampleRateShading; VkBool32 dualSrcBlend; VkBool32 logicOp; VkBool32 multiDrawIndirect; VkBool32 drawIndirectFirstInstance; VkBool32 depthClamp; VkBool32 depthBiasClamp; VkBool32 fillModeNonSolid; VkBool32 depthBounds; VkBool32 wideLines; VkBool32 largePoints; VkBool32 alphaToOne; VkBool32 multiViewport; VkBool32 samplerAnisotropy; VkBool32 textureCompressionETC2; VkBool32 textureCompressionASTC_LDR; VkBool32 textureCompressionBC; VkBool32 occlusionQueryPrecise; VkBool32 pipelineStatisticsQuery; VkBool32 vertexPipelineStoresAndAtomics; VkBool32 fragmentStoresAndAtomics; VkBool32 shaderTessellationAndGeometryPointSize; VkBool32 shaderImageGatherExtended; VkBool32 shaderStorageImageExtendedFormats; VkBool32 shaderStorageImageMultisample; VkBool32 shaderStorageImageReadWithoutFormat; VkBool32 shaderStorageImageWriteWithoutFormat; VkBool32 shaderUniformBufferArrayDynamicIndexing; VkBool32 shaderSampledImageArrayDynamicIndexing; VkBool32 shaderStorageBufferArrayDynamicIndexing; VkBool32 shaderStorageImageArrayDynamicIndexing; VkBool32 shaderClipDistance; VkBool32 shaderCullDistance; VkBool32 shaderFloat64; VkBool32 shaderInt64; VkBool32 shaderInt16; VkBool32 shaderResourceResidency; VkBool32 shaderResourceMinLod; VkBool32 sparseBinding; VkBool32 sparseResidencyBuffer; VkBool32 sparseResidencyImage2D; VkBool32 sparseResidencyImage3D; VkBool32 sparseResidency2Samples; VkBool32 sparseResidency4Samples; VkBool32 sparseResidency8Samples; VkBool32 sparseResidency16Samples; VkBool32 sparseResidencyAliased; VkBool32 variableMultisampleRate; VkBool32 inheritedQueries; } VkPhysicalDeviceFeatures;
The members of the VkPhysicalDeviceFeatures
structure describe the
following features:
robustBufferAccess
indicates that accesses to buffers are bounds-checked against the range
of the buffer descriptor (as determined by
VkDescriptorBufferInfo
::range
,
VkBufferViewCreateInfo
::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:
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 OpImageTexelPointer
and the object
pointed to is not wholly contained within the bound range.
![]() | Note |
---|---|
If a SPIR-V |
Out-of-bounds buffer loads will return any of the following values:
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:
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:
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.
fullDrawIndexUint32
indicates the full 32-bit range of indices is supported for indexed draw
calls when using a VkIndexType
of VK_INDEX_TYPE_UINT32
.
maxDrawIndexedIndexValue
is the maximum index value that may be
used (aside from the primitive restart index, which is always 232-1
when the VkIndexType
is VK_INDEX_TYPE_UINT32
).
If this feature is supported, maxDrawIndexedIndexValue
must be
232-1; otherwise it must be no smaller than 224-1.
See
maxDrawIndexedIndexValue.
imageCubeArray
indicates
whether image views with a VkImageViewType
of
VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
can be created, and that the
corresponding SampledCubeArray
and ImageCubeArray
SPIR-V
capabilities can be used in shader code.
independentBlend
indicates
whether the VkPipelineColorBlendAttachmentState
settings are
controlled independently per-attachment.
If this feature is not enabled, the
VkPipelineColorBlendAttachmentState
settings for all color
attachments must be identical.
Otherwise, a different VkPipelineColorBlendAttachmentState
can be
provided for each bound color attachment.
geometryShader
indicates
whether geometry shaders are supported.
If this feature is not enabled, the VK_SHADER_STAGE_GEOMETRY_BIT
and VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
enum values must not be
used.
This also indicates whether shader modules can declare the
Geometry
capability.
tessellationShader
indicates whether tessellation control and evaluation shaders are
supported.
If this feature is not enabled, the
VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT
,
VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT
,
VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
,
VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
, and
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
enum
values must not be used.
This also indicates whether shader modules can declare the
Tessellation
capability.
sampleRateShading
indicates whether per-sample shading and multisample interpolation are
supported.
If this feature is not enabled, the sampleShadingEnable
member of
the VkPipelineMultisampleStateCreateInfo
structure must be set to
VK_FALSE
and the minSampleShading
member is ignored.
This also indicates whether shader modules can declare the
SampleRateShading
capability.
dualSrcBlend
indicates whether
blend operations which take two sources are supported.
If this feature is not enabled, the VK_BLEND_FACTOR_SRC1_COLOR
,
VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR
,
VK_BLEND_FACTOR_SRC1_ALPHA
, and
VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
enum values must not be used
as source or destination blending factors.
See Section 26.1.2, “Dual-Source Blending”.
logicOp
indicates whether logic
operations are supported.
If this feature is not enabled, the logicOpEnable
member of the
VkPipelineColorBlendStateCreateInfo
structure must be set to
VK_FALSE
, and the logicOp
member is ignored.
multiDrawIndirect
indicates whether multiple draw indirect is supported.
If this feature is not enabled, the drawCount
parameter to the
vkCmdDrawIndirect
and vkCmdDrawIndexedIndirect
commands
must be 0 or 1.
The maxDrawIndirectCount
member of the
VkPhysicalDeviceLimits
structure must also be 1 if this feature
is not supported.
See maxDrawIndirectCount.
drawIndirectFirstInstance
indicates whether indirect draw calls
support the firstInstance
parameter.
If this feature is not enabled, the firstInstance
member of all
VkDrawIndirectCommand
and VkDrawIndexedIndirectCommand
structures that are provided to the vkCmdDrawIndirect
and
vkCmdDrawIndexedIndirect
commands must be 0.
depthClamp
indicates whether
depth clamping is supported.
If this feature is not enabled, the depthClampEnable
member of the
VkPipelineRasterizationStateCreateInfo
structure must be set to
VK_FALSE
.
Otherwise, setting depthClampEnable
to VK_TRUE
will enable
depth clamping.
depthBiasClamp
indicates
whether depth bias clamping is supported.
If this feature is not enabled, the depthBiasClamp
member of the
VkPipelineRasterizationStateCreateInfo
structure must be set to
0.0 unless the VK_DYNAMIC_STATE_DEPTH_BIAS
dynamic state is
enabled, and the depthBiasClamp
parameter to
vkCmdSetDepthBias
must be set to 0.0.
fillModeNonSolid
indicates
whether point and wireframe fill modes are supported.
If this feature is not enabled, the VK_POLYGON_MODE_POINT
and
VK_POLYGON_MODE_LINE
enum values must not be used.
depthBounds
indicates whether
depth bounds tests are supported.
If this feature is not enabled, the depthBoundsTestEnable
member
of the VkPipelineDepthStencilStateCreateInfo
structure must be
set to VK_FALSE
.
When depthBoundsTestEnable
is set to VK_FALSE
, the
minDepthBounds
and maxDepthBounds
members of the
VkPipelineDepthStencilStateCreateInfo
structure are ignored.
wideLines
indicates whether lines
with width other than 1.0 are supported.
If this feature is not enabled, the lineWidth
member of the
VkPipelineRasterizationStateCreateInfo
structure must be set to
1.0 unless the VK_DYNAMIC_STATE_LINE_WIDTH
dynamic state is
enabled, and the lineWidth
parameter to vkCmdSetLineWidth
must be set to 1.0.
When this feature is supported, the range and granularity of supported
line widths are indicated by the lineWidthRange
and
lineWidthGranularity
members of the VkPhysicalDeviceLimits
structure, respectively.
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
pointSizeRange
and pointSizeGranularity
members of the
VkPhysicalDeviceLimits
structure, respectively.
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 alphaToOneEnable
member
of the VkPipelineMultisampleStateCreateInfo
structure must be set
to VK_FALSE
.
Otherwise setting alphaToOneEnable
to VK_TRUE
will enable
alpha-to-one behavior.
multiViewport
indicates
whether more than one viewport is supported.
If this feature is not enabled, the viewportCount
and
scissorCount
members of the
VkPipelineViewportStateCreateInfo
structure must be set to 1.
Similarly, the viewportCount
parameter to the
vkCmdSetViewport
command and the scissorCount
parameter to
the vkCmdSetScissor
command must be 1, and the
firstViewport
parameter to the vkCmdSetViewport
command and
the firstScissor
parameter to the vkCmdSetScissor
command
must be 0.
samplerAnisotropy
indicates whether anisotropic filtering is supported.
If this feature is not enabled, the maxAnisotropy
member of the
VkSamplerCreateInfo
structure must be 1.0.
textureCompressionETC2
indicates whether the ETC2 and EAC
compressed texture formats are supported.
If this feature is not enabled, the following formats must not be used
to create images:
VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
VK_FORMAT_EAC_R11_UNORM_BLOCK
VK_FORMAT_EAC_R11_SNORM_BLOCK
VK_FORMAT_EAC_R11G11_UNORM_BLOCK
VK_FORMAT_EAC_R11G11_SNORM_BLOCK
vkGetPhysicalDeviceFormatProperties
is used to check for the supported
properties of individual formats.
textureCompressionASTC_LDR
indicates whether the ASTC LDR
compressed texture formats are supported.
If this feature is not enabled, the following formats must not be used
to create images:
VK_FORMAT_ASTC_4x4_UNORM_BLOCK
VK_FORMAT_ASTC_4x4_SRGB_BLOCK
VK_FORMAT_ASTC_5x4_UNORM_BLOCK
VK_FORMAT_ASTC_5x4_SRGB_BLOCK
VK_FORMAT_ASTC_5x5_UNORM_BLOCK
VK_FORMAT_ASTC_5x5_SRGB_BLOCK
VK_FORMAT_ASTC_6x5_UNORM_BLOCK
VK_FORMAT_ASTC_6x5_SRGB_BLOCK
VK_FORMAT_ASTC_6x6_UNORM_BLOCK
VK_FORMAT_ASTC_6x6_SRGB_BLOCK
VK_FORMAT_ASTC_8x5_UNORM_BLOCK
VK_FORMAT_ASTC_8x5_SRGB_BLOCK
VK_FORMAT_ASTC_8x6_UNORM_BLOCK
VK_FORMAT_ASTC_8x6_SRGB_BLOCK
VK_FORMAT_ASTC_8x8_UNORM_BLOCK
VK_FORMAT_ASTC_8x8_SRGB_BLOCK
VK_FORMAT_ASTC_10x5_UNORM_BLOCK
VK_FORMAT_ASTC_10x5_SRGB_BLOCK
VK_FORMAT_ASTC_10x6_UNORM_BLOCK
VK_FORMAT_ASTC_10x6_SRGB_BLOCK
VK_FORMAT_ASTC_10x8_UNORM_BLOCK
VK_FORMAT_ASTC_10x8_SRGB_BLOCK
VK_FORMAT_ASTC_10x10_UNORM_BLOCK
VK_FORMAT_ASTC_10x10_SRGB_BLOCK
VK_FORMAT_ASTC_12x10_UNORM_BLOCK
VK_FORMAT_ASTC_12x10_SRGB_BLOCK
VK_FORMAT_ASTC_12x12_UNORM_BLOCK
VK_FORMAT_ASTC_12x12_SRGB_BLOCK
vkGetPhysicalDeviceFormatProperties
is used to check for the supported
properties of individual formats.
textureCompressionBC
indicates whether the BC compressed texture formats are supported.
If this feature is not enabled, the following formats must not be used
to create images:
VK_FORMAT_BC1_RGB_UNORM_BLOCK
VK_FORMAT_BC1_RGB_SRGB_BLOCK
VK_FORMAT_BC1_RGBA_UNORM_BLOCK
VK_FORMAT_BC1_RGBA_SRGB_BLOCK
VK_FORMAT_BC2_UNORM_BLOCK
VK_FORMAT_BC2_SRGB_BLOCK
VK_FORMAT_BC3_UNORM_BLOCK
VK_FORMAT_BC3_SRGB_BLOCK
VK_FORMAT_BC4_UNORM_BLOCK
VK_FORMAT_BC4_SNORM_BLOCK
VK_FORMAT_BC5_UNORM_BLOCK
VK_FORMAT_BC5_SNORM_BLOCK
VK_FORMAT_BC6H_UFLOAT_BLOCK
VK_FORMAT_BC6H_SFLOAT_BLOCK
VK_FORMAT_BC7_UNORM_BLOCK
VK_FORMAT_BC7_SRGB_BLOCK
vkGetPhysicalDeviceFormatProperties
is used to check for the supported
properties of individual formats.
occlusionQueryPrecise
indicates whether occlusion queries returning actual sample counts are
supported.
Occlusion queries are created in a VkQueryPool
by specifying the
queryType
of VK_QUERY_TYPE_OCCLUSION
in the
VkQueryPoolCreateInfo
structure which is passed to
vkCreateQueryPool
.
If this feature is enabled, queries of this type can enable
VK_QUERY_CONTROL_PRECISE_BIT
in the flags
parameter to
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 VK_QUERY_CONTROL_PRECISE_BIT
is
set, occlusion queries will report the actual number of samples passed.
pipelineStatisticsQuery
indicates whether the pipeline statistics
queries are supported.
If this feature is not enabled, queries of type
VK_QUERY_TYPE_PIPELINE_STATISTICS
cannot be created, and none of
the VkQueryPipelineStatisticFlagBits
bits can be set in the
pipelineStatistics
member of the VkQueryPoolCreateInfo
structure.
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 NonWriteable
decoration (or the
readonly
memory qualifier in GLSL).
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 NonWriteable
decoration
(or the readonly
memory qualifier in GLSL).
shaderTessellationAndGeometryPointSize
indicates whether the
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
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
TessellationPointSize
capability for tessellation control and
evaluation shaders, or if the shader modules can declare the
GeometryPointSize
capability for geometry shaders.
An implementation supporting this feature must also support one or both
of the tessellationShader
or geometryShader
features.
shaderImageGatherExtended
indicates whether the extended set of
image gather instructions are available in shader code.
If this feature is not enabled, the OpImage
*Gather
instructions do not support the Offset
and ConstOffsets
operands.
This also indicates whether shader modules can declare the
ImageGatherExtended
capability.
shaderStorageImageExtendedFormats
indicates whether the extended
storage image formats are available in shader code.
If this feature is not enabled, the formats requiring the
StorageImageExtendedFormats
capability are not supported for
storage images.
This also indicates whether shader modules can declare the
StorageImageExtendedFormats
capability.
shaderStorageImageMultisample
indicates whether multisampled
storage images are supported.
If this feature is not enabled, images that are created with a
usage
that includes VK_IMAGE_USAGE_STORAGE_BIT
must be
created with samples
equal to VK_SAMPLE_COUNT_1_BIT
.
This also indicates whether shader modules can declare the
StorageImageMultisample
capability.
shaderStorageImageReadWithoutFormat
indicates whether storage
images require a format qualifier to be specified when reading from
storage images.
If this feature is not enabled, the OpImageRead
instruction must
not have an OpTypeImage
of Unknown
.
This also indicates whether shader modules can declare the
StorageImageReadWithoutFormat
capability.
shaderStorageImageWriteWithoutFormat
indicates whether storage
images require a format qualifier to be specified when writing to
storage images.
If this feature is not enabled, the OpImageWrite
instruction must
not have an OpTypeImage
of Unknown
.
This also indicates whether shader modules can declare the
StorageImageWriteWithoutFormat
capability.
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
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
or
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
UniformBufferArrayDynamicIndexing
capability.
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
VK_DESCRIPTOR_TYPE_SAMPLER
,
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
, or
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
SampledImageArrayDynamicIndexing
capability.
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
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
or
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
StorageBufferArrayDynamicIndexing
capability.
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
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
StorageImageArrayDynamicIndexing
capability.
shaderClipDistance
indicates whether clip distances are supported in shader code.
If this feature is not enabled, any members decorated with the
ClipDistance
built-in decoration must not be read from or written
to in shader modules.
This also indicates whether shader modules can declare the
ClipDistance
capability.
shaderCullDistance
indicates whether cull distances are supported in shader code.
If this feature is not enabled, any members decorated with the
CullDistance
built-in decoration must not be read from or written
to in shader modules.
This also indicates whether shader modules can declare the
CullDistance
capability.
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 Float64
capability.
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 Int64
capability.
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 Int16
capability.
shaderResourceResidency
indicates whether image operations that
return resource residency information are supported in shader code.
If this feature is not enabled, the OpImageSparse
* instructions
must not be used in shader code.
This also indicates whether shader modules can declare the
SparseResidency
capability.
The feature requires at least one of the sparseResidency*
features
to be supported.
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 MinLod
image operand must not
be used in shader code.
This also indicates whether shader modules can declare the MinLod
capability.
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 vkBindBufferMemory
and
vkBindImageMemory
commands.
In this case, buffers and images must not be created with
VK_BUFFER_CREATE_SPARSE_BINDING_BIT
and
VK_IMAGE_CREATE_SPARSE_BINDING_BIT
set in the flags
member
of the VkBufferCreateInfo
and VkImageCreateInfo
structures,
respectively.
Otherwise resource memory can be managed as described in
Sparse Resource Features.
sparseResidencyBuffer
indicates whether the device can access partially resident buffers.
If this feature is not enabled, buffers must not be created with
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT
set in the flags
member of the VkBufferCreateInfo
structure.
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 imageType
of
VK_IMAGE_TYPE_2D
and samples
set to
VK_SAMPLE_COUNT_1_BIT
must not be created with
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in the flags
member
of the VkImageCreateInfo
structure.
sparseResidencyImage3D
indicates whether the device can access
partially resident 3D images.
If this feature is not enabled, images with an imageType
of
VK_IMAGE_TYPE_3D
must not be created with
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in the flags
member
of the VkImageCreateInfo
structure.
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 imageType
of
VK_IMAGE_TYPE_2D
and samples
set to
VK_SAMPLE_COUNT_2_BIT
must not be created with
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in the flags
member
of the VkImageCreateInfo
structure.
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 imageType
of
VK_IMAGE_TYPE_2D
and samples
set to
VK_SAMPLE_COUNT_4_BIT
must not be created with
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in the flags
member
of the VkImageCreateInfo
structure.
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 imageType
of
VK_IMAGE_TYPE_2D
and samples
set to
VK_SAMPLE_COUNT_8_BIT
must not be created with
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in the flags
member
of the VkImageCreateInfo
structure.
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 imageType
of
VK_IMAGE_TYPE_2D
and samples
set to
VK_SAMPLE_COUNT_16_BIT
must not be created with
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in the flags
member
of the VkImageCreateInfo
structure.
sparseResidencyAliased
indicates whether the physical device can
correctly access data aliased into multiple locations.
If this feature is not enabled, the
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT
and
VK_IMAGE_CREATE_SPARSE_ALIASED_BIT
enum values must not be used
in flags
members of the VkBufferCreateInfo
and
VkImageCreateInfo
structures, respectively.
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
VkPipelineMultisampleStateCreateInfo
::rasterizationSamples
.
If set to VK_TRUE
, the implementation supports variable
multisample rates in a subpass with no attachments.
If set to 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.
inheritedQueries
indicates
whether a secondary command buffer may be executed while a query is
active.