// Copyright 2015-2023 The Khronos Group Inc. // // SPDX-License-Identifier: CC-BY-4.0 // This text fragment is used many times in the Features chapter. ifdef::hidden[] // tag::features[] If the sname:{refpage} structure is included in the pname:pNext chain of the slink:VkPhysicalDeviceFeatures2 structure passed to flink:vkGetPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. sname:{refpage} can: also be used in the pname:pNext chain of slink:VkDeviceCreateInfo to selectively enable these features. // end::features[] endif::hidden[] [[features]] = Features _Features_ describe functionality which is not supported on all implementations. Features are properties of the physical device. Features are optional:, and must: be explicitly enabled before use. Support for features is reported and enabled on a per-feature basis. ifdef::VK_VERSION_1_1,VK_KHR_get_physical_device_properties2[] [NOTE] .Note ==== Features are reported via the basic slink:VkPhysicalDeviceFeatures structure, as well as the extensible structure sname:VkPhysicalDeviceFeatures2, which was added in the `apiext:VK_KHR_get_physical_device_properties2` extension and included in Vulkan 1.1. When new features are added in future Vulkan versions or extensions, each extension should: introduce one new feature structure, if needed. This structure can: be added to the pname:pNext chain of the sname:VkPhysicalDeviceFeatures2 structure. ==== endif::VK_VERSION_1_1,VK_KHR_get_physical_device_properties2[] For convenience, new core versions of Vulkan may: introduce new unified feature structures for features promoted from extensions. At the same time, the extension's original feature structure (if any) is also promoted to the core API, and is an alias of the extension's structure. This results in multiple names for the same feature: in the original extension's feature structure and the promoted structure alias, in the unified feature structure. When a feature was implicitly supported and enabled in the extension, but an explicit name was added during promotion, then the extension itself acts as an alias for the feature as listed in the table below. All aliases of the same feature in the core API must: be reported consistently: either all must: be reported as supported, or none of them. When a promoted extension is available, any corresponding feature aliases must: be supported. [[features-extension-aliases]] .Extension Feature Aliases // Jon 1.3 TBD - add any appropriate extensions promoted to 1.3 [width="100%",options="header"] |==== | Extension | Feature(s) ifdef::VK_VERSION_1_2[] ifdef::VK_KHR_shader_draw_parameters[] | `apiext:VK_KHR_shader_draw_parameters` | <> endif::VK_KHR_shader_draw_parameters[] ifdef::VK_KHR_draw_indirect_count[] | `apiext:VK_KHR_draw_indirect_count` | <> endif::VK_KHR_draw_indirect_count[] ifdef::VK_KHR_sampler_mirror_clamp_to_edge[] | `apiext:VK_KHR_sampler_mirror_clamp_to_edge` | <> endif::VK_KHR_sampler_mirror_clamp_to_edge[] ifdef::VK_EXT_descriptor_indexing[] | `apiext:VK_EXT_descriptor_indexing` | <> endif::VK_EXT_descriptor_indexing[] ifdef::VK_EXT_sampler_filter_minmax[] | `apiext:VK_EXT_sampler_filter_minmax` | <> endif::VK_EXT_sampler_filter_minmax[] ifdef::VK_EXT_shader_viewport_index_layer[] | `apiext:VK_EXT_shader_viewport_index_layer` | <>, <> endif::VK_EXT_shader_viewport_index_layer[] endif::VK_VERSION_1_2[] |==== [open,refpage='vkGetPhysicalDeviceFeatures',desc='Reports capabilities of a physical device',type='protos'] -- To query supported features, call: include::{generated}/api/protos/vkGetPhysicalDeviceFeatures.adoc[] * 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 specifies that the feature is supported on this physical device, and ename:VK_FALSE specifies that the feature is not supported. include::{generated}/validity/protos/vkGetPhysicalDeviceFeatures.adoc[] -- 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 and return ename:VK_ERROR_FEATURE_NOT_PRESENT. The fine-grained features are enabled by passing a pointer to the sname:VkPhysicalDeviceFeatures structure via the pname:pEnabledFeatures member of the slink: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_VERSION_1_1,VK_KHR_get_physical_device_properties2[] Features can: also be enabled by using the slink:VkPhysicalDeviceFeatures2 structure. endif::VK_VERSION_1_1,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_VERSION_1_1,VK_KHR_get_physical_device_properties2[] and not including a slink:VkPhysicalDeviceFeatures2 in the pname:pNext chain of slink:VkDeviceCreateInfo endif::VK_VERSION_1_1,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 runtime performance cost. Application writers should: carefully consider the implications of enabling all supported features. ==== ifdef::VK_VERSION_1_1,VK_KHR_get_physical_device_properties2[] [open,refpage='vkGetPhysicalDeviceFeatures2',desc='Reports capabilities of a physical device',type='protos'] -- To query supported features defined by the core or extensions, call: ifdef::VK_VERSION_1_1[] include::{generated}/api/protos/vkGetPhysicalDeviceFeatures2.adoc[] endif::VK_VERSION_1_1[] ifdef::VK_VERSION_1_1+VK_KHR_get_physical_device_properties2[or the equivalent command] ifdef::VK_KHR_get_physical_device_properties2[] include::{generated}/api/protos/vkGetPhysicalDeviceFeatures2KHR.adoc[] endif::VK_KHR_get_physical_device_properties2[] * pname:physicalDevice is the physical device from which to query the supported features. * pname:pFeatures is a pointer to a slink:VkPhysicalDeviceFeatures2 structure in which the physical device features are returned. Each structure in pname:pFeatures and its pname:pNext chain contains members corresponding to fine-grained features. fname:vkGetPhysicalDeviceFeatures2 writes each member to a boolean value indicating whether that feature is supported. include::{generated}/validity/protos/vkGetPhysicalDeviceFeatures2.adoc[] -- [open,refpage='VkPhysicalDeviceFeatures2',desc='Structure describing the fine-grained features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceFeatures2 structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFeatures2.adoc[] ifdef::VK_KHR_get_physical_device_properties2[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceFeatures2KHR.adoc[] endif::VK_KHR_get_physical_device_properties2[] * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * pname:features is a slink:VkPhysicalDeviceFeatures structure 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:vkGetPhysicalDeviceFeatures2 or can: be included in the pname:pNext chain of a slink:VkDeviceCreateInfo structure, in which case it controls which features are enabled on the device in lieu of pname:pEnabledFeatures. include::{generated}/validity/structs/VkPhysicalDeviceFeatures2.adoc[] -- endif::VK_VERSION_1_1,VK_KHR_get_physical_device_properties2[] [open,refpage='VkPhysicalDeviceFeatures',desc='Structure describing the fine-grained features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFeatures.adoc[] This structure describes the following features: * [[features-robustBufferAccess]] pname:robustBufferAccess specifies that accesses to buffers are bounds-checked against the range of the buffer descriptor (as determined by sname:VkDescriptorBufferInfo::pname:range, slink: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. ifdef::VK_VERSION_1_1,VK_KHR_variable_pointers[] This includes accesses performed via _variable pointers_ where the buffer descriptor being accessed cannot be statically determined. Uninitialized pointers and pointers equal to code:OpConstantNull are treated as pointing to a zero-sized object, so all accesses through such pointers are considered to be out of bounds. endif::VK_VERSION_1_1,VK_KHR_variable_pointers[] ifdef::VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address[] Buffer accesses through buffer device addresses are not bounds-checked. endif::VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address[] ifdef::VK_NV_cooperative_matrix[] *** If the <> feature is not enabled, then accesses using code:OpCooperativeMatrixLoadNV and code:OpCooperativeMatrixStoreNV may: not be bounds-checked. endif::VK_NV_cooperative_matrix[] ifdef::VK_KHR_cooperative_matrix[] *** If the <> feature is not enabled, then accesses using code:OpCooperativeMatrixLoadKHR and code:OpCooperativeMatrixStoreKHR may: not be bounds-checked. endif::VK_KHR_cooperative_matrix[] + [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 ifdef::VK_EXT_robustness2[] <> is not enabled and endif::VK_EXT_robustness2[] any buffer access is determined to be out of bounds, then any other access of the same type (load, store, or atomic) to the same buffer that accesses an address less than 16 bytes away from the out of bounds address may: also be considered out of bounds. *** If the access is a load that reads from the same memory locations as a prior store in the same shader invocation, with no other intervening accesses to the same memory locations in that shader invocation, then the result of the load may: be the value stored by the store instruction, even if the access is out of bounds. If the load is code:Volatile, then an out of bounds load must: return the appropriate out of bounds value. ifdef::VK_EXT_robustness2[] ** Accesses to descriptors written with a dlink:VK_NULL_HANDLE resource or view are not considered to be out of bounds. Instead, each type of descriptor access defines a specific behavior for accesses to a null descriptor. endif::VK_EXT_robustness2[] ** Out-of-bounds buffer loads will return any of the following values: ifdef::VK_EXT_robustness2[] *** If the access is to a uniform buffer and <> is enabled, loads of offsets between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of <> bytes must: return either zero values or the contents of the memory at the offset being loaded. Loads of offsets past the descriptor range rounded up to a multiple of <> bytes must: return zero values. *** If the access is to a storage buffer and <> is enabled, loads of offsets between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of <> bytes must: return either zero values or the contents of the memory at the offset being loaded. Loads of offsets past the descriptor range rounded up to a multiple of <> bytes must: return zero values. Similarly, stores to addresses between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of <> bytes may: be discarded. *** Non-atomic accesses to storage buffers that are a multiple of 32 bits may: be decomposed into 32-bit accesses that are individually bounds-checked. *** If the access is to an index buffer and <> is enabled, zero values must: be returned. *** If the access is to a uniform texel buffer or storage texel buffer and <> is enabled, zero values must: be returned, and then <> is applied based on the buffer view's format. endif::VK_EXT_robustness2[] *** 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. ifdef::VK_EXT_robustness2[] *** If <> is enabled, out of bounds writes must: not modify any memory. endif::VK_EXT_robustness2[] ** 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. ifdef::VK_EXT_robustness2[] *** If <> is enabled, out of bounds atomics must: not modify any memory, and return an undefined: value. ** If <> is disabled, vertex endif::VK_EXT_robustness2[] ifndef::VK_EXT_robustness2[] ** Vertex endif::VK_EXT_robustness2[] input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than either: + *** code:vertexBufferRangeSize, if [eq]#code:bindingStride == 0#; or *** [eq]#(code:vertexBufferRangeSize - (code:vertexBufferRangeSize % code:bindingStride))# + where code:vertexBufferRangeSize is the byte size of the memory range bound to the vertex buffer binding and code:bindingStride is the byte stride of the corresponding vertex input binding. 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. ifdef::VK_EXT_robustness2[] ** If <> is enabled, vertex input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than the byte size of the memory range bound to the vertex buffer binding. *** If a vertex input attribute is out of bounds, the <> extracted are zero values, and missing G, B, or A components are <>. endif::VK_EXT_robustness2[] ** If pname:robustBufferAccess is not enabled, applications must: not perform out of bounds accesses ifdef::VK_EXT_pipeline_robustness[] except under the conditions enabled by the <> feature endif::VK_EXT_pipeline_robustness[] . * [[features-fullDrawIndexUint32]] pname:fullDrawIndexUint32 specifies 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-imageCubeArray]] pname:imageCubeArray specifies 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-independentBlend]] pname:independentBlend specifies 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-geometryShader]] pname:geometryShader specifies 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 specifies whether shader modules can: declare the code:Geometry capability. * [[features-tessellationShader]] pname:tessellationShader specifies 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 specifies whether shader modules can: declare the code:Tessellation capability. * [[features-sampleRateShading]] pname:sampleRateShading specifies whether <> and multisample interpolation are supported. If this feature is not enabled, the pname:sampleShadingEnable member of the slink:VkPipelineMultisampleStateCreateInfo structure must: be set to ename:VK_FALSE and the pname:minSampleShading member is ignored. This also specifies whether shader modules can: declare the code:SampleRateShading capability. * [[features-dualSrcBlend]] pname:dualSrcBlend specifies 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 <>. * [[features-logicOp]] pname:logicOp specifies whether logic operations are supported. If this feature is not enabled, the pname:logicOpEnable member of the slink:VkPipelineColorBlendStateCreateInfo structure must: be set to ename:VK_FALSE, and the pname:logicOp member is ignored. * [[features-multiDrawIndirect]] pname:multiDrawIndirect specifies 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-drawIndirectFirstInstance]] pname:drawIndirectFirstInstance specifies whether indirect drawing 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-depthClamp]] pname:depthClamp specifies whether depth clamping is supported. If this feature is not enabled, the pname:depthClampEnable member of the slink:VkPipelineRasterizationStateCreateInfo structure must: be set to ename:VK_FALSE. Otherwise, setting pname:depthClampEnable to ename:VK_TRUE will enable depth clamping. * [[features-depthBiasClamp]] pname:depthBiasClamp specifies whether depth bias clamping is supported. If this feature is not enabled, the pname:depthBiasClamp member of the slink: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-fillModeNonSolid]] pname:fillModeNonSolid specifies 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-depthBounds]] pname:depthBounds specifies whether depth bounds tests are supported. If this feature is not enabled, the pname:depthBoundsTestEnable member of the slink: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 slink:VkPipelineDepthStencilStateCreateInfo structure are ignored. * [[features-wideLines]] pname:wideLines specifies whether lines with width other than 1.0 are supported. If this feature is not enabled, the pname:lineWidth member of the slink: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-largePoints]] pname:largePoints specifies 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-alphaToOne]] pname:alphaToOne specifies whether the implementation is able to replace the alpha value of the fragment shader color output in the <> fragment operation. If this feature is not enabled, then the pname:alphaToOneEnable member of the slink:VkPipelineMultisampleStateCreateInfo structure must: be set to ename:VK_FALSE. Otherwise setting pname:alphaToOneEnable to ename:VK_TRUE will enable alpha-to-one behavior. * [[features-multiViewport]] pname:multiViewport specifies whether more than one viewport is supported. If this feature is not enabled: ** The pname:viewportCount and pname:scissorCount members of the slink:VkPipelineViewportStateCreateInfo structure must: be set to 1. ** The pname:firstViewport and pname:viewportCount parameters to the fname:vkCmdSetViewport command must: be set to 0 and 1, respectively. ** The pname:firstScissor and pname:scissorCount parameters to the fname:vkCmdSetScissor command must: be set to 0 and 1, respectively. ifdef::VK_NV_scissor_exclusive[] ** The pname:exclusiveScissorCount member of the slink:VkPipelineViewportExclusiveScissorStateCreateInfoNV structure must: be set to 0 or 1. ** The pname:firstExclusiveScissor and pname:exclusiveScissorCount parameters to the fname:vkCmdSetExclusiveScissorNV command must: be set to 0 and 1, respectively. endif::VK_NV_scissor_exclusive[] * [[features-samplerAnisotropy]] pname:samplerAnisotropy specifies whether anisotropic filtering is supported. If this feature is not enabled, the pname:anisotropyEnable member of the slink:VkSamplerCreateInfo structure must: be ename:VK_FALSE. * [[features-textureCompressionETC2]] pname:textureCompressionETC2 specifies 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 + To query for additional properties, or if the feature is not enabled, flink:vkGetPhysicalDeviceFormatProperties and flink:vkGetPhysicalDeviceImageFormatProperties can: be used to check for supported properties of individual formats as normal. * [[features-textureCompressionASTC_LDR]] pname:textureCompressionASTC_LDR specifies 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 + To query for additional properties, or if the feature is not enabled, flink:vkGetPhysicalDeviceFormatProperties and flink:vkGetPhysicalDeviceImageFormatProperties can: be used to check for supported properties of individual formats as normal. * [[features-textureCompressionBC]] pname:textureCompressionBC specifies 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 + To query for additional properties, or if the feature is not enabled, flink:vkGetPhysicalDeviceFormatProperties and flink:vkGetPhysicalDeviceImageFormatProperties can: be used to check for supported properties of individual formats as normal. * [[features-occlusionQueryPrecise]] pname:occlusionQueryPrecise specifies 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 slink: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-pipelineStatisticsQuery]] pname:pipelineStatisticsQuery specifies 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 slink:VkQueryPoolCreateInfo structure. * [[features-vertexPipelineStoresAndAtomics]] pname:vertexPipelineStoresAndAtomics specifies 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 buffer, and storage buffer variables used by these stages in shader modules must: be decorated with the code:NonWritable decoration (or the code:readonly memory qualifier in GLSL). * [[features-fragmentStoresAndAtomics]] pname:fragmentStoresAndAtomics specifies 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 buffer, and storage buffer variables used by the fragment stage in shader modules must: be decorated with the code:NonWritable decoration (or the code:readonly memory qualifier in GLSL). * [[features-shaderTessellationAndGeometryPointSize]] pname:shaderTessellationAndGeometryPointSize specifies 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 specifies 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 <> or <> features. * [[features-shaderImageGatherExtended]] pname:shaderImageGatherExtended specifies whether the extended set of image gather instructions are available in shader code. If this feature is not enabled, the code:OpImage*Gather instructions do not support the code:Offset and code:ConstOffsets operands. This also specifies whether shader modules can: declare the code:ImageGatherExtended capability. * [[features-shaderStorageImageExtendedFormats]] pname:shaderStorageImageExtendedFormats specifies whether all the "`storage image extended formats`" below are supported; if this feature is supported, then the ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT must: be supported in pname:optimalTilingFeatures for the following formats: + ** ename:VK_FORMAT_R16G16_SFLOAT ** ename:VK_FORMAT_B10G11R11_UFLOAT_PACK32 ** ename:VK_FORMAT_R16_SFLOAT ** ename:VK_FORMAT_R16G16B16A16_UNORM ** ename:VK_FORMAT_A2B10G10R10_UNORM_PACK32 ** ename:VK_FORMAT_R16G16_UNORM ** ename:VK_FORMAT_R8G8_UNORM ** ename:VK_FORMAT_R16_UNORM ** ename:VK_FORMAT_R8_UNORM ** ename:VK_FORMAT_R16G16B16A16_SNORM ** ename:VK_FORMAT_R16G16_SNORM ** ename:VK_FORMAT_R8G8_SNORM ** ename:VK_FORMAT_R16_SNORM ** ename:VK_FORMAT_R8_SNORM ** ename:VK_FORMAT_R16G16_SINT ** ename:VK_FORMAT_R8G8_SINT ** ename:VK_FORMAT_R16_SINT ** ename:VK_FORMAT_R8_SINT ** ename:VK_FORMAT_A2B10G10R10_UINT_PACK32 ** ename:VK_FORMAT_R16G16_UINT ** ename:VK_FORMAT_R8G8_UINT ** ename:VK_FORMAT_R16_UINT ** ename:VK_FORMAT_R8_UINT + [NOTE] .Note ==== pname:shaderStorageImageExtendedFormats feature only adds a guarantee of format support, which is specified for the whole physical device. Therefore enabling or disabling the feature via flink:vkCreateDevice has no practical effect. To query for additional properties, or if the feature is not supported, flink:vkGetPhysicalDeviceFormatProperties and flink:vkGetPhysicalDeviceImageFormatProperties can: be used to check for supported properties of individual formats, as usual rules allow. ename:VK_FORMAT_R32G32_UINT, ename:VK_FORMAT_R32G32_SINT, and ename:VK_FORMAT_R32G32_SFLOAT from code:StorageImageExtendedFormats SPIR-V capability, are already covered by core Vulkan <>. ==== * [[features-shaderStorageImageMultisample]] pname:shaderStorageImageMultisample specifies 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 specifies whether shader modules can: declare the code:StorageImageMultisample and code:ImageMSArray capabilities. * [[features-shaderStorageImageReadWithoutFormat]] pname:shaderStorageImageReadWithoutFormat specifies whether storage images and storage texel buffers require a format qualifier to be specified when reading. ifdef::VK_VERSION_1_3,VK_KHR_format_feature_flags2[] pname:shaderStorageImageReadWithoutFormat applies only to formats listed in the <> list. endif::VK_VERSION_1_3,VK_KHR_format_feature_flags2[] * [[features-shaderStorageImageWriteWithoutFormat]] pname:shaderStorageImageWriteWithoutFormat specifies whether storage images and storage texel buffers require a format qualifier to be specified when writing. ifdef::VK_VERSION_1_3,VK_KHR_format_feature_flags2[] pname:shaderStorageImageWriteWithoutFormat applies only to formats listed in the <> list. endif::VK_VERSION_1_3,VK_KHR_format_feature_flags2[] * [[features-shaderUniformBufferArrayDynamicIndexing]] pname:shaderUniformBufferArrayDynamicIndexing specifies 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 specifies whether shader modules can: declare the code:UniformBufferArrayDynamicIndexing capability. * [[features-shaderSampledImageArrayDynamicIndexing]] pname:shaderSampledImageArrayDynamicIndexing specifies 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 specifies whether shader modules can: declare the code:SampledImageArrayDynamicIndexing capability. * [[features-shaderStorageBufferArrayDynamicIndexing]] pname:shaderStorageBufferArrayDynamicIndexing specifies 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 specifies whether shader modules can: declare the code:StorageBufferArrayDynamicIndexing capability. * [[features-shaderStorageImageArrayDynamicIndexing]] pname:shaderStorageImageArrayDynamicIndexing specifies 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 specifies whether shader modules can: declare the code:StorageImageArrayDynamicIndexing capability. * [[features-shaderClipDistance]] pname:shaderClipDistance specifies 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 specifies whether shader modules can: declare the code:ClipDistance capability. * [[features-shaderCullDistance]] pname:shaderCullDistance specifies 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 specifies whether shader modules can: declare the code:CullDistance capability. * [[features-shaderFloat64]] pname:shaderFloat64 specifies 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 specifies whether shader modules can: declare the code:Float64 capability. Declaring and using 64-bit floats is enabled for all storage classes that SPIR-V allows with the code:Float64 capability. * [[features-shaderInt64]] pname:shaderInt64 specifies 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 specifies whether shader modules can: declare the code:Int64 capability. Declaring and using 64-bit integers is enabled for all storage classes that SPIR-V allows with the code:Int64 capability. * [[features-shaderInt16]] pname:shaderInt16 specifies 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 specifies whether shader modules can: declare the code:Int16 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the code:Int16 SPIR-V capability: Declaring and using 16-bit integers in the code:Private, ifndef::VK_KHR_workgroup_memory_explicit_layout[] code:Workgroup, endif::VK_KHR_workgroup_memory_explicit_layout[] ifdef::VK_KHR_workgroup_memory_explicit_layout[] code:Workgroup (for non-Block variables), endif::VK_KHR_workgroup_memory_explicit_layout[] and code:Function storage classes is enabled, while declaring them in the interface storage classes (e.g., code:UniformConstant, code:Uniform, code:StorageBuffer, code:Input, code:Output, and code:PushConstant) is not enabled. * [[features-shaderResourceResidency]] pname:shaderResourceResidency specifies 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 specifies whether shader modules can: declare the code:SparseResidency capability. The feature requires at least one of the ptext:sparseResidency* features to be supported. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-shaderResourceMinLod]] pname:shaderResourceMinLod specifies whether image operations specifying the minimum resource 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 specifies whether shader modules can: declare the code:MinLod capability. * [[features-sparseBinding]] pname:sparseBinding specifies 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 slink:VkBufferCreateInfo and slink:VkImageCreateInfo structures, respectively. Otherwise resource memory can: be managed as described in <>. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-sparseResidencyBuffer]] pname:sparseResidencyBuffer specifies 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 slink:VkBufferCreateInfo structure. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-sparseResidencyImage2D]] pname:sparseResidencyImage2D specifies 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 slink:VkImageCreateInfo structure. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-sparseResidencyImage3D]] pname:sparseResidencyImage3D specifies 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 slink:VkImageCreateInfo structure. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-sparseResidency2Samples]] pname:sparseResidency2Samples specifies 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 slink:VkImageCreateInfo structure. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-sparseResidency4Samples]] pname:sparseResidency4Samples specifies 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 slink:VkImageCreateInfo structure. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-sparseResidency8Samples]] pname:sparseResidency8Samples specifies 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 slink:VkImageCreateInfo structure. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-sparseResidency16Samples]] pname:sparseResidency16Samples specifies 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 slink:VkImageCreateInfo structure. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-sparseResidencyAliased]] pname:sparseResidencyAliased specifies 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 slink:VkBufferCreateInfo and slink:VkImageCreateInfo structures, respectively. ifdef::VKSC_VERSION_1_0[This must: be ename:VK_FALSE in Vulkan SC <>.] * [[features-variableMultisampleRate]] pname:variableMultisampleRate specifies whether all pipelines that will be bound to a command buffer during a <> must: have the same value for slink:VkPipelineMultisampleStateCreateInfo::pname:rasterizationSamples. If set to ename:VK_TRUE, the implementation supports variable multisample rates in a subpass which uses 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-inheritedQueries]] pname:inheritedQueries specifies whether a secondary command buffer may: be executed while a query is active. ifdef::VKSC_VERSION_1_0[] ifdef::hidden[] // tag::scdeviation[] * slink:VkPhysicalDeviceFeatures::pname:shaderResourceResidency must: be reported as ename:VK_FALSE <>. * slink:VkPhysicalDeviceFeatures::pname:sparseBinding must: be reported as ename:VK_FALSE <>. * slink:VkPhysicalDeviceFeatures::pname:sparseResidencyBuffer must: be reported as ename:VK_FALSE <>. * slink:VkPhysicalDeviceFeatures::pname:sparseResidencyImage2D must: be reported as ename:VK_FALSE <>. * slink:VkPhysicalDeviceFeatures::pname:sparseResidencyImage3D must: be reported as ename:VK_FALSE <>. * slink:VkPhysicalDeviceFeatures::pname:sparseResidency2Samples must: be reported as ename:VK_FALSE <>. * slink:VkPhysicalDeviceFeatures::pname:sparseResidency4Samples must: be reported as ename:VK_FALSE <>. * slink:VkPhysicalDeviceFeatures::pname:sparseResidency8Samples must: be reported as ename:VK_FALSE <>. * slink:VkPhysicalDeviceFeatures::pname:sparseResidency16Samples must: be reported as ename:VK_FALSE <>. * slink:VkPhysicalDeviceFeatures::pname:sparseResidencyAliased must: be reported as ename:VK_FALSE <>. // end::scdeviation[] endif::hidden[] endif::VKSC_VERSION_1_0[] include::{generated}/validity/structs/VkPhysicalDeviceFeatures.adoc[] -- ifdef::VK_VERSION_1_2[] [open,refpage='VkPhysicalDeviceVulkan11Features',desc='Structure describing the Vulkan 1.1 features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceVulkan11Features structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceVulkan11Features.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. :anchor-prefix: include::{chapters}/features.adoc[tag=VK_KHR_16bit_storage-features] include::{chapters}/features.adoc[tag=VK_KHR_multiview-features] include::{chapters}/features.adoc[tag=VK_KHR_variable_pointers-features] include::{chapters}/features.adoc[tag=VK_KHR_protected_memory-features] include::{chapters}/features.adoc[tag=VK_KHR_sampler_ycbcr_conversion-features] include::{chapters}/features.adoc[tag=VK_KHR_shader_draw_parameters-features] :refpage: VkPhysicalDeviceVulkan11Features include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceVulkan11Features.adoc[] -- [open,refpage='VkPhysicalDeviceVulkan12Features',desc='Structure describing the Vulkan 1.2 features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceVulkan12Features structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceVulkan12Features.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. :anchor-prefix: * [[features-samplerMirrorClampToEdge]] pname:samplerMirrorClampToEdge indicates whether the implementation supports the ename:VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE sampler address mode. If this feature is not enabled, the ename:VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE sampler address mode must: not be used. * [[features-drawIndirectCount]] pname:drawIndirectCount indicates whether the implementation supports the flink:vkCmdDrawIndirectCount and flink:vkCmdDrawIndexedIndirectCount functions. If this feature is not enabled, these functions must: not be used. include::{chapters}/features.adoc[tag=VK_KHR_8bit_storage-features] include::{chapters}/features.adoc[tag=VK_KHR_shader_atomic_int64-features] include::{chapters}/features.adoc[tag=VK_KHR_shader_float16_int8-features] * [[features-descriptorIndexing]] pname:descriptorIndexing indicates whether the implementation supports the minimum set of descriptor indexing features as described in the <> section. Enabling the pname:descriptorIndexing member when flink:vkCreateDevice is called does not imply the other minimum descriptor indexing features are also enabled. Those other descriptor indexing features must: be enabled individually as needed by the application. include::{chapters}/features.adoc[tag=VK_EXT_descriptor_indexing-features] * [[features-samplerFilterMinmax]] pname:samplerFilterMinmax indicates whether the implementation supports a minimum set of required formats supporting min/max filtering as defined by the <> property minimum requirements. If this feature is not enabled, then slink:VkSamplerReductionModeCreateInfo must: only use ename:VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE. include::{chapters}/features.adoc[tag=VK_EXT_scalar_block_layout-features] include::{chapters}/features.adoc[tag=VK_KHR_imageless_framebuffer-features] include::{chapters}/features.adoc[tag=VK_KHR_uniform_buffer_standard_layout-features] include::{chapters}/features.adoc[tag=VK_KHR_shader_subgroup_extended_types-features] include::{chapters}/features.adoc[tag=VK_KHR_separate_depth_stencil_layouts-features] include::{chapters}/features.adoc[tag=VK_EXT_host_query_reset-features] include::{chapters}/features.adoc[tag=VK_KHR_timeline_semaphore-features] include::{chapters}/features.adoc[tag=VK_EXT_buffer_device_address-features] include::{chapters}/features.adoc[tag=VK_KHR_vulkan_memory_model-features] * [[features-shaderOutputViewportIndex]] pname:shaderOutputViewportIndex indicates whether the implementation supports the code:ShaderViewportIndex SPIR-V capability enabling variables decorated with the code:ViewportIndex built-in to be exported from ifdef::VK_NV_mesh_shader,VK_EXT_mesh_shader[mesh,] vertex or tessellation evaluation shaders. If this feature is not enabled, the code:ViewportIndex built-in decoration must: not be used on outputs in ifdef::VK_NV_mesh_shader,VK_EXT_mesh_shader[mesh,] vertex or tessellation evaluation shaders. * [[features-shaderOutputLayer]] pname:shaderOutputLayer indicates whether the implementation supports the code:ShaderLayer SPIR-V capability enabling variables decorated with the code:Layer built-in to be exported from ifdef::VK_NV_mesh_shader,VK_EXT_mesh_shader[mesh,] vertex or tessellation evaluation shaders. If this feature is not enabled, the code:Layer built-in decoration must: not be used on outputs in ifdef::VK_NV_mesh_shader,VK_EXT_mesh_shader[mesh,] vertex or tessellation evaluation shaders. * [[features-subgroupBroadcastDynamicId]] If pname:subgroupBroadcastDynamicId is ename:VK_TRUE, the "`Id`" operand of code:OpGroupNonUniformBroadcast can: be dynamically uniform within a subgroup, and the "`Index`" operand of code:OpGroupNonUniformQuadBroadcast can: be dynamically uniform within the derivative group. If it is ename:VK_FALSE, these operands must: be constants. :refpage: VkPhysicalDeviceVulkan12Features include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceVulkan12Features.adoc[] -- endif::VK_VERSION_1_2[] ifdef::VK_VERSION_1_3[] [open,refpage='VkPhysicalDeviceVulkan13Features',desc='Structure describing the Vulkan 1.3 features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceVulkan13Features structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceVulkan13Features.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. :anchor-prefix: include::{chapters}/features.adoc[tag=VK_EXT_image_robustness-features] include::{chapters}/features.adoc[tag=VK_EXT_inline_uniform_block-features] include::{chapters}/features.adoc[tag=VK_EXT_pipeline_creation_cache_control-features] include::{chapters}/features.adoc[tag=VK_EXT_private_data-features] include::{chapters}/features.adoc[tag=VK_EXT_shader_demote_to_helper_invocation-features] include::{chapters}/features.adoc[tag=VK_KHR_shader_terminate_invocation-features] include::{chapters}/features.adoc[tag=VK_EXT_subgroup_size_control-features] include::{chapters}/features.adoc[tag=VK_KHR_synchronization2-features] include::{chapters}/features.adoc[tag=VK_EXT_texture_compression_astc_hdr-features] include::{chapters}/features.adoc[tag=VK_KHR_zero_initialize_workgroup_memory-features] include::{chapters}/features.adoc[tag=VK_KHR_dynamic_rendering-features] include::{chapters}/features.adoc[tag=VK_KHR_shader_integer_dot_product-features] include::{chapters}/features.adoc[tag=VK_KHR_maintenance4-features] :refpage: VkPhysicalDeviceVulkan13Features include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceVulkan13Features.adoc[] -- endif::VK_VERSION_1_3[] ifdef::VK_VERSION_1_1,VK_KHR_variable_pointers[] [open,refpage='VkPhysicalDeviceVariablePointersFeatures',desc='Structure describing variable pointers features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceVariablePointerFeatures VkPhysicalDeviceVariablePointersFeaturesKHR VkPhysicalDeviceVariablePointerFeaturesKHR'] -- The sname:VkPhysicalDeviceVariablePointersFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceVariablePointersFeatures.adoc[] ifndef::VKSC_VERSION_1_0[] ifdef::VK_VERSION_1_1[] include::{generated}/api/structs/VkPhysicalDeviceVariablePointerFeatures.adoc[] endif::VK_VERSION_1_1[] endif::VKSC_VERSION_1_0[] ifdef::VK_KHR_variable_pointers[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceVariablePointersFeaturesKHR.adoc[] include::{generated}/api/structs/VkPhysicalDeviceVariablePointerFeaturesKHR.adoc[] endif::VK_KHR_variable_pointers[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_variable_pointers-features[] * [[{anchor-prefix}features-variablePointersStorageBuffer]] pname:variablePointersStorageBuffer specifies whether the implementation supports the SPIR-V code:VariablePointersStorageBuffer capability. When this feature is not enabled, shader modules must: not declare the `SPV_KHR_variable_pointers` extension or the code:VariablePointersStorageBuffer capability. * [[{anchor-prefix}features-variablePointers]] pname:variablePointers specifies whether the implementation supports the SPIR-V code:VariablePointers capability. When this feature is not enabled, shader modules must: not declare the code:VariablePointers capability. // end::VK_KHR_variable_pointers-features[] :refpage: VkPhysicalDeviceVariablePointersFeatures include::{chapters}/features.adoc[tag=features] .Valid Usage **** * [[VUID-VkPhysicalDeviceVariablePointersFeatures-variablePointers-01431]] If pname:variablePointers is enabled then pname:variablePointersStorageBuffer must: also be enabled **** include::{generated}/validity/structs/VkPhysicalDeviceVariablePointersFeatures.adoc[] -- endif::VK_VERSION_1_1,VK_KHR_variable_pointers[] ifdef::VK_VERSION_1_1,VK_KHR_multiview[] [open,refpage='VkPhysicalDeviceMultiviewFeatures',desc='Structure describing multiview features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceMultiviewFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMultiviewFeatures.adoc[] ifdef::VK_KHR_multiview[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceMultiviewFeaturesKHR.adoc[] endif::VK_KHR_multiview[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_multiview-features[] * [[{anchor-prefix}features-multiview]] pname:multiview specifies 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. * [[{anchor-prefix}features-multiview-gs]] pname:multiviewGeometryShader specifies whether the implementation supports multiview rendering within a render pass, with <>. 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. * [[{anchor-prefix}features-multiview-tess]] pname:multiviewTessellationShader specifies whether the implementation supports multiview rendering within a render pass, with <>. 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. // end::VK_KHR_multiview-features[] :refpage: VkPhysicalDeviceMultiviewFeatures include::{chapters}/features.adoc[tag=features] .Valid Usage **** * [[VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580]] If pname:multiviewGeometryShader is enabled then pname:multiview must: also be enabled * [[VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581]] If pname:multiviewTessellationShader is enabled then pname:multiview must: also be enabled **** include::{generated}/validity/structs/VkPhysicalDeviceMultiviewFeatures.adoc[] -- endif::VK_VERSION_1_1,VK_KHR_multiview[] ifdef::VK_EXT_shader_atomic_float[] [open,refpage='VkPhysicalDeviceShaderAtomicFloatFeaturesEXT',desc='Structure describing features supported by VK_EXT_shader_atomic_float',type='structs'] -- The slink:VkPhysicalDeviceShaderAtomicFloatFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // tag::VK_EXT_shader_atomic_float-features[] * [[features-shaderBufferFloat32Atomics]] pname:shaderBufferFloat32Atomics indicates whether shaders can: perform 32-bit floating-point load, store and exchange atomic operations on storage buffers. * [[features-shaderBufferFloat32AtomicAdd]] pname:shaderBufferFloat32AtomicAdd indicates whether shaders can: perform 32-bit floating-point add atomic operations on storage buffers. * [[features-shaderBufferFloat64Atomics]] pname:shaderBufferFloat64Atomics indicates whether shaders can: perform 64-bit floating-point load, store and exchange atomic operations on storage buffers. * [[features-shaderBufferFloat64AtomicAdd]] pname:shaderBufferFloat64AtomicAdd indicates whether shaders can: perform 64-bit floating-point add atomic operations on storage buffers. * [[features-shaderSharedFloat32Atomics]] pname:shaderSharedFloat32Atomics indicates whether shaders can: perform 32-bit floating-point load, store and exchange atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. * [[features-shaderSharedFloat32AtomicAdd]] pname:shaderSharedFloat32AtomicAdd indicates whether shaders can: perform 32-bit floating-point add atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. * [[features-shaderSharedFloat64Atomics]] pname:shaderSharedFloat64Atomics indicates whether shaders can: perform 64-bit floating-point load, store and exchange atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. * [[features-shaderSharedFloat64AtomicAdd]] pname:shaderSharedFloat64AtomicAdd indicates whether shaders can: perform 64-bit floating-point add atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. * [[features-shaderImageFloat32Atomics]] pname:shaderImageFloat32Atomics indicates whether shaders can: perform 32-bit floating-point load, store and exchange atomic image operations. * [[features-shaderImageFloat32AtomicAdd]] pname:shaderImageFloat32AtomicAdd indicates whether shaders can: perform 32-bit floating-point add atomic image operations. * [[features-sparseImageFloat32Atomics]] pname:sparseImageFloat32Atomics indicates whether 32-bit floating-point load, store and exchange atomic operations can: be used on sparse images. * [[features-sparseImageFloat32AtomicAdd]] pname:sparseImageFloat32AtomicAdd indicates whether 32-bit floating-point add atomic operations can: be used on sparse images. // end::VK_EXT_shader_atomic_float-features[] :refpage: VkPhysicalDeviceShaderAtomicFloatFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.adoc[] -- endif::VK_EXT_shader_atomic_float[] ifdef::VK_EXT_shader_atomic_float2[] [open,refpage='VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT',desc='Structure describing features supported by VK_EXT_shader_atomic_float2',type='structs'] -- The slink:VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // tag::VK_EXT_shader_atomic_float2-features[] * [[features-shaderBufferFloat16Atomics]] pname:shaderBufferFloat16Atomics indicates whether shaders can: perform 16-bit floating-point load, store, and exchange atomic operations on storage buffers. * [[features-shaderBufferFloat16AtomicAdd]] pname:shaderBufferFloat16AtomicAdd indicates whether shaders can: perform 16-bit floating-point add atomic operations on storage buffers. * [[features-shaderBufferFloat16AtomicMinMax]] pname:shaderBufferFloat16AtomicMinMax indicates whether shaders can: perform 16-bit floating-point min and max atomic operations on storage buffers. * [[features-shaderBufferFloat32AtomicMinMax]] pname:shaderBufferFloat32AtomicMinMax indicates whether shaders can: perform 32-bit floating-point min and max atomic operations on storage buffers. * [[features-shaderBufferFloat64AtomicMinMax]] pname:shaderBufferFloat64AtomicMinMax indicates whether shaders can: perform 64-bit floating-point min and max atomic operations on storage buffers. * [[features-shaderSharedFloat16Atomics]] pname:shaderSharedFloat16Atomics indicates whether shaders can: perform 16-bit floating-point load, store and exchange atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. * [[features-shaderSharedFloat16AtomicAdd]] pname:shaderSharedFloat16AtomicAdd indicates whether shaders can: perform 16-bit floating-point add atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. * [[features-shaderSharedFloat16AtomicMinMax]] pname:shaderSharedFloat16AtomicMinMax indicates whether shaders can: perform 16-bit floating-point min and max atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. * [[features-shaderSharedFloat32AtomicMinMax]] pname:shaderSharedFloat32AtomicMinMax indicates whether shaders can: perform 32-bit floating-point min and max atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. * [[features-shaderSharedFloat64AtomicMinMax]] pname:shaderSharedFloat64AtomicMinMax indicates whether shaders can: perform 64-bit floating-point min and max atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. * [[features-shaderImageFloat32AtomicMinMax]] pname:shaderImageFloat32AtomicMinMax indicates whether shaders can: perform 32-bit floating-point min and max atomic image operations. * [[features-sparseImageFloat32AtomicMinMax]] pname:sparseImageFloat32AtomicMinMax indicates whether 32-bit floating-point min and max atomic operations can: be used on sparse images. // end::VK_EXT_shader_atomic_float2-features[] :refpage: VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.adoc[] -- endif::VK_EXT_shader_atomic_float2[] ifdef::VK_VERSION_1_2,VK_KHR_shader_atomic_int64[] [open,refpage='VkPhysicalDeviceShaderAtomicInt64Features',desc='Structure describing features supported by VK_KHR_shader_atomic_int64',type='structs',alias='VkPhysicalDeviceShaderAtomicInt64FeaturesKHR'] -- The slink:VkPhysicalDeviceShaderAtomicInt64Features structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderAtomicInt64Features.adoc[] ifdef::VK_KHR_shader_atomic_int64[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceShaderAtomicInt64FeaturesKHR.adoc[] endif::VK_KHR_shader_atomic_int64[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_shader_atomic_int64-features[] * [[{anchor-prefix}features-shaderBufferInt64Atomics]] pname:shaderBufferInt64Atomics indicates whether shaders can: perform 64-bit unsigned and signed integer atomic operations on buffers. * [[{anchor-prefix}features-shaderSharedInt64Atomics]] pname:shaderSharedInt64Atomics indicates whether shaders can: perform 64-bit unsigned and signed integer atomic operations on shared ifdef::VK_EXT_mesh_shader[] and payload endif::VK_EXT_mesh_shader[] memory. // end::VK_KHR_shader_atomic_int64-features[] :refpage: VkPhysicalDeviceShaderAtomicInt64Features include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderAtomicInt64Features.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_shader_atomic_int64[] ifdef::VK_EXT_shader_image_atomic_int64[] [open,refpage='VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT',desc='Structure describing features supported by VK_EXT_shader_image_atomic_int64',type='structs'] -- The slink:VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderImageInt64Atomics]] pname:shaderImageInt64Atomics indicates whether shaders can: support 64-bit unsigned and signed integer atomic operations on images. * [[features-sparseImageInt64Atomics]] pname:sparseImageInt64Atomics indicates whether 64-bit integer atomics can: be used on sparse images. :refpage: VkPhysicalDeviceShaderAtomicInt64FeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.adoc[] -- endif::VK_EXT_shader_image_atomic_int64[] ifdef::VK_VERSION_1_2,VK_KHR_8bit_storage[] [open,refpage='VkPhysicalDevice8BitStorageFeatures',desc='Structure describing features supported by VK_KHR_8bit_storage',type='structs',alias='VkPhysicalDevice8BitStorageFeaturesKHR'] -- The slink:VkPhysicalDevice8BitStorageFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDevice8BitStorageFeatures.adoc[] ifdef::VK_KHR_8bit_storage[] or the equivalent include::{generated}/api/structs/VkPhysicalDevice8BitStorageFeaturesKHR.adoc[] endif::VK_KHR_8bit_storage[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_8bit_storage-features[] * [[{anchor-prefix}features-storageBuffer8BitAccess]] pname:storageBuffer8BitAccess indicates whether objects in the code:StorageBuffer, ifdef::VK_KHR_ray_tracing_pipeline[code:ShaderRecordBufferKHR,] ifdef::VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address[] or code:PhysicalStorageBuffer endif::VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address[] storage class with the code:Block decoration can: have 8-bit integer members. If this feature is not enabled, 8-bit integer members must: not be used in such objects. This also indicates whether shader modules can: declare the code:StorageBuffer8BitAccess capability. * [[{anchor-prefix}features-uniformAndStorageBuffer8BitAccess]] pname:uniformAndStorageBuffer8BitAccess indicates whether objects in the code:Uniform storage class with the code:Block decoration can: have 8-bit integer members. If this feature is not enabled, 8-bit integer members must: not be used in such objects. This also indicates whether shader modules can: declare the code:UniformAndStorageBuffer8BitAccess capability. * [[{anchor-prefix}features-storagePushConstant8]] pname:storagePushConstant8 indicates whether objects in the code:PushConstant storage class can: have 8-bit integer members. If this feature is not enabled, 8-bit integer members must: not be used in such objects. This also indicates whether shader modules can: declare the code:StoragePushConstant8 capability. // end::VK_KHR_8bit_storage-features[] :refpage: VkPhysicalDevice8BitStorageFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevice8BitStorageFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_8bit_storage[] ifdef::VK_VERSION_1_1,VK_KHR_16bit_storage[] [open,refpage='VkPhysicalDevice16BitStorageFeatures',desc='Structure describing features supported by VK_KHR_16bit_storage',type='structs'] -- The slink:VkPhysicalDevice16BitStorageFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDevice16BitStorageFeatures.adoc[] ifdef::VK_KHR_16bit_storage[] or the equivalent include::{generated}/api/structs/VkPhysicalDevice16BitStorageFeaturesKHR.adoc[] endif::VK_KHR_16bit_storage[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_16bit_storage-features[] * [[{anchor-prefix}features-storageBuffer16BitAccess]] pname:storageBuffer16BitAccess specifies whether objects in the code:StorageBuffer, ifdef::VK_KHR_ray_tracing_pipeline[code:ShaderRecordBufferKHR,] ifdef::VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address[] or code:PhysicalStorageBuffer endif::VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address[] storage class with the code:Block decoration can: have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must: not be used in such objects. This also specifies whether shader modules can: declare the code:StorageBuffer16BitAccess capability. * [[{anchor-prefix}features-uniformAndStorageBuffer16BitAccess]] pname:uniformAndStorageBuffer16BitAccess specifies whether objects in the code:Uniform storage class with the code:Block decoration can: have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must: not be used in such objects. This also specifies whether shader modules can: declare the code:UniformAndStorageBuffer16BitAccess capability. * [[{anchor-prefix}features-storagePushConstant16]] pname:storagePushConstant16 specifies whether objects in the code:PushConstant storage class can: have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or floating-point members must: not be used in such objects. This also specifies whether shader modules can: declare the code:StoragePushConstant16 capability. * [[{anchor-prefix}features-storageInputOutput16]] pname:storageInputOutput16 specifies whether objects in the code:Input and code:Output storage classes can: have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must: not be used in such objects. This also specifies whether shader modules can: declare the code:StorageInputOutput16 capability. // end::VK_KHR_16bit_storage-features[] :refpage: VkPhysicalDevice16BitStorageFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevice16BitStorageFeatures.adoc[] -- endif::VK_VERSION_1_1,VK_KHR_16bit_storage[] ifdef::VK_VERSION_1_2,VK_KHR_shader_float16_int8[] [open,refpage='VkPhysicalDeviceShaderFloat16Int8Features',desc='Structure describing features supported by VK_KHR_shader_float16_int8',type='structs',alias='VkPhysicalDeviceShaderFloat16Int8FeaturesKHR VkPhysicalDeviceFloat16Int8FeaturesKHR'] -- The sname:VkPhysicalDeviceShaderFloat16Int8Features structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderFloat16Int8Features.adoc[] ifdef::VK_KHR_shader_float16_int8[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceShaderFloat16Int8FeaturesKHR.adoc[] include::{generated}/api/structs/VkPhysicalDeviceFloat16Int8FeaturesKHR.adoc[] endif::VK_KHR_shader_float16_int8[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_shader_float16_int8-features[] * [[{anchor-prefix}features-shaderFloat16]] pname:shaderFloat16 indicates whether 16-bit floats (halfs) are supported in shader code. This also indicates whether shader modules can: declare the code:Float16 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the code:Float16 SPIR-V capability: Declaring and using 16-bit floats in the code:Private, ifndef::VK_KHR_workgroup_memory_explicit_layout[] code:Workgroup, endif::VK_KHR_workgroup_memory_explicit_layout[] ifdef::VK_KHR_workgroup_memory_explicit_layout[] code:Workgroup (for non-Block variables), endif::VK_KHR_workgroup_memory_explicit_layout[] and code:Function storage classes is enabled, while declaring them in the interface storage classes (e.g., code:UniformConstant, code:Uniform, code:StorageBuffer, code:Input, code:Output, and code:PushConstant) is not enabled. * [[{anchor-prefix}features-shaderInt8]] pname:shaderInt8 indicates whether 8-bit integers (signed and unsigned) are supported in shader code. This also indicates whether shader modules can: declare the code:Int8 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the code:Int8 SPIR-V capability: Declaring and using 8-bit integers in the code:Private, ifndef::VK_KHR_workgroup_memory_explicit_layout[] code:Workgroup, endif::VK_KHR_workgroup_memory_explicit_layout[] ifdef::VK_KHR_workgroup_memory_explicit_layout[] code:Workgroup (for non-Block variables), endif::VK_KHR_workgroup_memory_explicit_layout[] and code:Function storage classes is enabled, while declaring them in the interface storage classes (e.g., code:UniformConstant, code:Uniform, code:StorageBuffer, code:Input, code:Output, and code:PushConstant) is not enabled. // end::VK_KHR_shader_float16_int8-features[] :refpage: VkPhysicalDeviceShaderFloat16Int8Features include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderFloat16Int8Features.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_shader_float16_int8[] ifdef::VK_KHR_shader_clock[] [open,refpage='VkPhysicalDeviceShaderClockFeaturesKHR',desc='Structure describing features supported by VK_KHR_shader_clock',type='structs'] -- The slink:VkPhysicalDeviceShaderClockFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderClockFeaturesKHR.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderSubgroupClock]] pname:shaderSubgroupClock indicates whether shaders can: perform code:Subgroup scoped clock reads. * [[features-shaderDeviceClock]] pname:shaderDeviceClock indicates whether shaders can: perform code:Device scoped clock reads. :refpage: VkPhysicalDeviceShaderClockFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderClockFeaturesKHR.adoc[] -- endif::VK_KHR_shader_clock[] ifdef::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[] [open,refpage='VkPhysicalDeviceSamplerYcbcrConversionFeatures',desc='Structure describing {YCbCr} conversion features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR'] -- The sname:VkPhysicalDeviceSamplerYcbcrConversionFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceSamplerYcbcrConversionFeatures.adoc[] ifdef::VK_KHR_sampler_ycbcr_conversion[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR.adoc[] endif::VK_KHR_sampler_ycbcr_conversion[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_sampler_ycbcr_conversion-features[] * [[{anchor-prefix}features-samplerYcbcrConversion]] pname:samplerYcbcrConversion specifies whether the implementation supports <>. If pname:samplerYcbcrConversion is ename:VK_FALSE, sampler {YCbCr} conversion is not supported, and samplers using sampler {YCbCr} conversion must: not be used. // end::VK_KHR_sampler_ycbcr_conversion-features[] :refpage: VkPhysicalDeviceSamplerYcbcrConversionFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceSamplerYcbcrConversionFeatures.adoc[] -- endif::VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion[] ifdef::VK_VERSION_1_1[] [open,refpage='VkPhysicalDeviceProtectedMemoryFeatures',desc='Structure describing protected memory features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceProtectedMemoryFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceProtectedMemoryFeatures.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_protected_memory-features[] * [[{anchor-prefix}features-protectedMemory]] pname:protectedMemory specifies whether <> is supported. // end::VK_KHR_protected_memory-features[] :refpage: VkPhysicalDeviceProtectedMemoryFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceProtectedMemoryFeatures.adoc[] -- endif::VK_VERSION_1_1[] ifdef::VK_EXT_blend_operation_advanced[] [open,refpage='VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT',desc='Structure describing advanced blending features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-advancedBlendCoherentOperations]] pname:advancedBlendCoherentOperations specifies whether blending using <> is guaranteed to execute atomically and in <>. If this is ename:VK_TRUE, ename:VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT is treated the same as ename:VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, and advanced blending needs no additional synchronization over basic blending. If this is ename:VK_FALSE, then memory dependencies are required to guarantee order between two advanced blending operations that occur on the same sample. :refpage: VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.adoc[] -- endif::VK_EXT_blend_operation_advanced[] ifdef::VK_EXT_conditional_rendering[] [open,refpage='VkPhysicalDeviceConditionalRenderingFeaturesEXT',desc='Structure describing if a secondary command buffer can be executed if conditional rendering is active in the primary command buffer',type='structs'] -- The sname:VkPhysicalDeviceConditionalRenderingFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceConditionalRenderingFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-conditionalRendering]] pname:conditionalRendering specifies whether conditional rendering is supported. * [[features-inheritedConditionalRendering]] pname:inheritedConditionalRendering specifies whether a secondary command buffer can: be executed while conditional rendering is active in the primary command buffer. :refpage: VkPhysicalDeviceConditionalRenderingFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceConditionalRenderingFeaturesEXT.adoc[] -- endif::VK_EXT_conditional_rendering[] ifdef::VK_VERSION_1_1[] [open,refpage='VkPhysicalDeviceShaderDrawParametersFeatures',desc='Structure describing shader draw parameter features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceShaderDrawParameterFeatures'] -- The sname:VkPhysicalDeviceShaderDrawParametersFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderDrawParametersFeatures.adoc[] ifndef::VKSC_VERSION_1_0[] include::{generated}/api/structs/VkPhysicalDeviceShaderDrawParameterFeatures.adoc[] endif::VKSC_VERSION_1_0[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_shader_draw_parameters-features[] * [[{anchor-prefix}features-shaderDrawParameters]] pname:shaderDrawParameters specifies whether the implementation supports the SPIR-V code:DrawParameters capability. When this feature is not enabled, shader modules must: not declare the `SPV_KHR_shader_draw_parameters` extension or the code:DrawParameters capability. // end::VK_KHR_shader_draw_parameters-features[] :refpage: VkPhysicalDeviceShaderDrawParametersFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderDrawParametersFeatures.adoc[] -- endif::VK_VERSION_1_1[] ifdef::VK_NV_mesh_shader[] [open,refpage='VkPhysicalDeviceMeshShaderFeaturesNV',desc='Structure describing mesh shading features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceMeshShaderFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMeshShaderFeaturesNV.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. ifdef::VK_EXT_mesh_shader[] * pname:taskShader specifies whether task shaders are supported. endif::VK_EXT_mesh_shader[] ifndef::VK_EXT_mesh_shader[] * [[{vuprefix}features-taskShader]] pname:taskShader specifies whether task shaders are supported. endif::VK_EXT_mesh_shader[] If this feature is not enabled, the ename:VK_SHADER_STAGE_TASK_BIT_NV and ename:VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV enum values must: not be used. ifdef::VK_EXT_mesh_shader[] * pname:meshShader specifies whether mesh shaders are supported. endif::VK_EXT_mesh_shader[] ifndef::VK_EXT_mesh_shader[] * [[{vuprefix}features-meshShader]] pname:meshShader specifies whether mesh shaders are supported. endif::VK_EXT_mesh_shader[] If this feature is not enabled, the ename:VK_SHADER_STAGE_MESH_BIT_NV and ename:VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV enum values must: not be used. :refpage: VkPhysicalDeviceMeshShaderFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMeshShaderFeaturesNV.adoc[] -- endif::VK_NV_mesh_shader[] ifdef::VK_EXT_mesh_shader[] [open,refpage='VkPhysicalDeviceMeshShaderFeaturesEXT',desc='Structure describing mesh shading features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceMeshShaderFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMeshShaderFeaturesEXT.adoc[] * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-taskShader]] pname:taskShader specifies whether task shaders are supported. If this feature is not enabled, the ename:VK_SHADER_STAGE_TASK_BIT_EXT and ename:VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT enum values must: not be used. * [[features-meshShader]] pname:meshShader specifies whether mesh shaders are supported. If this feature is not enabled, the ename:VK_SHADER_STAGE_MESH_BIT_EXT and ename:VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT enum values must: not be used. ifdef::VK_VERSION_1_1,VK_KHR_multiview[] * [[features-multiview-mesh]] pname:multiviewMeshShader specifies whether the implementation supports <> rendering within a render pass, with mesh shaders. If this feature is not enabled, then a pipeline compiled against a subpass with a non-zero view mask must: not include a mesh shader. endif::VK_VERSION_1_1,VK_KHR_multiview[] ifdef::VK_KHR_fragment_shading_rate[] * [[features-primitiveFragmentShadingRate-mesh]] pname:primitiveFragmentShadingRateMeshShader indicates that the implementation supports the <> in mesh shaders. endif::VK_KHR_fragment_shading_rate[] * [[features-meshShaderQueries]] pname:meshShaderQueries indicates that the implementation supports creating query pools using the ename:VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT query type and statistic queries containing the ename:VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT and ename:VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT flags :refpage: VkPhysicalDeviceMeshShaderFeaturesEXT include::{chapters}/features.adoc[tag=features] ifdef::VK_NV_mesh_shader[] The corresponding features of the sname:VkPhysicalDeviceMeshShaderFeaturesNV structure must: match those in sname:VkPhysicalDeviceMeshShaderFeaturesEXT. endif::VK_NV_mesh_shader[] .Valid Usage **** ifdef::VK_VERSION_1_1,VK_KHR_multiview[] * [[VUID-VkPhysicalDeviceMeshShaderFeaturesEXT-multiviewMeshShader-07032]] If pname:multiviewMeshShader is enabled then sname:VkPhysicalDeviceMultiviewFeaturesKHR::pname:multiview must: also be enabled endif::VK_VERSION_1_1,VK_KHR_multiview[] ifdef::VK_KHR_fragment_shading_rate[] * [[VUID-VkPhysicalDeviceMeshShaderFeaturesEXT-primitiveFragmentShadingRateMeshShader-07033]] If pname:primitiveFragmentShadingRateMeshShader is enabled then sname:VkPhysicalDeviceFragmentShadingRateFeaturesKHR::pname:primitiveFragmentShadingRate must: also be enabled endif::VK_KHR_fragment_shading_rate[] **** include::{generated}/validity/structs/VkPhysicalDeviceMeshShaderFeaturesEXT.adoc[] -- endif::VK_EXT_mesh_shader[] ifdef::VK_NV_memory_decompression[] [open,refpage='VkPhysicalDeviceMemoryDecompressionFeaturesNV',desc='Structure describing if memory decompression is supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceMemoryDecompressionFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMemoryDecompressionFeaturesNV.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-memoryDecompression]] pname:memoryDecompression indicates whether memory decompression is supported. :refpage: VkPhysicalDeviceMemoryDecompressionFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMemoryDecompressionFeaturesNV.adoc[] -- endif::VK_NV_memory_decompression[] ifdef::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] [open,refpage='VkPhysicalDeviceDescriptorIndexingFeatures',desc='Structure describing descriptor indexing features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceDescriptorIndexingFeaturesEXT'] -- The sname:VkPhysicalDeviceDescriptorIndexingFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDescriptorIndexingFeatures.adoc[] ifdef::VK_EXT_descriptor_indexing[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceDescriptorIndexingFeaturesEXT.adoc[] endif::VK_EXT_descriptor_indexing[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_EXT_descriptor_indexing-features[] * [[{anchor-prefix}features-shaderInputAttachmentArrayDynamicIndexing]] pname:shaderInputAttachmentArrayDynamicIndexing indicates whether arrays of input attachments 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_INPUT_ATTACHMENT 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:InputAttachmentArrayDynamicIndexing capability. * [[{anchor-prefix}features-shaderUniformTexelBufferArrayDynamicIndexing]] pname:shaderUniformTexelBufferArrayDynamicIndexing indicates whether arrays of uniform texel 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_TEXEL_BUFFER 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:UniformTexelBufferArrayDynamicIndexing capability. * [[{anchor-prefix}features-shaderStorageTexelBufferArrayDynamicIndexing]] pname:shaderStorageTexelBufferArrayDynamicIndexing indicates whether arrays of storage texel 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_TEXEL_BUFFER 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:StorageTexelBufferArrayDynamicIndexing capability. * [[{anchor-prefix}features-shaderUniformBufferArrayNonUniformIndexing]] pname:shaderUniformBufferArrayNonUniformIndexing indicates whether arrays of uniform buffers can: be indexed by non-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: not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can: declare the code:UniformBufferArrayNonUniformIndexing capability. * [[{anchor-prefix}features-shaderSampledImageArrayNonUniformIndexing]] pname:shaderSampledImageArrayNonUniformIndexing indicates whether arrays of samplers or sampled images can: be indexed by non-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: not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can: declare the code:SampledImageArrayNonUniformIndexing capability. * [[{anchor-prefix}features-shaderStorageBufferArrayNonUniformIndexing]] pname:shaderStorageBufferArrayNonUniformIndexing indicates whether arrays of storage buffers can: be indexed by non-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: not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can: declare the code:StorageBufferArrayNonUniformIndexing capability. * [[{anchor-prefix}features-shaderStorageImageArrayNonUniformIndexing]] pname:shaderStorageImageArrayNonUniformIndexing indicates whether arrays of storage images can: be indexed by non-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: not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can: declare the code:StorageImageArrayNonUniformIndexing capability. * [[{anchor-prefix}features-shaderInputAttachmentArrayNonUniformIndexing]] pname:shaderInputAttachmentArrayNonUniformIndexing indicates whether arrays of input attachments can: be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT must: not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can: declare the code:InputAttachmentArrayNonUniformIndexing capability. * [[{anchor-prefix}features-shaderUniformTexelBufferArrayNonUniformIndexing]] pname:shaderUniformTexelBufferArrayNonUniformIndexing indicates whether arrays of uniform texel buffers can: be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must: not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can: declare the code:UniformTexelBufferArrayNonUniformIndexing capability. * [[{anchor-prefix}features-shaderStorageTexelBufferArrayNonUniformIndexing]] pname:shaderStorageTexelBufferArrayNonUniformIndexing indicates whether arrays of storage texel buffers can: be indexed by non-uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must: not be indexed by non-uniform integer expressions when aggregated into arrays in shader code. This also indicates whether shader modules can: declare the code:StorageTexelBufferArrayNonUniformIndexing capability. * [[{anchor-prefix}features-descriptorBindingUniformBufferUpdateAfterBind]] pname:descriptorBindingUniformBufferUpdateAfterBind indicates whether the implementation supports updating uniform buffer descriptors after a set is bound. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must: not be used with ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER. * [[{anchor-prefix}features-descriptorBindingSampledImageUpdateAfterBind]] pname:descriptorBindingSampledImageUpdateAfterBind indicates whether the implementation supports updating sampled image descriptors after a set is bound. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must: not be used with ename:VK_DESCRIPTOR_TYPE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE. * [[{anchor-prefix}features-descriptorBindingStorageImageUpdateAfterBind]] pname:descriptorBindingStorageImageUpdateAfterBind indicates whether the implementation supports updating storage image descriptors after a set is bound. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must: not be used with ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE. * [[{anchor-prefix}features-descriptorBindingStorageBufferUpdateAfterBind]] pname:descriptorBindingStorageBufferUpdateAfterBind indicates whether the implementation supports updating storage buffer descriptors after a set is bound. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must: not be used with ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER. * [[{anchor-prefix}features-descriptorBindingUniformTexelBufferUpdateAfterBind]] pname:descriptorBindingUniformTexelBufferUpdateAfterBind indicates whether the implementation supports updating uniform texel buffer descriptors after a set is bound. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must: not be used with ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER. * [[{anchor-prefix}features-descriptorBindingStorageTexelBufferUpdateAfterBind]] pname:descriptorBindingStorageTexelBufferUpdateAfterBind indicates whether the implementation supports updating storage texel buffer descriptors after a set is bound. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must: not be used with ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER. * [[{anchor-prefix}features-descriptorBindingUpdateUnusedWhilePending]] pname:descriptorBindingUpdateUnusedWhilePending indicates whether the implementation supports updating descriptors while the set is in use. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT must: not be used. * [[{anchor-prefix}features-descriptorBindingPartiallyBound]] pname:descriptorBindingPartiallyBound indicates whether the implementation supports statically using a descriptor set binding in which some descriptors are not valid. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT must: not be used. * [[{anchor-prefix}features-descriptorBindingVariableDescriptorCount]] pname:descriptorBindingVariableDescriptorCount indicates whether the implementation supports descriptor sets with a variable-sized last binding. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT must: not be used. * [[{anchor-prefix}features-runtimeDescriptorArray]] pname:runtimeDescriptorArray indicates whether the implementation supports the SPIR-V code:RuntimeDescriptorArray capability. If this feature is not enabled, descriptors must: not be declared in runtime arrays. // end::VK_EXT_descriptor_indexing-features[] :refpage: VkPhysicalDeviceDescriptorIndexingFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDescriptorIndexingFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] ifdef::VK_NV_copy_memory_indirect[] [open,refpage='VkPhysicalDeviceCopyMemoryIndirectFeaturesNV',desc='Structure describing indirect copy features supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceCopyMemoryIndirectFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-indirectCopy]] pname:indirectCopy indicates whether <> are supported. :refpage: VkPhysicalDeviceCopyMemoryIndirectFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.adoc[] -- endif::VK_NV_copy_memory_indirect[] ifdef::VK_EXT_vertex_attribute_divisor[] [open,refpage='VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT',desc='Structure describing if fetching of vertex attribute may be repeated for instanced rendering',type='structs'] -- The sname:VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-vertexAttributeInstanceRateDivisor]] pname:vertexAttributeInstanceRateDivisor specifies whether vertex attribute fetching may be repeated in case of instanced rendering. * [[features-vertexAttributeInstanceRateZeroDivisor]] pname:vertexAttributeInstanceRateZeroDivisor specifies whether a zero value for sname:VkVertexInputBindingDivisorDescriptionEXT::pname:divisor is supported. :refpage: VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.adoc[] -- endif::VK_EXT_vertex_attribute_divisor[] ifdef::VK_EXT_astc_decode_mode[] [open,refpage='VkPhysicalDeviceASTCDecodeFeaturesEXT',desc='Structure describing ASTC decode mode features',type='structs'] -- The sname:VkPhysicalDeviceASTCDecodeFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceASTCDecodeFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-astc-decodeModeSharedExponent]] pname:decodeModeSharedExponent indicates whether the implementation supports decoding ASTC compressed formats to ename:VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 internal precision. :refpage: VkPhysicalDeviceASTCDecodeFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceASTCDecodeFeaturesEXT.adoc[] -- endif::VK_EXT_astc_decode_mode[] ifdef::VK_EXT_transform_feedback[] [open,refpage='VkPhysicalDeviceTransformFeedbackFeaturesEXT',desc='Structure describing transform feedback features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceTransformFeedbackFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceTransformFeedbackFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-transformFeedback]] pname:transformFeedback indicates whether the implementation supports transform feedback and shader modules can: declare the code:TransformFeedback capability. * [[features-geometryStreams]] pname:geometryStreams indicates whether the implementation supports the code:GeometryStreams SPIR-V capability. :refpage: VkPhysicalDeviceTransformFeedbackFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceTransformFeedbackFeaturesEXT.adoc[] -- endif::VK_EXT_transform_feedback[] ifdef::VK_VERSION_1_2,VK_KHR_vulkan_memory_model[] [open,refpage='VkPhysicalDeviceVulkanMemoryModelFeatures',desc='Structure describing features supported by the memory model',type='structs'] -- The sname:VkPhysicalDeviceVulkanMemoryModelFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceVulkanMemoryModelFeatures.adoc[] ifdef::VK_KHR_vulkan_memory_model[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceVulkanMemoryModelFeaturesKHR.adoc[] endif::VK_KHR_vulkan_memory_model[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_vulkan_memory_model-features[] * [[{anchor-prefix}features-vulkanMemoryModel]] pname:vulkanMemoryModel indicates whether shader modules can: declare the code:VulkanMemoryModel capability. * [[{anchor-prefix}features-vulkanMemoryModelDeviceScope]] pname:vulkanMemoryModelDeviceScope indicates whether the Vulkan Memory Model can use code:Device scope synchronization. This also indicates whether shader modules can: declare the code:VulkanMemoryModelDeviceScope capability. * [[{anchor-prefix}features-vulkanMemoryModelAvailabilityVisibilityChains]] pname:vulkanMemoryModelAvailabilityVisibilityChains indicates whether the Vulkan Memory Model can use <> with more than one element. // end::VK_KHR_vulkan_memory_model-features[] :refpage: VkPhysicalDeviceVulkanMemoryModelFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceVulkanMemoryModelFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_vulkan_memory_model[] ifdef::VK_VERSION_1_3,VK_EXT_inline_uniform_block[] [open,refpage='VkPhysicalDeviceInlineUniformBlockFeatures',desc='Structure describing inline uniform block features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceInlineUniformBlockFeaturesEXT'] -- The sname:VkPhysicalDeviceInlineUniformBlockFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceInlineUniformBlockFeatures.adoc[] ifdef::VK_EXT_inline_uniform_block[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceInlineUniformBlockFeaturesEXT.adoc[] endif::VK_EXT_inline_uniform_block[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_EXT_inline_uniform_block-features[] * [[{anchor-prefix}features-inlineUniformBlock]] pname:inlineUniformBlock indicates whether the implementation supports inline uniform block descriptors. If this feature is not enabled, ename:VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK must: not be used. * [[{anchor-prefix}features-descriptorBindingInlineUniformBlockUpdateAfterBind]] pname:descriptorBindingInlineUniformBlockUpdateAfterBind ifndef::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] is ename:VK_FALSE and reserved for future use. endif::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] ifdef::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] indicates whether the implementation supports updating inline uniform block descriptors after a set is bound. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must: not be used with ename:VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK. endif::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] // end::VK_EXT_inline_uniform_block-features[] :refpage: VkPhysicalDeviceInlineUniformBlockFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceInlineUniformBlockFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_EXT_inline_uniform_block[] ifdef::VK_NV_representative_fragment_test[] [open,refpage='VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV',desc='Structure describing the representative fragment test features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-representativeFragmentTest]] pname:representativeFragmentTest indicates whether the implementation supports the representative fragment test. See <>. :refpage: VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.adoc[] -- endif::VK_NV_representative_fragment_test[] ifdef::VK_NV_scissor_exclusive[] [open,refpage='VkPhysicalDeviceExclusiveScissorFeaturesNV',desc='Structure describing exclusive scissor features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceExclusiveScissorFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExclusiveScissorFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-exclusiveScissor]] pname:exclusiveScissor indicates that the implementation supports the exclusive scissor test. See <> for more information. :refpage: VkPhysicalDeviceExclusiveScissorFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExclusiveScissorFeaturesNV.adoc[] -- endif::VK_NV_scissor_exclusive[] ifdef::VK_NV_corner_sampled_image[] [open,refpage='VkPhysicalDeviceCornerSampledImageFeaturesNV',desc='Structure describing corner sampled image features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceCornerSampledImageFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCornerSampledImageFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-cornersampledimage]] pname:cornerSampledImage specifies whether images can be created with a slink:VkImageCreateInfo::pname:flags containing ename:VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV. See <>. :refpage: VkPhysicalDeviceCornerSampledImageFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCornerSampledImageFeaturesNV.adoc[] -- endif::VK_NV_corner_sampled_image[] ifdef::VK_NV_compute_shader_derivatives[] [open,refpage='VkPhysicalDeviceComputeShaderDerivativesFeaturesNV',desc='Structure describing compute shader derivative features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceComputeShaderDerivativesFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-computeDerivativeGroupQuads]] pname:computeDerivativeGroupQuads indicates that the implementation supports the code:ComputeDerivativeGroupQuadsNV SPIR-V capability. * [[features-computeDerivativeGroupLinear]] pname:computeDerivativeGroupLinear indicates that the implementation supports the code:ComputeDerivativeGroupLinearNV SPIR-V capability. See <> for more information. :refpage: VkPhysicalDeviceComputeShaderDerivativesFeaturesNVfeatures. include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.adoc[] -- endif::VK_NV_compute_shader_derivatives[] ifdef::VK_KHR_fragment_shader_barycentric[] [open,refpage='VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR',desc='Structure describing barycentric support in fragment shaders that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.adoc[] ifdef::VK_NV_fragment_shader_barycentric[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.adoc[] endif::VK_NV_fragment_shader_barycentric[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-fragmentShaderBarycentric]] pname:fragmentShaderBarycentric indicates that the implementation supports the code:BaryCoordKHR and code:BaryCoordNoPerspKHR SPIR-V fragment shader built-ins and supports the code:PerVertexKHR SPIR-V decoration on fragment shader input variables. See <> for more information. :refpage: VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.adoc[] -- endif::VK_KHR_fragment_shader_barycentric[] ifdef::VK_NV_shader_image_footprint[] [open,refpage='VkPhysicalDeviceShaderImageFootprintFeaturesNV',desc='Structure describing shader image footprint features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderImageFootprintFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderImageFootprintFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-imageFootprint]] pname:imageFootprint specifies whether the implementation supports the code:ImageFootprintNV SPIR-V capability. See <> for more information. :refpage: VkPhysicalDeviceShaderImageFootprintFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderImageFootprintFeaturesNV.adoc[] -- endif::VK_NV_shader_image_footprint[] ifdef::VK_NV_shading_rate_image[] [open,refpage='VkPhysicalDeviceShadingRateImageFeaturesNV',desc='Structure describing shading rate image features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceShadingRateImageFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShadingRateImageFeaturesNV.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shadingRateImage]] pname:shadingRateImage indicates that the implementation supports the use of a shading rate image to derive an effective shading rate for fragment processing. It also indicates that the implementation supports the code:ShadingRateNV SPIR-V execution mode. * [[features-shadingRateCoarseSampleOrder]] pname:shadingRateCoarseSampleOrder indicates that the implementation supports a user-configurable ordering of coverage samples in fragments larger than one pixel. See <> for more information. :refpage: VkPhysicalDeviceShadingRateImageFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShadingRateImageFeaturesNV.adoc[] -- endif::VK_NV_shading_rate_image[] ifdef::VK_EXT_fragment_density_map[] [open,refpage='VkPhysicalDeviceFragmentDensityMapFeaturesEXT',desc='Structure describing fragment density map features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceFragmentDensityMapFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-fragmentDensityMap]] pname:fragmentDensityMap specifies whether the implementation supports render passes with a fragment density map attachment. If this feature is not enabled and the pname:pNext chain of slink:VkRenderPassCreateInfo includes a slink:VkRenderPassFragmentDensityMapCreateInfoEXT structure, pname:fragmentDensityMapAttachment must: be ename:VK_ATTACHMENT_UNUSED. * [[features-fragmentDensityMapDynamic]] pname:fragmentDensityMapDynamic specifies whether the implementation supports dynamic fragment density map image views. If this feature is not enabled, ename:VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT must: not be included in slink:VkImageViewCreateInfo::pname:flags. * [[features-fragmentDensityMapNonSubsampledImages]] pname:fragmentDensityMapNonSubsampledImages specifies whether the implementation supports regular non-subsampled image attachments with fragment density map render passes. If this feature is not enabled, render passes with a <> must: only have <> bound. :refpage: VkPhysicalDeviceFragmentDensityMapFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.adoc[] -- ifdef::VK_EXT_fragment_density_map2[] [open,refpage='VkPhysicalDeviceFragmentDensityMap2FeaturesEXT',desc='Structure describing additional fragment density map features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceFragmentDensityMap2FeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-fragmentDensityMapDeferred]] pname:fragmentDensityMapDeferred specifies whether the implementation supports deferred reads of fragment density map image views. If this feature is not enabled, ename:VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT must: not be included in sname:VkImageViewCreateInfo::pname:flags. :refpage: VkPhysicalDeviceFragmentDensityMap2FeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.adoc[] -- endif::VK_EXT_fragment_density_map2[] ifdef::VK_QCOM_fragment_density_map_offset[] [open,refpage='VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM',desc='Structure describing fragment density map offset features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-fragmentDensityMapOffsets]] pname:fragmentDensityMapOffsets specifies whether the implementation supports <> :refpage: VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.adoc[] -- endif::VK_QCOM_fragment_density_map_offset[] endif::VK_EXT_fragment_density_map[] ifdef::VK_HUAWEI_invocation_mask[] [open,refpage='VkPhysicalDeviceInvocationMaskFeaturesHUAWEI',desc='Structure describing invocation mask features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceInvocationMaskFeaturesHUAWEI structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-invocationMask]] pname:invocationMask indicates that the implementation supports the use of an invocation mask image to optimize the ray dispatch. :refpage: VkPhysicalDeviceInvocationMaskFeaturesHUAWEI include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.adoc[] -- endif::VK_HUAWEI_invocation_mask[] ifdef::VK_VERSION_1_2,VK_EXT_scalar_block_layout[] [open,refpage='VkPhysicalDeviceScalarBlockLayoutFeatures',desc='Structure indicating support for scalar block layouts',type='structs',alias='VkPhysicalDeviceScalarBlockLayoutFeaturesEXT'] -- The sname:VkPhysicalDeviceScalarBlockLayoutFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceScalarBlockLayoutFeatures.adoc[] ifdef::VK_EXT_scalar_block_layout[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceScalarBlockLayoutFeaturesEXT.adoc[] endif::VK_EXT_scalar_block_layout[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_EXT_scalar_block_layout-features[] * [[{anchor-prefix}features-scalarBlockLayout]] pname:scalarBlockLayout indicates that the implementation supports the layout of resource blocks in shaders using <>. // end::VK_EXT_scalar_block_layout-features[] :refpage: VkPhysicalDeviceScalarBlockLayoutFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceScalarBlockLayoutFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_EXT_scalar_block_layout[] ifdef::VK_VERSION_1_2,VK_KHR_uniform_buffer_standard_layout[] [open,refpage='VkPhysicalDeviceUniformBufferStandardLayoutFeatures',desc='Structure indicating support for std430-like packing in uniform buffers',type='structs',alias='VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR'] -- The sname:VkPhysicalDeviceUniformBufferStandardLayoutFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.adoc[] ifdef::VK_KHR_uniform_buffer_standard_layout[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR.adoc[] endif::VK_KHR_uniform_buffer_standard_layout[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_uniform_buffer_standard_layout-features[] * [[{anchor-prefix}features-uniformBufferStandardLayout]] pname:uniformBufferStandardLayout indicates that the implementation supports the same layouts for uniform buffers as for storage and other kinds of buffers. See <>. // end::VK_KHR_uniform_buffer_standard_layout-features[] :refpage: VkPhysicalDeviceUniformBufferStandardLayoutFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_uniform_buffer_standard_layout[] ifdef::VK_EXT_depth_clip_enable[] [open,refpage='VkPhysicalDeviceDepthClipEnableFeaturesEXT',desc='Structure indicating support for explicit enable of depth clip',type='structs'] -- The sname:VkPhysicalDeviceDepthClipEnableFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDepthClipEnableFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-depthClipEnable]] pname:depthClipEnable indicates that the implementation supports setting the depth clipping operation explicitly via the slink:VkPipelineRasterizationDepthClipStateCreateInfoEXT pipeline state. Otherwise depth clipping is only enabled when slink:VkPipelineRasterizationStateCreateInfo::pname:depthClampEnable is set to ename:VK_FALSE. :refpage: VkPhysicalDeviceDepthClipEnableFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDepthClipEnableFeaturesEXT.adoc[] -- endif::VK_EXT_depth_clip_enable[] ifdef::VK_EXT_memory_priority[] [open,refpage='VkPhysicalDeviceMemoryPriorityFeaturesEXT',desc='Structure describing memory priority features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceMemoryPriorityFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMemoryPriorityFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-memoryPriority]] pname:memoryPriority indicates that the implementation supports memory priorities specified at memory allocation time via slink:VkMemoryPriorityAllocateInfoEXT. :refpage: VkPhysicalDeviceMemoryPriorityFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMemoryPriorityFeaturesEXT.adoc[] -- endif::VK_EXT_memory_priority[] ifdef::VK_VERSION_1_2,VK_KHR_buffer_device_address[] [open,refpage='VkPhysicalDeviceBufferDeviceAddressFeatures',desc='Structure describing buffer address features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceBufferDeviceAddressFeaturesKHR'] -- The sname:VkPhysicalDeviceBufferDeviceAddressFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceBufferDeviceAddressFeatures.adoc[] ifdef::VK_KHR_buffer_device_address[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceBufferDeviceAddressFeaturesKHR.adoc[] endif::VK_KHR_buffer_device_address[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_EXT_buffer_device_address-features[] * [[{anchor-prefix}features-bufferDeviceAddress]] pname:bufferDeviceAddress indicates that the implementation supports accessing buffer memory in shaders as storage buffers via an address queried from flink:vkGetBufferDeviceAddress. * [[{anchor-prefix}features-bufferDeviceAddressCaptureReplay]] pname:bufferDeviceAddressCaptureReplay indicates that the implementation supports saving and reusing buffer and device addresses, e.g. for trace capture and replay. * [[{anchor-prefix}features-bufferDeviceAddressMultiDevice]] pname:bufferDeviceAddressMultiDevice indicates that the implementation supports the pname:bufferDeviceAddress ifndef::VK_KHR_ray_tracing_pipeline+VK_KHR_ray_query[feature] ifdef::VK_KHR_ray_tracing_pipeline[] ifndef::VK_KHR_ray_query[] and pname:rayTracingPipeline features endif::VK_KHR_ray_query[] ifdef::VK_KHR_ray_query[] , pname:rayTracingPipeline and pname:rayQuery features endif::VK_KHR_ray_query[] endif::VK_KHR_ray_tracing_pipeline[] ifndef::VK_KHR_ray_tracing_pipeline[] ifdef::VK_KHR_ray_query[] and pname:rayQuery features endif::VK_KHR_ray_query[] endif::VK_KHR_ray_tracing_pipeline[] for logical devices created with multiple physical devices. If this feature is not supported, buffer ifdef::VK_KHR_acceleration_structure[] and acceleration structure endif::VK_KHR_acceleration_structure[] addresses must: not be queried on a logical device created with more than one physical device. // end::VK_EXT_buffer_device_address-features[] [NOTE] .Note ==== pname:bufferDeviceAddressMultiDevice exists to allow certain legacy platforms to be able to support pname:bufferDeviceAddress without needing to support shared GPU virtual addresses for multi-device configurations. ==== See flink:vkGetBufferDeviceAddress for more information. :refpage: VkPhysicalDeviceBufferDeviceAddressFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceBufferDeviceAddressFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_buffer_device_address[] ifdef::VK_EXT_buffer_device_address[] [open,refpage='VkPhysicalDeviceBufferDeviceAddressFeaturesEXT',desc='Structure describing buffer address features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceBufferAddressFeaturesEXT'] -- The sname:VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.adoc[] include::{generated}/api/structs/VkPhysicalDeviceBufferAddressFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-bufferDeviceAddressEXT]] pname:bufferDeviceAddress indicates that the implementation supports accessing buffer memory in shaders as storage buffers via an address queried from flink:vkGetBufferDeviceAddressEXT. * [[features-bufferDeviceAddressCaptureReplayEXT]] pname:bufferDeviceAddressCaptureReplay indicates that the implementation supports saving and reusing buffer addresses, e.g. for trace capture and replay. * [[features-bufferDeviceAddressMultiDeviceEXT]] pname:bufferDeviceAddressMultiDevice indicates that the implementation supports the pname:bufferDeviceAddress feature for logical devices created with multiple physical devices. If this feature is not supported, buffer addresses must: not be queried on a logical device created with more than one physical device. :refpage: VkPhysicalDeviceBufferDeviceAddressFeaturesEXT include::{chapters}/features.adoc[tag=features] ifdef::VK_VERSION_1_2,VK_KHR_buffer_device_address[] [NOTE] .Note ==== The sname:VkPhysicalDeviceBufferDeviceAddressFeaturesEXT structure has the same members as the sname:VkPhysicalDeviceBufferDeviceAddressFeatures structure, but the functionality indicated by the members is expressed differently. The features indicated by the sname:VkPhysicalDeviceBufferDeviceAddressFeatures structure requires additional flags to be passed at memory allocation time, and the capture and replay mechanism is built around opaque capture addresses for buffer and memory objects. ==== endif::VK_VERSION_1_2,VK_KHR_buffer_device_address[] include::{generated}/validity/structs/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.adoc[] -- endif::VK_EXT_buffer_device_address[] ifdef::VK_NV_dedicated_allocation_image_aliasing[] [open,refpage='VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV',desc='Structure describing dedicated allocation image aliasing features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-dedicatedAllocationImageAliasing]] pname:dedicatedAllocationImageAliasing indicates that the implementation supports aliasing of compatible image objects on a dedicated allocation. :refpage: VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.adoc[] -- endif::VK_NV_dedicated_allocation_image_aliasing[] ifdef::VK_VERSION_1_2,VK_KHR_imageless_framebuffer[] [open,refpage='VkPhysicalDeviceImagelessFramebufferFeatures',desc='Structure indicating support for imageless framebuffers',type='structs',alias='VkPhysicalDeviceImagelessFramebufferFeaturesKHR'] -- The sname:VkPhysicalDeviceImagelessFramebufferFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceImagelessFramebufferFeatures.adoc[] ifdef::VK_KHR_imageless_framebuffer[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceImagelessFramebufferFeaturesKHR.adoc[] endif::VK_KHR_imageless_framebuffer[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_imageless_framebuffer-features[] * [[{anchor-prefix}features-imagelessFramebuffer]] pname:imagelessFramebuffer indicates that the implementation supports specifying the image view for attachments at render pass begin time via slink:VkRenderPassAttachmentBeginInfo. // end::VK_KHR_imageless_framebuffer-features[] :refpage: VkPhysicalDeviceImagelessFramebufferFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceImagelessFramebufferFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_imageless_framebuffer[] ifdef::VK_EXT_fragment_shader_interlock[] [open,refpage='VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT',desc='Structure describing fragment shader interlock features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-fragmentShaderSampleInterlock]] pname:fragmentShaderSampleInterlock indicates that the implementation supports the code:FragmentShaderSampleInterlockEXT SPIR-V capability. * [[features-fragmentShaderPixelInterlock]] pname:fragmentShaderPixelInterlock indicates that the implementation supports the code:FragmentShaderPixelInterlockEXT SPIR-V capability. * [[features-fragmentShaderShadingRateInterlock]] pname:fragmentShaderShadingRateInterlock indicates that the implementation supports the code:FragmentShaderShadingRateInterlockEXT SPIR-V capability. :refpage: VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.adoc[] -- endif::VK_EXT_fragment_shader_interlock[] ifdef::VK_NV_cooperative_matrix[] [open,refpage='VkPhysicalDeviceCooperativeMatrixFeaturesNV',desc='Structure describing cooperative matrix features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceCooperativeMatrixFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCooperativeMatrixFeaturesNV.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-cooperativeMatrix-NV]] pname:cooperativeMatrix indicates that the implementation supports the code:CooperativeMatrixNV SPIR-V capability. * [[features-cooperativeMatrixRobustBufferAccess-NV]] pname:cooperativeMatrixRobustBufferAccess indicates that the implementation supports robust buffer access for SPIR-V code:OpCooperativeMatrixLoadNV and code:OpCooperativeMatrixStoreNV instructions. :refpage: VkPhysicalDeviceCooperativeMatrixFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCooperativeMatrixFeaturesNV.adoc[] -- endif::VK_NV_cooperative_matrix[] ifdef::VK_KHR_cooperative_matrix[] [open,refpage='VkPhysicalDeviceCooperativeMatrixFeaturesKHR',desc='Structure describing cooperative matrix features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceCooperativeMatrixFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCooperativeMatrixFeaturesKHR.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-cooperativeMatrix]] pname:cooperativeMatrix indicates that the implementation supports the code:CooperativeMatrixKHR SPIR-V capability. * [[features-cooperativeMatrixRobustBufferAccess]] pname:cooperativeMatrixRobustBufferAccess indicates that the implementation supports robust buffer access for SPIR-V code:OpCooperativeMatrixLoadKHR and code:OpCooperativeMatrixStoreKHR instructions. :refpage: VkPhysicalDeviceCooperativeMatrixFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCooperativeMatrixFeaturesKHR.adoc[] -- endif::VK_KHR_cooperative_matrix[] ifdef::VK_EXT_ycbcr_image_arrays[] [open,refpage='VkPhysicalDeviceYcbcrImageArraysFeaturesEXT',desc='Structure describing extended {YCbCr} image creation features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceYcbcrImageArraysFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-ycbcrImageArrays]] pname:ycbcrImageArrays indicates that the implementation supports creating images with a format that requires <> and has multiple array layers. :refpage: VkPhysicalDeviceYcbcrImageArraysFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.adoc[] -- endif::VK_EXT_ycbcr_image_arrays[] ifdef::VK_VERSION_1_1[] ifdef::VK_VERSION_1_2,VK_KHR_shader_subgroup_extended_types[] [open,refpage='VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures',desc='Structure describing the extended types subgroups support feature for an implementation',type='structs',alias='VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR'] -- The sname:VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.adoc[] ifdef::VK_KHR_shader_subgroup_extended_types[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR.adoc[] endif::VK_KHR_shader_subgroup_extended_types[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_shader_subgroup_extended_types-features[] * [[{anchor-prefix}features-subgroup-extended-types]] pname:shaderSubgroupExtendedTypes is a boolean specifying whether subgroup operations can use 8-bit integer, 16-bit integer, 64-bit integer, 16-bit floating-point, and vectors of these types in <> with <>, if the implementation supports the types. // end::VK_KHR_shader_subgroup_extended_types-features[] :refpage: VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_shader_subgroup_extended_types[] endif::VK_VERSION_1_1[] ifdef::VK_VERSION_1_2,VK_EXT_host_query_reset[] [open,refpage='VkPhysicalDeviceHostQueryResetFeatures',desc='Structure describing whether queries can be reset from the host',type='structs',alias='VkPhysicalDeviceHostQueryResetFeaturesEXT'] -- The sname:VkPhysicalDeviceHostQueryResetFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceHostQueryResetFeatures.adoc[] ifdef::VK_EXT_host_query_reset[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceHostQueryResetFeaturesEXT.adoc[] endif::VK_EXT_host_query_reset[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_EXT_host_query_reset-features[] * [[{anchor-prefix}features-hostQueryReset]] pname:hostQueryReset indicates that the implementation supports resetting queries from the host with flink:vkResetQueryPool. // end::VK_EXT_host_query_reset-features[] :refpage: VkPhysicalDeviceHostQueryResetFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceHostQueryResetFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_EXT_host_query_reset[] ifdef::VK_INTEL_shader_integer_functions2[] [open,refpage='VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL',desc='Structure describing shader integer functions that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderIntegerFunctions2]] pname:shaderIntegerFunctions2 indicates that the implementation supports the code:IntegerFunctions2INTEL SPIR-V capability. :refpage: VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTELfeatures. include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.adoc[] -- endif::VK_INTEL_shader_integer_functions2[] ifdef::VK_NV_coverage_reduction_mode[] [open,refpage='VkPhysicalDeviceCoverageReductionModeFeaturesNV',desc='Structure describing the coverage reduction mode features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceCoverageReductionModeFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCoverageReductionModeFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-coverageReductionMode]] pname:coverageReductionMode indicates whether the implementation supports coverage reduction modes. See <>. :refpage: VkPhysicalDeviceCoverageReductionModeFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCoverageReductionModeFeaturesNV.adoc[] -- endif::VK_NV_coverage_reduction_mode[] ifdef::VK_VERSION_1_2,VK_KHR_timeline_semaphore[] [open,refpage='VkPhysicalDeviceTimelineSemaphoreFeatures',desc='Structure describing timeline semaphore features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceTimelineSemaphoreFeaturesKHR'] -- The sname:VkPhysicalDeviceTimelineSemaphoreFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceTimelineSemaphoreFeatures.adoc[] ifdef::VK_KHR_timeline_semaphore[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceTimelineSemaphoreFeaturesKHR.adoc[] endif::VK_KHR_timeline_semaphore[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_timeline_semaphore-features[] * [[{anchor-prefix}features-timelineSemaphore]] pname:timelineSemaphore indicates whether semaphores created with a elink:VkSemaphoreType of ename:VK_SEMAPHORE_TYPE_TIMELINE are supported. // end::VK_KHR_timeline_semaphore-features[] :refpage: VkPhysicalDeviceTimelineSemaphoreFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceTimelineSemaphoreFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_timeline_semaphore[] ifdef::VK_NV_external_sci_sync[] [open,refpage='VkPhysicalDeviceExternalSciSyncFeaturesNV',desc='Structure describing SciSync features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceExternalSciSyncFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExternalSciSyncFeaturesNV.adoc[] The members of the sname:VkPhysicalDeviceExternalSciSyncFeaturesNV structure describe the following features: * [[features-sciSyncFence]] pname:sciSyncFence indicates whether external fences created with a handle type of ename:VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV and ename:VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV are supported for import and/or export. * [[features-sciSyncSemaphore]] pname:sciSyncSemaphore indicates whether external semaphores created with a handle type of ename:VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV are supported for import and/or export. * [[features-sciSyncImport]] pname:sciSyncImport indicates whether stext:NvSciSyncObj import functionality is supported. If pname:sciSyncImport is set to ename:VK_TRUE, slink:VkFence and/or slink:VkSemaphore support importing stext:NvSciSyncObj from applications. In this case, the application is responsible for the resource management of the stext:NvSciSyncObj. * [[features-sciSyncExport]] pname:sciSyncExport indicates whether stext:NvSciSyncObj export functionality is supported. If pname:sciSyncExport is set to ename:VK_TRUE, slink:VkFence and/or slink:VkSemaphore support exporting stext:NvSciSyncObj created by the driver to applications. In this case, the driver is responsible for the resource management of the stext:NvSciSyncObj. [[features-externalscisync-table]] .Functionality supported for NvSciSync features |===== | Features | pname:sciSyncImport | pname:sciSyncExport | Always supported^1^ | pname:sciSyncFence | flink:vkImportFenceSciSyncFenceNV, flink:vkImportFenceSciSyncObjNV | slink:VkExportFenceSciSyncInfoNV | flink:vkGetFenceSciSyncFenceNV, flink:vkGetFenceSciSyncObjNV, flink:vkGetPhysicalDeviceSciSyncAttributesNV (with ename:VK_SCI_SYNC_PRIMITIVE_TYPE_FENCE_NV) | pname:sciSyncSemaphore | flink:vkImportSemaphoreSciSyncObjNV | slink:VkExportSemaphoreSciSyncInfoNV | flink:vkGetSemaphoreSciSyncObjNV, flink:vkGetPhysicalDeviceSciSyncAttributesNV (with ename:VK_SCI_SYNC_PRIMITIVE_TYPE_SEMAPHORE_NV) |===== 1:: Functionality in this column is always available. The <> table summarizes the functionality enabled by the sname:VkPhysicalDeviceExternalSciSyncFeaturesNV structure. There are two orthogonal pieces of functionality: fence and semaphore support; import and export support. Each entry in the body of the table summarizes the functionality that can: be used when the given features are supported and enabled. This summarizes Valid Usage statements that are added elsewhere in this specification. :refpage: VkPhysicalDeviceExternalSciSyncFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExternalSciSyncFeaturesNV.adoc[] -- endif::VK_NV_external_sci_sync[] ifdef::VK_NV_external_sci_sync2[] [open,refpage='VkPhysicalDeviceExternalSciSync2FeaturesNV',desc='Structure describing SciSync features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceExternalSciSync2FeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExternalSciSync2FeaturesNV.adoc[] The members of the sname:VkPhysicalDeviceExternalSciSync2FeaturesNV structure describe the following features: * [[features-sciSyncFence2]] pname:sciSyncFence indicates whether external fences created with a handle type of ename:VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV and ename:VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV are supported for import and/or export. * [[features-sciSyncSemaphore2]] pname:sciSyncSemaphore2 indicates whether semaphore SciSync pools are supported and semaphores can be created from stext:NvSciSyncObj via slink:VkSemaphoreSciSyncPoolNV objects. In this case, the application is responsible for the resource management of the stext:NvSciSyncObj. * [[features-sciSyncImport2]] pname:sciSyncImport indicates whether stext:NvSciSyncObj import functionality is supported. If pname:sciSyncImport is set to ename:VK_TRUE, slink:VkFence and/or slink:VkSemaphore support importing stext:NvSciSyncObj from applications. In this case, the application is responsible for the resource management of the stext:NvSciSyncObj. * [[features-sciSyncExport2]] pname:sciSyncExport indicates whether stext:NvSciSyncObj export functionality is supported. If pname:sciSyncExport is set to ename:VK_TRUE, slink:VkFence supports exporting stext:NvSciSyncObj created by the driver to applications. In this case, the driver is responsible for the resource management of the stext:NvSciSyncObj. [[features-externalscisync2-table]] .Functionality supported for NvSciSync features |===== | Features | pname:sciSyncImport | pname:sciSyncExport | Always supported^1^ | pname:sciSyncFence | flink:vkImportFenceSciSyncFenceNV, flink:vkImportFenceSciSyncObjNV | slink:VkExportFenceSciSyncInfoNV | flink:vkGetFenceSciSyncFenceNV, flink:vkGetFenceSciSyncObjNV, flink:vkGetPhysicalDeviceSciSyncAttributesNV (with ename:VK_SCI_SYNC_PRIMITIVE_TYPE_FENCE_NV) | pname:sciSyncSemaphore2 | flink:vkCreateSemaphoreSciSyncPoolNV, slink:VkSemaphoreSciSyncCreateInfoNV | n/a | flink:vkGetPhysicalDeviceSciSyncAttributesNV (with ename:VK_SCI_SYNC_PRIMITIVE_TYPE_SEMAPHORE_NV) |===== 1:: Functionality in this column is always available. The <> table summarizes the functionality enabled by the sname:VkPhysicalDeviceExternalSciSync2FeaturesNV structure. There are two orthogonal pieces of functionality: fence and semaphore support; import and export support. Each entry in the body of the table summarizes the functionality that can: be used when the given features are supported and enabled. This summarizes Valid Usage statements that are added elsewhere in this specification. :refpage: VkPhysicalDeviceExternalSciSync2FeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExternalSciSync2FeaturesNV.adoc[] -- endif::VK_NV_external_sci_sync2[] ifdef::VK_NV_external_memory_sci_buf[] [open,refpage='VkPhysicalDeviceExternalMemorySciBufFeaturesNV',desc='Structure describing NvSciBuf features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceExternalMemorySciBufFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExternalMemorySciBufFeaturesNV.adoc[] include::{generated}/api/structs/VkPhysicalDeviceExternalSciBufFeaturesNV.adoc[] The members of the sname:VkPhysicalDeviceExternalMemorySciBufFeaturesNV structure describe the following features: * [[features-sciBufImport]] pname:sciBufImport indicates whether stext:NvSciBufObj import functionality is supported. If pname:sciBufImport is set to ename:VK_TRUE, slink:VkDeviceMemory supports importing stext:NvSciBufObj from applications. In this case, the application is responsible for the resource management of the stext:NvSciBufObj. * [[features-sciBufExport]] pname:sciBufExport indicates whether stext:NvSciBufObj export functionality is supported. If pname:sciBufExport is set to ename:VK_TRUE, slink:VkDeviceMemory supports exporting stext:NvSciBufObj created by the driver to applications. In this case, the driver is responsible for the resource management of the stext:NvSciBufObj. [[features-externalscibuf-table]] .Functionality supported for NvSciBuf features |===== | Features | Functionality | pname:sciBufImport | slink:VkImportMemorySciBufInfoNV, flink:vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV | pname:sciBufExport | slink:VkExportMemorySciBufInfoNV | Always supported^1^ | flink:vkGetPhysicalDeviceSciBufAttributesNV, flink:vkGetMemorySciBufNV, |===== 1:: Functionality in this row is always available. The <> table summarizes the functionality enabled by the sname:VkPhysicalDeviceExternalMemorySciBufFeaturesNV structure. Each entry in the body of the table summarizes the functionality that can: be used when the given features are supported and enabled. This summarizes Valid Usage statements that are added elsewhere in this specification. :refpage: VkPhysicalDeviceExternalMemorySciBufFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExternalMemorySciBufFeaturesNV.adoc[] -- endif::VK_NV_external_memory_sci_buf[] ifdef::VK_QNX_external_memory_screen_buffer[] [open,refpage='VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX',desc='Structure describing QNX Screen Buffer features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.adoc[] The members of the sname:VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX structure describe the following features: * [[features-screenBufferImport]] pname:screenBufferImport indicates whether QNX Screen buffer import functionality is supported. If pname:screenBufferImport is set to ename:VK_TRUE, slink:VkDeviceMemory supports importing code:_screen_buffer from applications. In this case, the application is responsible for the resource management of the code:_screen_buffer. [[features-externalscreenbuffer-table]] .Functionality supported for QNX Screen Buffer features |===== | Features | Functionality | pname:screenBufferImport | slink:VkImportScreenBufferInfoQNX | Always supported^1^ | flink:vkGetScreenBufferPropertiesQNX, slink:VkScreenBufferPropertiesQNX, slink:VkScreenBufferFormatPropertiesQNX, slink:VkExternalFormatQNX |===== 1:: Functionality in this row is always available. The <> table summarizes the functionality enabled by the sname:VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX structure. Each entry in the body of the table summarizes the functionality that can: be used when the given features are supported and enabled. This summarizes Valid Usage statements that are added elsewhere in this specification. :refpage: VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.adoc[] -- endif::VK_QNX_external_memory_screen_buffer[] ifdef::VK_EXT_index_type_uint8[] [open,refpage='VkPhysicalDeviceIndexTypeUint8FeaturesEXT',desc='Structure describing whether uint8 index type can be used',type='structs'] -- The sname:VkPhysicalDeviceIndexTypeUint8FeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-indexTypeUint8]] pname:indexTypeUint8 indicates that ename:VK_INDEX_TYPE_UINT8_EXT can be used with ifdef::VK_KHR_maintenance5[flink:vkCmdBindIndexBuffer2KHR and] flink:vkCmdBindIndexBuffer. :refpage: VkPhysicalDeviceIndexTypeUint8FeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.adoc[] -- endif::VK_EXT_index_type_uint8[] ifdef::VK_EXT_primitive_topology_list_restart[] [open,refpage='VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT',desc='Structure describing whether list type primitives can support primitive restart',type='structs'] -- The sname:VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-primitiveTopologyListRestart]] pname:primitiveTopologyListRestart indicates that list type primitives, ename:VK_PRIMITIVE_TOPOLOGY_POINT_LIST, ename:VK_PRIMITIVE_TOPOLOGY_LINE_LIST, ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, ename:VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY and ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, can: use the primitive restart index value in index buffers. * [[features-primitiveTopologyPatchListRestart]] pname:primitiveTopologyPatchListRestart indicates that the ename:VK_PRIMITIVE_TOPOLOGY_PATCH_LIST topology can: use the primitive restart index value in index buffers. :refpage: VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.adoc[] -- endif::VK_EXT_primitive_topology_list_restart[] ifdef::VK_NV_shader_sm_builtins[] [open,refpage='VkPhysicalDeviceShaderSMBuiltinsFeaturesNV',desc='Structure describing the shader SM Builtins features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderSMBuiltinsFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderSMBuiltins]] pname:shaderSMBuiltins indicates whether the implementation supports the SPIR-V code:ShaderSMBuiltinsNV capability. :refpage: VkPhysicalDeviceShaderSMBuiltinsFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.adoc[] -- endif::VK_NV_shader_sm_builtins[] ifdef::VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts[] [open,refpage='VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures',desc='Structure describing whether the implementation can do depth and stencil image barriers separately',type='structs',alias='VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR'] -- The sname:VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.adoc[] ifdef::VK_KHR_separate_depth_stencil_layouts[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR.adoc[] endif::VK_KHR_separate_depth_stencil_layouts[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_2[:anchor-prefix: extension-] ifndef::VK_VERSION_1_2[:anchor-prefix:] // tag::VK_KHR_separate_depth_stencil_layouts-features[] * [[{anchor-prefix}features-separateDepthStencilLayouts]] pname:separateDepthStencilLayouts indicates whether the implementation supports a sname:VkImageMemoryBarrier for a depth/stencil image with only one of ename:VK_IMAGE_ASPECT_DEPTH_BIT or ename:VK_IMAGE_ASPECT_STENCIL_BIT set, and whether ename:VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, ename:VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, ename:VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or ename:VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL can be used. // end::VK_KHR_separate_depth_stencil_layouts-features[] :refpage: VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.adoc[] -- endif::VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts[] ifdef::VK_KHR_pipeline_executable_properties[] [open,refpage='VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR',desc='Structure describing whether pipeline executable properties are available',type='structs'] -- The sname:VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-pipelineExecutableInfo]] pname:pipelineExecutableInfo indicates that the implementation supports reporting properties and statistics about the pipeline executables associated with a compiled pipeline. :refpage: VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.adoc[] -- endif::VK_KHR_pipeline_executable_properties[] ifdef::VK_VERSION_1_3,VK_EXT_shader_demote_to_helper_invocation[] [open,refpage='VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures',desc='Structure describing the shader demote to helper invocations features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT'] -- The sname:VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.adoc[] ifdef::VK_EXT_shader_demote_to_helper_invocation[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.adoc[] endif::VK_EXT_shader_demote_to_helper_invocation[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_EXT_shader_demote_to_helper_invocation-features[] * [[{anchor-prefix}features-shaderDemoteToHelperInvocation]] pname:shaderDemoteToHelperInvocation indicates whether the implementation supports the SPIR-V code:DemoteToHelperInvocationEXT capability. // end::VK_EXT_shader_demote_to_helper_invocation-features[] :refpage: VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_EXT_shader_demote_to_helper_invocation[] ifdef::VK_EXT_texel_buffer_alignment[] [open,refpage='VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT',desc='Structure describing the texel buffer alignment features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-texelBufferAlignment]] pname:texelBufferAlignment indicates whether the implementation uses more specific alignment requirements advertised in slink:VkPhysicalDeviceTexelBufferAlignmentProperties rather than slink:VkPhysicalDeviceLimits::pname:minTexelBufferOffsetAlignment. :refpage: VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.adoc[] -- endif::VK_EXT_texel_buffer_alignment[] ifdef::VK_EXT_attachment_feedback_loop_dynamic_state[] [open,refpage='VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT',desc='Structure describing if dynamic feedback loops can be used',type='structs'] -- The sname:VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-attachmentFeedbackLoopDynamicState]] pname:attachmentFeedbackLoopDynamicState specifies whether dynamic feedback loops are supported. :refpage: VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.adoc[] -- endif::VK_EXT_attachment_feedback_loop_dynamic_state[] ifdef::VK_VERSION_1_3,VK_EXT_texture_compression_astc_hdr[] [open,refpage='VkPhysicalDeviceTextureCompressionASTCHDRFeatures',desc='Structure describing ASTC HDR features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT'] -- The sname:VkPhysicalDeviceTextureCompressionASTCHDRFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.adoc[] ifdef::VK_EXT_texture_compression_astc_hdr[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT.adoc[] endif::VK_EXT_texture_compression_astc_hdr[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_EXT_texture_compression_astc_hdr-features[] * [[{anchor-prefix}features-textureCompressionASTC_HDR]] pname:textureCompressionASTC_HDR indicates whether all of the ASTC HDR 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_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK ** ename:VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK + To query for additional properties, or if the feature is not enabled, flink:vkGetPhysicalDeviceFormatProperties and flink:vkGetPhysicalDeviceImageFormatProperties can: be used to check for supported properties of individual formats as normal. // end::VK_EXT_texture_compression_astc_hdr-features[] :refpage: VkPhysicalDeviceTextureCompressionASTCHDRFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_EXT_texture_compression_astc_hdr[] ifdef::VK_EXT_line_rasterization[] [open,refpage='VkPhysicalDeviceLineRasterizationFeaturesEXT',desc='Structure describing the line rasterization features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceLineRasterizationFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceLineRasterizationFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-rectangularLines]] pname:rectangularLines indicates whether the implementation supports <>. * [[features-bresenhamLines]] pname:bresenhamLines indicates whether the implementation supports <>. * [[features-smoothLines]] pname:smoothLines indicates whether the implementation supports <>. * [[features-stippledRectangularLines]] pname:stippledRectangularLines indicates whether the implementation supports <> with ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT lines. * [[features-stippledBresenhamLines]] pname:stippledBresenhamLines indicates whether the implementation supports <> with ename:VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT lines. * [[features-stippledSmoothLines]] pname:stippledSmoothLines indicates whether the implementation supports <> with ename:VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT lines. :refpage: VkPhysicalDeviceLineRasterizationFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceLineRasterizationFeaturesEXT.adoc[] -- endif::VK_EXT_line_rasterization[] ifdef::VK_VERSION_1_3,VK_EXT_subgroup_size_control[] [open,refpage='VkPhysicalDeviceSubgroupSizeControlFeatures',desc='Structure describing the subgroup size control features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceSubgroupSizeControlFeaturesEXT'] -- The sname:VkPhysicalDeviceSubgroupSizeControlFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceSubgroupSizeControlFeatures.adoc[] ifdef::VK_EXT_subgroup_size_control[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.adoc[] endif::VK_EXT_subgroup_size_control[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_EXT_subgroup_size_control-features[] * [[{anchor-prefix}features-subgroupSizeControl]] pname:subgroupSizeControl indicates whether the implementation supports controlling shader subgroup sizes via the ename:VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT flag and the slink:VkPipelineShaderStageRequiredSubgroupSizeCreateInfo structure. * [[{anchor-prefix}features-computeFullSubgroups]] pname:computeFullSubgroups indicates whether the implementation supports requiring full subgroups in compute ifdef::VK_NV_mesh_shader[] , mesh, or task endif::VK_NV_mesh_shader[] shaders via the ename:VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT flag. // end::VK_EXT_subgroup_size_control-features[] :refpage: VkPhysicalDeviceSubgroupSizeControlFeatures include::{chapters}/features.adoc[tag=features] ifndef::VKSC_VERSION_1_0[] [NOTE] .Note ==== The sname:VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure was added in version 2 of the `apiext:VK_EXT_subgroup_size_control` extension. Version 1 implementations of this extension will not fill out the features structure but applications may assume that both pname:subgroupSizeControl and pname:computeFullSubgroups are supported if the extension is supported. (See also the <> section.) Applications are advised to add a sname:VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure to the pname:pNext chain of slink:VkDeviceCreateInfo to enable the features regardless of the version of the extension supported by the implementation. If the implementation only supports version 1, it will safely ignore the sname:VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure. Vulkan 1.3 implementations always support the features structure. ==== endif::VKSC_VERSION_1_0[] include::{generated}/validity/structs/VkPhysicalDeviceSubgroupSizeControlFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_EXT_subgroup_size_control[] ifdef::VK_AMD_device_coherent_memory[] [open,refpage='VkPhysicalDeviceCoherentMemoryFeaturesAMD',desc='Structure describing whether device coherent memory can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceCoherentMemoryFeaturesAMD structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCoherentMemoryFeaturesAMD.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-deviceCoherentMemory]] pname:deviceCoherentMemory indicates that the implementation supports <>. :refpage: VkPhysicalDeviceCoherentMemoryFeaturesAMD include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCoherentMemoryFeaturesAMD.adoc[] -- endif::VK_AMD_device_coherent_memory[] ifdef::VK_KHR_acceleration_structure[] [open,refpage='VkPhysicalDeviceAccelerationStructureFeaturesKHR',desc='Structure describing the acceleration structure features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceAccelerationStructureFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceAccelerationStructureFeaturesKHR.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-accelerationStructure]] pname:accelerationStructure indicates whether the implementation supports the acceleration structure functionality. See <>. * [[features-accelerationStructureCaptureReplay]] pname:accelerationStructureCaptureReplay indicates whether the implementation supports saving and reusing acceleration structure device addresses, e.g. for trace capture and replay. * [[features-accelerationStructureIndirectBuild]] pname:accelerationStructureIndirectBuild indicates whether the implementation supports indirect acceleration structure build commands, e.g. flink:vkCmdBuildAccelerationStructuresIndirectKHR. * [[features-accelerationStructureHostCommands]] pname:accelerationStructureHostCommands indicates whether the implementation supports host side acceleration structure commands, e.g. flink:vkBuildAccelerationStructuresKHR, flink:vkCopyAccelerationStructureKHR, flink:vkCopyAccelerationStructureToMemoryKHR, flink:vkCopyMemoryToAccelerationStructureKHR, flink:vkWriteAccelerationStructuresPropertiesKHR. * [[features-descriptorBindingAccelerationStructureUpdateAfterBind]] pname:descriptorBindingAccelerationStructureUpdateAfterBind indicates whether the implementation supports updating acceleration structure descriptors after a set is bound. If this feature is not enabled, ename:VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT must: not be used with ename:VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR. :refpage: VkPhysicalDeviceAccelerationStructureFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceAccelerationStructureFeaturesKHR.adoc[] -- endif::VK_KHR_acceleration_structure[] ifdef::VK_KHR_ray_tracing_pipeline[] [open,refpage='VkPhysicalDeviceRayTracingPipelineFeaturesKHR',desc='Structure describing the ray tracing features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceRayTracingPipelineFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-rayTracingPipeline]] pname:rayTracingPipeline indicates whether the implementation supports the ray tracing pipeline functionality. See <>. * [[features-rayTracingPipelineShaderGroupHandleCaptureReplay]] pname:rayTracingPipelineShaderGroupHandleCaptureReplay indicates whether the implementation supports saving and reusing shader group handles, e.g. for trace capture and replay. * [[features-rayTracingPipelineShaderGroupHandleCaptureReplayMixed]] pname:rayTracingPipelineShaderGroupHandleCaptureReplayMixed indicates whether the implementation supports reuse of shader group handles being arbitrarily mixed with creation of non-reused shader group handles. If this is ename:VK_FALSE, all reused shader group handles must: be specified before any non-reused handles may: be created. * [[features-rayTracingPipelineTraceRaysIndirect]] pname:rayTracingPipelineTraceRaysIndirect indicates whether the implementation supports indirect ray tracing commands, e.g. flink:vkCmdTraceRaysIndirectKHR. * [[features-rayTraversalPrimitiveCulling]] pname:rayTraversalPrimitiveCulling indicates whether the implementation supports <>. :refpage: VkPhysicalDeviceRayTracingPipelineFeaturesKHR include::{chapters}/features.adoc[tag=features] .Valid Usage **** * [[VUID-VkPhysicalDeviceRayTracingPipelineFeaturesKHR-rayTracingPipelineShaderGroupHandleCaptureReplayMixed-03575]] If pname:rayTracingPipelineShaderGroupHandleCaptureReplayMixed is ename:VK_TRUE, pname:rayTracingPipelineShaderGroupHandleCaptureReplay must: also be ename:VK_TRUE **** include::{generated}/validity/structs/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.adoc[] -- endif::VK_KHR_ray_tracing_pipeline[] ifdef::VK_KHR_ray_query[] [open,refpage='VkPhysicalDeviceRayQueryFeaturesKHR',desc='Structure describing the ray query features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceRayQueryFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRayQueryFeaturesKHR.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-rayQuery]] pname:rayQuery indicates whether the implementation supports ray query (code:OpRayQueryProceedKHR) functionality. :refpage: VkPhysicalDeviceRayQueryFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceRayQueryFeaturesKHR.adoc[] -- endif::VK_KHR_ray_query[] ifdef::VK_KHR_ray_tracing_maintenance1[] [open,refpage='VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR',desc='Structure describing the ray tracing maintenance features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-rayTracingMaintenance1]] pname:rayTracingMaintenance1 indicates that the implementation supports the following: ** The code:CullMaskKHR SPIR-V builtin using the `SPV_KHR_ray_cull_mask` SPIR-V extension. ** Additional acceleration structure property queries: ename:VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR and ename:VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR. ** A new access flag ename:VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR. ** A new pipeline stage flag bit ename:VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR * [[features-rayTracingPipelineTraceRaysIndirect2]] pname:rayTracingPipelineTraceRaysIndirect2 indicates whether the implementation supports the extended indirect ray tracing command flink:vkCmdTraceRaysIndirect2KHR. :refpage: VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.adoc[] -- endif::VK_KHR_ray_tracing_maintenance1[] ifdef::VK_EXT_extended_dynamic_state[] [open,refpage='VkPhysicalDeviceExtendedDynamicStateFeaturesEXT',desc='Structure describing what extended dynamic state can be used',type='structs'] -- The sname:VkPhysicalDeviceExtendedDynamicStateFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-extendedDynamicState]] pname:extendedDynamicState indicates that the implementation supports the following dynamic states: ** ename:VK_DYNAMIC_STATE_CULL_MODE ** ename:VK_DYNAMIC_STATE_FRONT_FACE ** ename:VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY ** ename:VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT ** ename:VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT ** ename:VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE ** ename:VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE ** ename:VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE ** ename:VK_DYNAMIC_STATE_DEPTH_COMPARE_OP ** ename:VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE ** ename:VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE ** ename:VK_DYNAMIC_STATE_STENCIL_OP :refpage: VkPhysicalDeviceExtendedDynamicStateFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.adoc[] -- endif::VK_EXT_extended_dynamic_state[] ifdef::VK_EXT_extended_dynamic_state2[] [open,refpage='VkPhysicalDeviceExtendedDynamicState2FeaturesEXT',desc='Structure describing what extended dynamic state can be used',type='structs'] -- The sname:VkPhysicalDeviceExtendedDynamicState2FeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-extendedDynamicState2]] pname:extendedDynamicState2 indicates that the implementation supports the following dynamic states: ** ename:VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE ** ename:VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE ** ename:VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE * [[features-extendedDynamicState2LogicOp]] pname:extendedDynamicState2LogicOp indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_LOGIC_OP_EXT * [[features-extendedDynamicState2PatchControlPoints]] pname:extendedDynamicState2PatchControlPoints indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT :refpage: VkPhysicalDeviceExtendedDynamicState2FeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.adoc[] -- endif::VK_EXT_extended_dynamic_state2[] ifdef::VK_EXT_extended_dynamic_state3[] [open,refpage='VkPhysicalDeviceExtendedDynamicState3FeaturesEXT',desc='Structure describing what extended dynamic state is supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceExtendedDynamicState3FeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-extendedDynamicState3TessellationDomainOrigin]] pname:extendedDynamicState3TessellationDomainOrigin indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT * [[features-extendedDynamicState3DepthClampEnable]] pname:extendedDynamicState3DepthClampEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT * [[features-extendedDynamicState3PolygonMode]] pname:extendedDynamicState3PolygonMode indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_POLYGON_MODE_EXT * [[features-extendedDynamicState3RasterizationSamples]] pname:extendedDynamicState3RasterizationSamples indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT * [[features-extendedDynamicState3SampleMask]] pname:extendedDynamicState3SampleMask indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_SAMPLE_MASK_EXT * [[features-extendedDynamicState3AlphaToCoverageEnable]] pname:extendedDynamicState3AlphaToCoverageEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT * [[features-extendedDynamicState3AlphaToOneEnable]] pname:extendedDynamicState3AlphaToOneEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT * [[features-extendedDynamicState3LogicOpEnable]] pname:extendedDynamicState3LogicOpEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT * [[features-extendedDynamicState3ColorBlendEnable]] pname:extendedDynamicState3ColorBlendEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT * [[features-extendedDynamicState3ColorBlendEquation]] pname:extendedDynamicState3ColorBlendEquation indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT * [[features-extendedDynamicState3ColorWriteMask]] pname:extendedDynamicState3ColorWriteMask indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT * [[features-extendedDynamicState3RasterizationStream]] pname:extendedDynamicState3RasterizationStream indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT * [[features-extendedDynamicState3ConservativeRasterizationMode]] pname:extendedDynamicState3ConservativeRasterizationMode indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT * [[features-extendedDynamicState3ExtraPrimitiveOverestimationSize]] pname:extendedDynamicState3ExtraPrimitiveOverestimationSize indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT * [[features-extendedDynamicState3DepthClipEnable]] pname:extendedDynamicState3DepthClipEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT * [[features-extendedDynamicState3SampleLocationsEnable]] pname:extendedDynamicState3SampleLocationsEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT * [[features-extendedDynamicState3ColorBlendAdvanced]] pname:extendedDynamicState3ColorBlendAdvanced indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT * [[features-extendedDynamicState3ProvokingVertexMode]] pname:extendedDynamicState3ProvokingVertexMode indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT * [[features-extendedDynamicState3LineRasterizationMode]] pname:extendedDynamicState3LineRasterizationMode indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT * [[features-extendedDynamicState3LineStippleEnable]] pname:extendedDynamicState3LineStippleEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT * [[features-extendedDynamicState3DepthClipNegativeOneToOne]] pname:extendedDynamicState3DepthClipNegativeOneToOne indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT * [[features-extendedDynamicState3ViewportWScalingEnable]] pname:extendedDynamicState3ViewportWScalingEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV * [[features-extendedDynamicState3ViewportSwizzle]] pname:extendedDynamicState3ViewportSwizzle indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV * [[features-extendedDynamicState3CoverageToColorEnable]] pname:extendedDynamicState3CoverageToColorEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV * [[features-extendedDynamicState3CoverageToColorLocation]] pname:extendedDynamicState3CoverageToColorLocation indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV * [[features-extendedDynamicState3CoverageModulationMode]] pname:extendedDynamicState3CoverageModulationMode indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV * [[features-extendedDynamicState3CoverageModulationTableEnable]] pname:extendedDynamicState3CoverageModulationTableEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV * [[features-extendedDynamicState3CoverageModulationTable]] pname:extendedDynamicState3CoverageModulationTable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV * [[features-extendedDynamicState3CoverageReductionMode]] pname:extendedDynamicState3CoverageReductionMode indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV * [[features-extendedDynamicState3RepresentativeFragmentTestEnable]] pname:extendedDynamicState3RepresentativeFragmentTestEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV * [[features-extendedDynamicState3ShadingRateImageEnable]] pname:extendedDynamicState3ShadingRateImageEnable indicates that the implementation supports the following dynamic state: ** ename:VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV :refpage: VkPhysicalDeviceExtendedDynamicState3FeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.adoc[] -- endif::VK_EXT_extended_dynamic_state3[] ifdef::VK_NV_device_generated_commands[] [open,refpage='VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV',desc='Structure describing the device-generated commands features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-deviceGeneratedCommands]] pname:deviceGeneratedCommands indicates whether the implementation supports functionality to generate commands on the device. See <>. :refpage: VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.adoc[] -- endif::VK_NV_device_generated_commands[] ifdef::VK_NV_device_generated_commands_compute[] [open,refpage='VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV',desc='Structure describing the device-generated compute features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-deviceGeneratedCompute]] pname:deviceGeneratedCompute indicates whether the implementation supports functionality to generate dispatch commands and push constants for the compute pipeline on the device. See <>. * [[features-deviceGeneratedComputePipelines]] pname:deviceGeneratedComputePipelines indicates whether the implementation supports functionality to generate commands to bind compute pipelines on the device. See <>. * [[features-deviceGeneratedComputeCaptureReplay]] pname:deviceGeneratedComputeCaptureReplay indicates whether the implementation supports functionality to capture compute pipeline address and reuse later for replay in <>. :refpage: VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.adoc[] -- endif::VK_NV_device_generated_commands_compute[] ifdef::VK_NV_device_diagnostics_config[] [open,refpage='VkPhysicalDeviceDiagnosticsConfigFeaturesNV',desc='Structure describing the device-generated diagnostic configuration features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceDiagnosticsConfigFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-diagnosticsConfig]] pname:diagnosticsConfig indicates whether the implementation supports the ability to configure diagnostic tools. :refpage: VkPhysicalDeviceDiagnosticsConfigFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.adoc[] -- endif::VK_NV_device_diagnostics_config[] ifdef::VK_EXT_device_memory_report[] [open,refpage='VkPhysicalDeviceDeviceMemoryReportFeaturesEXT',desc='Structure describing whether device memory report callback can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceDeviceMemoryReportFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-deviceMemoryReport]] pname:deviceMemoryReport indicates whether the implementation supports the ability to register device memory report callbacks. :refpage: VkPhysicalDeviceDeviceMemoryReportFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.adoc[] -- endif::VK_EXT_device_memory_report[] ifdef::VK_EXT_global_priority_query,VK_KHR_global_priority[] [open,refpage='VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR',desc='Structure describing whether global priority query can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.adoc[] ifdef::VK_EXT_global_priority_query[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT.adoc[] endif::VK_EXT_global_priority_query[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-globalPriorityQuery]] pname:globalPriorityQuery indicates whether the implementation supports the ability to query global queue priorities. :refpage: VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.adoc[] -- endif::VK_EXT_global_priority_query,VK_KHR_global_priority[] ifdef::VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control[] [open,refpage='VkPhysicalDevicePipelineCreationCacheControlFeatures',desc='Structure describing whether pipeline cache control can be supported by an implementation',type='structs',alias='VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT'] -- The sname:VkPhysicalDevicePipelineCreationCacheControlFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePipelineCreationCacheControlFeatures.adoc[] ifdef::VK_EXT_pipeline_creation_cache_control[] or the equivalent include::{generated}/api/structs/VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT.adoc[] endif::VK_EXT_pipeline_creation_cache_control[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_EXT_pipeline_creation_cache_control-features[] * [[{anchor-prefix}features-pipelineCreationCacheControl]] pname:pipelineCreationCacheControl indicates that the implementation supports: ** The following can: be used in stext:Vk*PipelineCreateInfo::pname:flags: *** ename:VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT *** ename:VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT ** The following can: be used in slink:VkPipelineCacheCreateInfo::pname:flags: *** ename:VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT // end::VK_EXT_pipeline_creation_cache_control-features[] :refpage: VkPhysicalDevicePipelineCreationCacheControlFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePipelineCreationCacheControlFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control[] ifdef::VK_VERSION_1_3,VK_KHR_zero_initialize_workgroup_memory[] [open,refpage='VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures',desc='Structure describing support for zero initialization of workgroup memory by an implementation',type='structs',alias='VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR'] -- The sname:VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.adoc[] ifdef::VK_KHR_zero_initialize_workgroup_memory[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.adoc[] endif::VK_KHR_zero_initialize_workgroup_memory[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_KHR_zero_initialize_workgroup_memory-features[] * [[{anchor-prefix}features-shaderZeroInitializeWorkgroupMemory]] pname:shaderZeroInitializeWorkgroupMemory specifies whether the implementation supports initializing a variable in Workgroup storage class. // end::VK_KHR_zero_initialize_workgroup_memory-features[] :refpage: VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_KHR_zero_initialize_workgroup_memory[] ifdef::VK_VERSION_1_3,VK_EXT_private_data[] [open,refpage='VkPhysicalDevicePrivateDataFeatures',desc='Structure specifying physical device support',type='structs',alias='VkPhysicalDevicePrivateDataFeaturesEXT'] -- The sname:VkPhysicalDevicePrivateDataFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePrivateDataFeatures.adoc[] ifdef::VK_EXT_private_data[] or the equivalent include::{generated}/api/structs/VkPhysicalDevicePrivateDataFeaturesEXT.adoc[] endif::VK_EXT_private_data[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_EXT_private_data-features[] * [[{anchor-prefix}features-privateData]] pname:privateData indicates whether the implementation supports private data. See <>. // end::VK_EXT_private_data-features[] :refpage: VkPhysicalDevicePrivateDataFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePrivateDataFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_EXT_private_data[] ifdef::VK_KHR_shader_subgroup_uniform_control_flow[] [open,refpage='VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR',desc='Structure describing support for shader subgroup uniform control flow by an implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderSubgroupUniformControlFlow]] pname:shaderSubgroupUniformControlFlow specifies whether the implementation supports the shader execution mode code:SubgroupUniformControlFlowKHR :refpage: VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.adoc[] -- endif::VK_KHR_shader_subgroup_uniform_control_flow[] ifdef::VK_EXT_robustness2[] [open,refpage='VkPhysicalDeviceRobustness2FeaturesEXT',desc='Structure describing the out-of-bounds behavior for an implementation',type='structs'] -- The sname:VkPhysicalDeviceRobustness2FeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRobustness2FeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-robustBufferAccess2]] pname:robustBufferAccess2 indicates whether buffer accesses are tightly bounds-checked against the range of the descriptor. Uniform buffers must: be bounds-checked to the range of the descriptor, where the range is rounded up to a multiple of <>. Storage buffers must: be bounds-checked to the range of the descriptor, where the range is rounded up to a multiple of <>. Out of bounds buffer loads will return zero values, and <> from texel buffers will have [eq]#(0,0,1)# values <> based on the format. * [[features-robustImageAccess2]] pname:robustImageAccess2 indicates whether image accesses are tightly bounds-checked against the dimensions of the image view. Out of bounds <> from images will return zero values, with [eq]#(0,0,1)# values <> based on the format. * [[{vuprefix}features-nullDescriptor]] pname:nullDescriptor indicates whether descriptors can: be written with a dlink:VK_NULL_HANDLE resource or view, which are considered valid to access and act as if the descriptor were bound to nothing. :refpage: VkPhysicalDeviceRobustness2FeaturesEXT include::{chapters}/features.adoc[tag=features] .Valid Usage **** * [[VUID-VkPhysicalDeviceRobustness2FeaturesEXT-robustBufferAccess2-04000]] If pname:robustBufferAccess2 is enabled then <> must: also be enabled **** include::{generated}/validity/structs/VkPhysicalDeviceRobustness2FeaturesEXT.adoc[] -- endif::VK_EXT_robustness2[] ifndef::VK_EXT_robustness2[] [[features-nullDescriptor]] nullDescriptor support requires the `apiext:VK_EXT_robustness2` extension. endif::VK_EXT_robustness2[] ifdef::VK_VERSION_1_3,VK_EXT_image_robustness[] [open,refpage='VkPhysicalDeviceImageRobustnessFeatures',desc='Structure describing the out-of-bounds behavior for an implementation',type='structs',alias='VkPhysicalDeviceImageRobustnessFeaturesEXT'] -- The sname:VkPhysicalDeviceImageRobustnessFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceImageRobustnessFeatures.adoc[] ifdef::VK_EXT_image_robustness[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceImageRobustnessFeaturesEXT.adoc[] endif::VK_EXT_image_robustness[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_EXT_image_robustness-features[] * [[{anchor-prefix}features-robustImageAccess]] pname:robustImageAccess indicates whether image accesses are tightly bounds-checked against the dimensions of the image view. <> resulting from out of bounds image loads will be replaced as described in <>, with either [eq]#(0,0,1)# or [eq]#(0,0,0)# values inserted for missing G, B, or A components based on the format. // end::VK_EXT_image_robustness-features[] :refpage: VkPhysicalDeviceImageRobustnessFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceImageRobustnessFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_EXT_image_robustness[] ifdef::VK_VERSION_1_3,VK_KHR_shader_terminate_invocation[] [open,refpage='VkPhysicalDeviceShaderTerminateInvocationFeatures',desc='Structure describing support for the SPIR-V code:SPV_KHR_terminate_invocation extension',type='structs',alias='VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR'] -- The sname:VkPhysicalDeviceShaderTerminateInvocationFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderTerminateInvocationFeatures.adoc[] ifdef::VK_KHR_shader_terminate_invocation[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR.adoc[] endif::VK_KHR_shader_terminate_invocation[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_KHR_shader_terminate_invocation-features[] * [[{anchor-prefix}features-shaderTerminateInvocation]] pname:shaderTerminateInvocation specifies whether the implementation supports SPIR-V modules that use the `SPV_KHR_terminate_invocation` extension. // end::VK_KHR_shader_terminate_invocation-features[] :refpage: VkPhysicalDeviceShaderTerminateInvocationFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderTerminateInvocationFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_KHR_shader_terminate_invocation[] ifdef::VK_EXT_custom_border_color[] [open,refpage='VkPhysicalDeviceCustomBorderColorFeaturesEXT',desc='Structure describing whether custom border colors can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceCustomBorderColorFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCustomBorderColorFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-customBorderColors]] pname:customBorderColors indicates that the implementation supports providing a pname:borderColor value with one of the following values at sampler creation time: ** ename:VK_BORDER_COLOR_FLOAT_CUSTOM_EXT ** ename:VK_BORDER_COLOR_INT_CUSTOM_EXT * [[features-customBorderColorWithoutFormat]] pname:customBorderColorWithoutFormat indicates that explicit formats are not required for custom border colors and the value of the pname:format member of the slink:VkSamplerCustomBorderColorCreateInfoEXT structure may: be ename:VK_FORMAT_UNDEFINED. If this feature bit is not set, applications must: provide the elink:VkFormat of the image view(s) being sampled by this sampler in the pname:format member of the slink:VkSamplerCustomBorderColorCreateInfoEXT structure. :refpage: VkPhysicalDeviceCustomBorderColorFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCustomBorderColorFeaturesEXT.adoc[] -- endif::VK_EXT_custom_border_color[] ifdef::VK_EXT_border_color_swizzle[] [open,refpage='VkPhysicalDeviceBorderColorSwizzleFeaturesEXT',desc='Structure describing whether samplers with custom border colors require the component swizzle specified in order to have defined behavior',type='structs'] -- The sname:VkPhysicalDeviceBorderColorSwizzleFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-borderColorSwizzle]] pname:borderColorSwizzle indicates that defined values are returned by sampled image operations when used with a sampler that uses a ename:VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, ename:VK_BORDER_COLOR_INT_OPAQUE_BLACK, ename:VK_BORDER_COLOR_FLOAT_CUSTOM_EXT, or ename:VK_BORDER_COLOR_INT_CUSTOM_EXT pname:borderColor and an image view that uses a non-<>, when either pname:borderColorSwizzleFromImage is enabled or the slink:VkSamplerBorderColorComponentMappingCreateInfoEXT is specified. * [[features-borderColorSwizzleFromImage]] pname:borderColorSwizzleFromImage indicates that the implementation will return the correct border color values from sampled image operations under the conditions expressed above, without the application having to specify the border color component mapping when creating the sampler object. If this feature bit is not set, applications can: chain a slink:VkSamplerBorderColorComponentMappingCreateInfoEXT structure when creating samplers for use with image views that do not have an <> and, when those samplers are combined with image views using the same component mapping, sampled image operations that use opaque black or custom border colors will return the correct border color values. :refpage: VkPhysicalDeviceBorderColorSwizzleFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.adoc[] -- endif::VK_EXT_border_color_swizzle[] ifdef::VK_KHR_portability_subset[] [open,refpage='VkPhysicalDevicePortabilitySubsetFeaturesKHR',desc='Structure describing the features that may not be supported by an implementation of the Vulkan 1.0 Portability Subset',type='structs'] -- The sname:VkPhysicalDevicePortabilitySubsetFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePortabilitySubsetFeaturesKHR.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-constantAlphaColorBlendFactors]] pname:constantAlphaColorBlendFactors indicates whether this implementation supports constant _alpha_ <> used as source or destination _color_ <>. * [[features-events]] pname:events indicates whether this implementation supports synchronization using <>. * [[features-imageViewFormatReinterpretation]] pname:imageViewFormatReinterpretation indicates whether this implementation supports a sname:VkImageView being created with a texel format containing a different number of components, or a different number of bits in each component, than the texel format of the underlying sname:VkImage. * [[features-imageViewFormatSwizzle]] pname:imageViewFormatSwizzle indicates whether this implementation supports remapping format components using slink:VkImageViewCreateInfo::pname:components. * [[features-imageView2DOn3DImage]] pname:imageView2DOn3DImage indicates whether this implementation supports a sname:VkImage being created with the ename:VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT flag set, permitting a 2D or 2D array image view to be created on a 3D sname:VkImage. * [[features-multisampleArrayImage]] pname:multisampleArrayImage indicates whether this implementation supports a sname:VkImage being created as a 2D array with multiple samples per texel. * [[features-mutableComparisonSamplers]] pname:mutableComparisonSamplers indicates whether this implementation allows descriptors with comparison samplers to be <>. * [[features-pointPolygons]] pname:pointPolygons indicates whether this implementation supports <> using a _point_ <>. * [[features-samplerMipLodBias]] pname:samplerMipLodBias indicates whether this implementation supports setting a <> when <>. * [[features-separateStencilMaskRef]] pname:separateStencilMaskRef indicates whether this implementation supports separate front and back <> reference values. * [[features-shaderSampleRateInterpolationFunctions]] pname:shaderSampleRateInterpolationFunctions indicates whether this implementation supports fragment shaders which use the <> capability and the extended instructions `InterpolateAtCentroid`, `InterpolateAtOffset`, and `InterpolateAtSample` from the `GLSL.std.450` extended instruction set. This member is only meaningful if the <> feature is supported. * [[features-tessellationIsolines]] pname:tessellationIsolines indicates whether this implementation supports <> from the <> stage of a graphics pipeline. This member is only meaningful if <> are supported. * [[features-tessellationPointMode]] pname:tessellationPointMode indicates whether this implementation supports <> from the <> stage of a graphics pipeline. This member is only meaningful if <> are supported. * [[features-triangleFans]] pname:triangleFans indicates whether this implementation supports <> primitive topology. * [[features-vertexAttributeAccessBeyondStride]] pname:vertexAttributeAccessBeyondStride indicates whether this implementation supports accessing a vertex input attribute beyond the stride of the corresponding vertex input binding. :refpage: VkPhysicalDevicePortabilitySubsetFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePortabilitySubsetFeaturesKHR.adoc[] -- endif::VK_KHR_portability_subset[] ifdef::VKSC_VERSION_1_0[] [open,refpage='VkPhysicalDeviceVulkanSC10Features',desc='Structure describing the features that may not be supported by an implementation of Vulkan SC',type='structs'] -- The sname:VkPhysicalDeviceVulkanSC10Features structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceVulkanSC10Features.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderAtomicInstructions]] pname:shaderAtomicInstructions indicates whether this implementation supports shaders which use the SPIR-V code:OpAtomic* instructions. :refpage: VkPhysicalDeviceVulkanSC10Features include::{chapters}/features.adoc[tag=features] ifdef::hidden[] // tag::scaddition[] * slink:VkPhysicalDeviceVulkanSC10Features <> // end::scaddition[] // tag::scdeviation[] * slink:VkPhysicalDeviceVulkanSC10Features::pname:shaderAtomicInstructions are made optional <>. // end::scdeviation[] endif::hidden[] include::{generated}/validity/structs/VkPhysicalDeviceVulkanSC10Features.adoc[] -- endif::VKSC_VERSION_1_0[] ifdef::VK_KHR_performance_query[] include::{chapters}/VK_KHR_performance_query/features.adoc[] endif::VK_KHR_performance_query[] ifdef::VK_EXT_4444_formats[] [open,refpage='VkPhysicalDevice4444FormatsFeaturesEXT',desc='Structure describing additional 4444 formats supported by an implementation',type='structs'] -- The sname:VkPhysicalDevice4444FormatsFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDevice4444FormatsFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-formatA4R4G4B4]] pname:formatA4R4G4B4 indicates that the implementation must: support using a elink:VkFormat of ename:VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT with at least the following elink:VkFormatFeatureFlagBits: ** ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT ** ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT ** ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT * [[features-formatA4B4G4R4]] pname:formatA4B4G4R4 indicates that the implementation must: support using a elink:VkFormat of ename:VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT with at least the following elink:VkFormatFeatureFlagBits: ** ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT ** ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT ** ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT :refpage: VkPhysicalDevice4444FormatsFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevice4444FormatsFeaturesEXT.adoc[] ifdef::VK_VERSION_1_3[] [NOTE] .Note ==== Although the formats defined by the `apiext:VK_EXT_4444_formats` extension were promoted to Vulkan 1.3 as optional formats, the slink:VkPhysicalDevice4444FormatsFeaturesEXT structure was not promoted to Vulkan 1.3. ==== endif::VK_VERSION_1_3[] -- endif::VK_EXT_4444_formats[] ifdef::VK_EXT_mutable_descriptor_type,VK_VALVE_mutable_descriptor_type[] [open,refpage='VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT',desc='Structure describing whether the mutable descriptor type is supported',type='structs',alias='VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE'] -- The sname:VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.adoc[] ifdef::VK_VALVE_mutable_descriptor_type[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.adoc[] endif::VK_VALVE_mutable_descriptor_type[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-mutableDescriptorType]] pname:mutableDescriptorType indicates that the implementation must: support using the elink:VkDescriptorType of ename:VK_DESCRIPTOR_TYPE_MUTABLE_EXT with at least the following descriptor types, where any combination of the types must: be supported: ** 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 * Additionally, pname:mutableDescriptorType indicates that: ifdef::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] ** Non-uniform descriptor indexing must: be supported if all descriptor types in a slink:VkMutableDescriptorTypeListEXT for ename:VK_DESCRIPTOR_TYPE_MUTABLE_EXT have the corresponding non-uniform indexing features enabled in slink:VkPhysicalDeviceDescriptorIndexingFeatures. ** ename:VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT with pname:descriptorType of ename:VK_DESCRIPTOR_TYPE_MUTABLE_EXT relaxes the list of required descriptor types to the descriptor types which have the corresponding update-after-bind feature enabled in slink:VkPhysicalDeviceDescriptorIndexingFeatures. endif::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] ** Dynamically uniform descriptor indexing must: be supported if all descriptor types in a slink:VkMutableDescriptorTypeListEXT for ename:VK_DESCRIPTOR_TYPE_MUTABLE_EXT have the corresponding dynamic indexing features enabled. ** ename:VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT must: be supported. ** ename:VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT must: be supported. :refpage: VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.adoc[] -- endif::VK_EXT_mutable_descriptor_type,VK_VALVE_mutable_descriptor_type[] ifdef::VK_EXT_depth_clip_control[] [open,refpage='VkPhysicalDeviceDepthClipControlFeaturesEXT',desc='Structure describing additional depth clip control supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceDepthClipControlFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDepthClipControlFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-depthClipControl]] pname:depthClipControl indicates that the implementation supports setting slink:VkPipelineViewportDepthClipControlCreateInfoEXT::pname:negativeOneToOne to ename:VK_TRUE. :refpage: VkPhysicalDeviceDepthClipControlFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDepthClipControlFeaturesEXT.adoc[] -- endif::VK_EXT_depth_clip_control[] ifdef::VK_KHR_workgroup_memory_explicit_layout[] [open,refpage='VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR',desc='Structure describing the workgroup storage explicit layout features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-workgroupMemoryExplicitLayout]] pname:workgroupMemoryExplicitLayout indicates whether the implementation supports the SPIR-V code:WorkgroupMemoryExplicitLayoutKHR capability. * [[features-workgroupMemoryExplicitLayoutScalarBlockLayout]] pname:workgroupMemoryExplicitLayoutScalarBlockLayout indicates whether the implementation supports scalar alignment for laying out Workgroup Blocks. * [[features-workgroupMemoryExplicitLayout8BitAccess]] pname:workgroupMemoryExplicitLayout8BitAccess indicates whether objects in the code:Workgroup storage class with the code:Block decoration can: have 8-bit integer members. If this feature is not enabled, 8-bit integer members must: not be used in such objects. This also indicates whether shader modules can: declare the code:WorkgroupMemoryExplicitLayout8BitAccessKHR capability. * [[features-workgroupMemoryExplicitLayout16BitAccess]] pname:workgroupMemoryExplicitLayout16BitAccess indicates whether objects in the code:Workgroup storage class with the code:Block decoration can: have 16-bit integer and 16-bit floating-point members. If this feature is not enabled, 16-bit integer or 16-bit floating-point members must: not be used in such objects. This also indicates whether shader modules can: declare the code:WorkgroupMemoryExplicitLayout16BitAccessKHR capability. :refpage: VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.adoc[] -- endif::VK_KHR_workgroup_memory_explicit_layout[] ifdef::VK_VERSION_1_3,VK_KHR_synchronization2[] [open,refpage='VkPhysicalDeviceSynchronization2Features',desc='Structure describing whether the implementation supports v2 synchronization commands',type='structs',alias='VkPhysicalDeviceSynchronization2FeaturesKHR'] -- The sname:VkPhysicalDeviceSynchronization2Features structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceSynchronization2Features.adoc[] ifdef::VK_KHR_synchronization2[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceSynchronization2FeaturesKHR.adoc[] endif::VK_KHR_synchronization2[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_KHR_synchronization2-features[] * [[{anchor-prefix}features-synchronization2]] pname:synchronization2 indicates whether the implementation supports the new set of synchronization commands introduced in `apiext:VK_KHR_synchronization2`. // end::VK_KHR_synchronization2-features[] :refpage: VkPhysicalDeviceSynchronization2Features include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceSynchronization2Features.adoc[] -- endif::VK_VERSION_1_3,VK_KHR_synchronization2[] ifdef::VK_EXT_vertex_input_dynamic_state[] [open,refpage='VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT',desc='Structure describing whether the dynamic vertex input state can be used',type='structs'] -- The sname:VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-vertexInputDynamicState]] pname:vertexInputDynamicState indicates that the implementation supports the following dynamic states: ** ename:VK_DYNAMIC_STATE_VERTEX_INPUT_EXT :refpage: VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.adoc[] -- endif::VK_EXT_vertex_input_dynamic_state[] ifdef::VK_EXT_primitives_generated_query[] [open,refpage='VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT',desc='Structure describing support for primitives generated query',type='structs'] -- The sname:VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-primitivesGeneratedQuery]] pname:primitivesGeneratedQuery indicates whether the implementation supports the ename:VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query type. * [[features-primitivesGeneratedQueryWithRasterizerDiscard]] pname:primitivesGeneratedQueryWithRasterizerDiscard indicates whether the implementation supports this query when <> is enabled. * [[features-primitivesGeneratedQueryWithNonZeroStreams]] pname:primitivesGeneratedQueryWithNonZeroStreams indicates whether the implementation supports this query with a non-zero index in flink:vkCmdBeginQueryIndexedEXT. :refpage: VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.adoc[] -- endif::VK_EXT_primitives_generated_query[] ifdef::VK_KHR_fragment_shading_rate[] [open,refpage='VkPhysicalDeviceFragmentShadingRateFeaturesKHR',desc='Structure indicating support for variable rate fragment shading',type='structs'] -- The sname:VkPhysicalDeviceFragmentShadingRateFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-pipelineFragmentShadingRate]] pname:pipelineFragmentShadingRate indicates that the implementation supports the <>. * [[features-primitiveFragmentShadingRate]] pname:primitiveFragmentShadingRate indicates that the implementation supports the <>. * [[features-attachmentFragmentShadingRate]] pname:attachmentFragmentShadingRate indicates that the implementation supports the <>. :refpage: VkPhysicalDeviceFragmentShadingRateFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.adoc[] -- endif::VK_KHR_fragment_shading_rate[] ifdef::VK_EXT_legacy_dithering[] [open,refpage='VkPhysicalDeviceLegacyDitheringFeaturesEXT',desc='Structure describing support for legacy dithering',type='structs'] -- The sname:VkPhysicalDeviceLegacyDitheringFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceLegacyDitheringFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-legacyDithering]] pname:legacyDithering indicates whether the implementation supports <>. :refpage: VkPhysicalDeviceLegacyDitheringFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceLegacyDitheringFeaturesEXT.adoc[] -- endif::VK_EXT_legacy_dithering[] ifdef::VK_NV_fragment_shading_rate_enums[] [open,refpage='VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV',desc='Structure indicating support for fragment shading rate enums',type='structs'] -- The sname:VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-fragmentShadingRateEnums]] pname:fragmentShadingRateEnums indicates that the implementation supports specifying fragment shading rates using the ename:VkFragmentShadingRateNV enumerated type. * [[features-supersampleFragmentShadingRates]] pname:supersampleFragmentShadingRates indicates that the implementation supports fragment shading rate enum values indicating more than one invocation per fragment. * [[features-noInvocationFragmentShadingRates]] pname:noInvocationFragmentShadingRates indicates that the implementation supports a fragment shading rate enum value indicating that no fragment shaders should be invoked when that shading rate is used. :refpage: VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.adoc[] -- endif::VK_NV_fragment_shading_rate_enums[] ifdef::VK_NV_inherited_viewport_scissor[] [open,refpage='VkPhysicalDeviceInheritedViewportScissorFeaturesNV',desc='Structure describing the viewport scissor inheritance behavior for an implementation',type='structs'] -- The sname:VkPhysicalDeviceInheritedViewportScissorFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-inheritedViewportScissor2D]] pname:inheritedViewportScissor2D indicates whether secondary command buffers can inherit most of the dynamic state affected by ifdef::VK_VERSION_1_3,VK_EXT_extended_dynamic_state[] ename:VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, ename:VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, endif::VK_VERSION_1_3,VK_EXT_extended_dynamic_state[] ifdef::VK_EXT_discard_rectangles[] ename:VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, ename:VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT, ename:VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT, endif::VK_EXT_discard_rectangles[] ename:VK_DYNAMIC_STATE_VIEWPORT or ename:VK_DYNAMIC_STATE_SCISSOR, from a primary command buffer. :refpage: VkPhysicalDeviceInheritedViewportScissorFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.adoc[] -- endif::VK_NV_inherited_viewport_scissor[] ifdef::VK_EXT_pipeline_protected_access[] [open,refpage='VkPhysicalDevicePipelineProtectedAccessFeaturesEXT',desc='Structure describing support for specifying protected access on individual pipelines',type='structs'] -- The sname:VkPhysicalDevicePipelineProtectedAccessFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePipelineProtectedAccessFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-pipelineProtectedAccess]] pname:pipelineProtectedAccess indicates whether the implementation supports specifying protected access on individual pipelines. :refpage: VkPhysicalDevicePipelineProtectedAccessFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePipelineProtectedAccessFeaturesEXT.adoc[] -- endif::VK_EXT_pipeline_protected_access[] ifdef::VK_EXT_ycbcr_2plane_444_formats[] [open,refpage='VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT',desc='Structure describing whether the implementation supports additional 2-plane 444 {YCbCr} formats',type='structs'] -- The sname:VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-ycbcr2plane444Formats]] pname:ycbcr2plane444Formats indicates that the implementation supports the following 2-plane 444 {YCbCr} formats: ** ename:VK_FORMAT_G8_B8R8_2PLANE_444_UNORM ** ename:VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 ** ename:VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 ** ename:VK_FORMAT_G16_B16R16_2PLANE_444_UNORM :refpage: VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.adoc[] ifdef::VK_VERSION_1_3[] [NOTE] .Note ==== Although the formats defined by the `apiext:VK_EXT_ycbcr_2plane_444_formats` were promoted to Vulkan 1.3 as optional formats, the slink:VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT structure was not promoted to Vulkan 1.3. ==== endif::VK_VERSION_1_3[] -- endif::VK_EXT_ycbcr_2plane_444_formats[] ifdef::VK_EXT_color_write_enable[] [open,refpage='VkPhysicalDeviceColorWriteEnableFeaturesEXT',desc='Structure describing whether writes to color attachments can be enabled and disabled dynamically',type='structs'] -- The sname:VkPhysicalDeviceColorWriteEnableFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceColorWriteEnableFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-colorWriteEnable]] pname:colorWriteEnable indicates that the implementation supports the dynamic state ename:VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT. :refpage: VkPhysicalDeviceColorWriteEnableFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceColorWriteEnableFeaturesEXT.adoc[] -- endif::VK_EXT_color_write_enable[] ifdef::VK_EXT_pipeline_properties[] [open,refpage='VkPhysicalDevicePipelinePropertiesFeaturesEXT',desc='Structure describing what pipeline properties are supported',type='structs'] -- The sname:VkPhysicalDevicePipelinePropertiesFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePipelinePropertiesFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-pipelinePropertiesIdentifier]] pname:pipelinePropertiesIdentifier indicates that the implementation supports querying a unique pipeline identifier. :refpage: VkPhysicalDevicePipelinePropertiesFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePipelinePropertiesFeaturesEXT.adoc[] -- endif::VK_EXT_pipeline_properties[] ifdef::VK_EXT_provoking_vertex[] [open,refpage='VkPhysicalDeviceProvokingVertexFeaturesEXT',desc='Structure describing the provoking vertex features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceProvokingVertexFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceProvokingVertexFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-provokingVertexLast]] pname:provokingVertexLast indicates whether the implementation supports the ename:VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT <> for flat shading. * [[features-transformFeedbackPreservesProvokingVertex]] pname:transformFeedbackPreservesProvokingVertex indicates that the order of vertices within each primitive written by transform feedback will preserve the provoking vertex. This does not apply to triangle fan primitives when <> is ename:VK_FALSE. pname:transformFeedbackPreservesProvokingVertex must: be ename:VK_FALSE when the `apiext:VK_EXT_transform_feedback` extension is not supported. :refpage: VkPhysicalDeviceProvokingVertexFeaturesEXT include::{chapters}/features.adoc[tag=features] ifdef::VK_EXT_transform_feedback[] When sname:VkPhysicalDeviceProvokingVertexFeaturesEXT is in the pname:pNext chain of slink:VkDeviceCreateInfo but the <> feature is not enabled, the value of pname:transformFeedbackPreservesProvokingVertex is ignored. endif::VK_EXT_transform_feedback[] include::{generated}/validity/structs/VkPhysicalDeviceProvokingVertexFeaturesEXT.adoc[] -- endif::VK_EXT_provoking_vertex[] ifdef::VK_EXT_descriptor_buffer[] [open,refpage='VkPhysicalDeviceDescriptorBufferFeaturesEXT',desc='Structure describing the descriptor buffer features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceDescriptorBufferFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDescriptorBufferFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-descriptorBuffer]] pname:descriptorBuffer indicates that the implementation supports putting shader-accessible descriptors directly in memory. * [[features-descriptorBufferCaptureReplay]] pname:descriptorBufferCaptureReplay indicates that the implementation supports capture and replay when using descriptor buffers. If this is ename:VK_TRUE, all resources created with ename:VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, ename:VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, ename:VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, ename:VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, or ename:VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT must: be created before resources of the same types without those flags. * [[features-descriptorBufferImageLayoutIgnored]] pname:descriptorBufferImageLayoutIgnored indicates that the implementation will ignore pname:imageLayout in sname:VkDescriptorImageInfo when calling flink:vkGetDescriptorEXT. * [[features-descriptorBufferPushDescriptors]] pname:descriptorBufferPushDescriptors indicates that the implementation supports using push descriptors with descriptor buffers. :refpage: VkPhysicalDeviceDescriptorBufferFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDescriptorBufferFeaturesEXT.adoc[] -- endif::VK_EXT_descriptor_buffer[] ifdef::VK_EXT_pageable_device_local_memory[] [open,refpage='VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT',desc='Structure describing whether the implementation supports pageable device-local memory',type='structs'] -- The sname:VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-pageableDeviceLocalMemory]] pname:pageableDeviceLocalMemory indicates that the implementation supports pageable device-local memory and may: transparently move device-local memory allocations to host-local memory to better share device-local memory with other applications. :refpage: VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.adoc[] -- endif::VK_EXT_pageable_device_local_memory[] ifdef::VK_EXT_multi_draw[] [open,refpage='VkPhysicalDeviceMultiDrawFeaturesEXT',desc='Structure describing whether the implementation supports multi draw functionality',type='structs'] -- The sname:VkPhysicalDeviceMultiDrawFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMultiDrawFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-multiDraw]] pname:multiDraw indicates that the implementation supports flink:vkCmdDrawMultiEXT and flink:vkCmdDrawMultiIndexedEXT. :refpage: VkPhysicalDeviceMultiDrawFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMultiDrawFeaturesEXT.adoc[] -- endif::VK_EXT_multi_draw[] ifdef::VK_NV_ray_tracing_motion_blur[] [open,refpage='VkPhysicalDeviceRayTracingMotionBlurFeaturesNV',desc='Structure describing the ray tracing motion blur features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceRayTracingMotionBlurFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-rayTracingMotionBlur]] pname:rayTracingMotionBlur indicates whether the implementation supports the motion blur feature. * [[features-rayTracingMotionBlurPipelineTraceRaysIndirect]] pname:rayTracingMotionBlurPipelineTraceRaysIndirect indicates whether the implementation supports indirect ray tracing commands with the motion blur feature enabled. :refpage: VkPhysicalDeviceRayTracingMotionBlurFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.adoc[] -- endif::VK_NV_ray_tracing_motion_blur[] ifdef::VK_EXT_opacity_micromap[] [open,refpage='VkPhysicalDeviceOpacityMicromapFeaturesEXT',desc='Structure describing the ray tracing opacity micromap features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceOpacityMicromapFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceOpacityMicromapFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-micromap]] pname:micromap indicates whether the implementation supports the micromap array feature. * [[features-micromapCaptureReplay]] pname:micromapCaptureReplay indicates whether the implementation supports capture and replay of addresses for micromap arrays. * [[features-micromapHostCommands]] pname:micromapHostCommands indicates whether the implementation supports host side micromap array commands. :refpage: VkPhysicalDeviceOpacityMicromapFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceOpacityMicromapFeaturesEXT.adoc[] -- endif::VK_EXT_opacity_micromap[] ifdef::VK_NV_displacement_micromap[] [open,refpage='VkPhysicalDeviceDisplacementMicromapFeaturesNV',desc='Structure describing the ray tracing displacement micromap features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceDisplacementMicromapFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDisplacementMicromapFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-displacementMicromap]] pname:displacementMicromap indicates whether the implementation supports the displacement micromap feature. :refpage: VkPhysicalDeviceDisplacementMicromapFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDisplacementMicromapFeaturesNV.adoc[] -- endif::VK_NV_displacement_micromap[] ifdef::VK_HUAWEI_subpass_shading[] [open,refpage='VkPhysicalDeviceSubpassShadingFeaturesHUAWEI',desc='Structure describing whether subpass shading is enabled',type='structs'] -- The sname:VkPhysicalDeviceSubpassShadingFeaturesHUAWEI structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-subpassShading]] pname:subpassShading specifies whether subpass shading is supported. :refpage: VkPhysicalDeviceSubpassShadingFeaturesHUAWEI include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.adoc[] -- endif::VK_HUAWEI_subpass_shading[] ifdef::VK_NV_external_memory_rdma[] [open,refpage='VkPhysicalDeviceExternalMemoryRDMAFeaturesNV',desc='Structure describing the external memory RDMA features supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceExternalMemoryRDMAFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-externalMemoryRDMA]] pname:externalMemoryRDMA indicates whether the implementation has support for the ename:VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV memory property and the ename:VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV external memory handle type. :refpage: VkPhysicalDeviceExternalMemoryRDMAFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.adoc[] -- endif::VK_NV_external_memory_rdma[] ifdef::VK_KHR_present_id[] [open,refpage='VkPhysicalDevicePresentIdFeaturesKHR',desc='Structure indicating support for present id',type='structs'] -- The sname:VkPhysicalDevicePresentIdFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePresentIdFeaturesKHR.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-presentId]] pname:presentId indicates that the implementation supports specifying present ID values in the sname:VkPresentIdKHR extension to the sname:VkPresentInfoKHR struct. :refpage: VkPhysicalDevicePresentIdFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePresentIdFeaturesKHR.adoc[] -- endif::VK_KHR_present_id[] ifdef::VK_KHR_present_wait[] [open,refpage='VkPhysicalDevicePresentWaitFeaturesKHR',desc='Structure indicating support for present wait',type='structs'] -- The sname:VkPhysicalDevicePresentWaitFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePresentWaitFeaturesKHR.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-presentWait]] pname:presentWait indicates that the implementation supports fname:vkWaitForPresentKHR. :refpage: VkPhysicalDevicePresentWaitFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePresentWaitFeaturesKHR.adoc[] -- endif::VK_KHR_present_wait[] ifdef::VK_EXT_host_image_copy[] [open,refpage='VkPhysicalDeviceHostImageCopyFeaturesEXT',desc='Structure indicating support for copies to or from images from host memory',type='structs'] -- The sname:VkPhysicalDeviceHostImageCopyFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceHostImageCopyFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-hostImageCopy]] pname:hostImageCopy indicates that the implementation supports copying from host memory to images using the flink:vkCopyMemoryToImageEXT command, copying from images to host memory using the flink:vkCopyImageToMemoryEXT command, and copying between images using the flink:vkCopyImageToImageEXT command. :refpage: VkPhysicalDeviceHostImageCopyFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceHostImageCopyFeaturesEXT.adoc[] -- endif::VK_EXT_host_image_copy[] ifdef::VK_NV_present_barrier[] [open,refpage='VkPhysicalDevicePresentBarrierFeaturesNV',desc='Structure indicating support for VK_NV_present_barrier extension',type='structs'] -- The sname:VkPhysicalDevicePresentBarrierFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePresentBarrierFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-presentBarrier]] pname:presentBarrier indicates that the implementation supports the present barrier feature. :refpage: VkPhysicalDevicePresentBarrierFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePresentBarrierFeaturesNV.adoc[] -- endif::VK_NV_present_barrier[] ifdef::VK_VERSION_1_3,VK_KHR_shader_integer_dot_product[] [open,refpage='VkPhysicalDeviceShaderIntegerDotProductFeatures',desc='Structure describing integer dot product features that can be supported by an implementation',type='structs',alias='VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR'] -- The sname:VkPhysicalDeviceShaderIntegerDotProductFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderIntegerDotProductFeatures.adoc[] ifdef::VK_KHR_shader_integer_dot_product[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR.adoc[] endif::VK_KHR_shader_integer_dot_product[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_KHR_shader_integer_dot_product-features[] * [[{anchor-prefix}features-shaderIntegerDotProduct]] pname:shaderIntegerDotProduct specifies whether shader modules can: declare the code:DotProductInputAllKHR, code:DotProductInput4x8BitKHR, code:DotProductInput4x8BitPackedKHR and code:DotProductKHR capabilities. // end::VK_KHR_shader_integer_dot_product-features[] :refpage: VkPhysicalDeviceShaderIntegerDotProductFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderIntegerDotProductFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_KHR_shader_integer_dot_product[] ifdef::VK_VERSION_1_3,VK_KHR_maintenance4[] [open,refpage='VkPhysicalDeviceMaintenance4Features',desc='Structure describing whether the implementation supports maintenance4 functionality',type='structs',alias='VkPhysicalDeviceMaintenance4FeaturesKHR'] -- The sname:VkPhysicalDeviceMaintenance4Features structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMaintenance4Features.adoc[] ifdef::VK_KHR_maintenance4[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceMaintenance4FeaturesKHR.adoc[] endif::VK_KHR_maintenance4[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_KHR_maintenance4-features[] * [[{anchor-prefix}features-maintenance4]] pname:maintenance4 indicates that the implementation supports the following: ** The application may: destroy a slink:VkPipelineLayout object immediately after using it to create another object. ** code:LocalSizeId can: be used as an alternative to code:LocalSize to specify the local workgroup size with specialization constants. ** Images created with identical creation parameters will always have the same alignment requirements. ** The size memory requirement of a buffer or image is never greater than that of another buffer or image created with a greater or equal size. ** Push constants do not have to be initialized before they are dynamically accessed. ** The interface matching rules allow a larger output vector to match with a smaller input vector, with additional values being discarded. // end::VK_KHR_maintenance4-features[] :refpage: VkPhysicalDeviceMaintenance4Features include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMaintenance4Features.adoc[] -- endif::VK_VERSION_1_3,VK_KHR_maintenance4[] ifdef::VK_KHR_maintenance5[] [open,refpage='VkPhysicalDeviceMaintenance5FeaturesKHR',desc='Structure describing whether the implementation supports maintenance5 functionality',type='structs',alias='VkPhysicalDeviceMaintenance5FeaturesKHR'] -- The sname:VkPhysicalDeviceMaintenance5FeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMaintenance5FeaturesKHR.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-maintenance5]] pname:maintenance5 indicates that the implementation supports the following: ** The ability to expose support for the optional format ename:VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR. ** The ability to expose support for the optional format ename:VK_FORMAT_A8_UNORM_KHR. ** A property to indicate that multisample coverage operations are performed after sample counting in EarlyFragmentTests mode. ** Creating a sname:VkBufferView with a subset of the associated sname:VkBuffer usage using slink:VkBufferUsageFlags2CreateInfoKHR. ** A new function flink:vkCmdBindIndexBuffer2KHR, allowing a range of memory to be bound as an index buffer. ** flink:vkGetDeviceProcAddr will return `NULL` for function pointers of core functions for versions higher than the version requested by the application. ** flink:vkCmdBindVertexBuffers2 supports using ename:VK_WHOLE_SIZE in the pname:pSizes parameter. ** If code:PointSize is not written, a default value of `1.0` is used for the size of points. ** slink:VkShaderModuleCreateInfo can: be added as a chained structure to pipeline creation via slink:VkPipelineShaderStageCreateInfo, rather than having to create a shader module. ** A function flink:vkGetRenderingAreaGranularityKHR to query the optimal render area for a dynamic rendering instance. ** A property to indicate that depth/stencil texturing operations with ename:VK_COMPONENT_SWIZZLE_ONE have defined behavior. ** flink:vkGetDeviceImageSubresourceLayoutKHR allows an application to perform a flink:vkGetImageSubresourceLayout query without having to create an image. ** ename:VK_REMAINING_ARRAY_LAYERS as the pname:layerCount member of slink:VkImageSubresourceLayers. ** A property to indicate whether code:PointSize controls the final rasterization of polygons if <> is ename:VK_POLYGON_MODE_POINT. ** Two properties to indicate the non-strict line rasterization algorithm used. ** Two new flags words elink:VkPipelineCreateFlagBits2KHR and elink:VkBufferUsageFlagBits2KHR. ** Physical-device-level functions can: now be called with any value in the valid range for a type beyond the defined enumerants, such that applications can avoid checking individual features, extensions, or versions before querying supported properties of a particular enumerant. ** Copies between images of any type are allowed, with 1D images treated as 2D images with a height of `1`. :refpage: VkPhysicalDeviceMaintenance5FeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMaintenance5FeaturesKHR.adoc[] -- endif::VK_KHR_maintenance5[] ifdef::VK_VERSION_1_3,VK_KHR_dynamic_rendering[] [open,refpage='VkPhysicalDeviceDynamicRenderingFeatures',desc='Structure indicating support for dynamic render pass instances',type='structs',alias='VkPhysicalDeviceDynamicRenderingFeaturesKHR'] -- The sname:VkPhysicalDeviceDynamicRenderingFeatures structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDynamicRenderingFeatures.adoc[] ifdef::VK_KHR_dynamic_rendering[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceDynamicRenderingFeaturesKHR.adoc[] endif::VK_KHR_dynamic_rendering[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. // Must have preceding whitespace ifdef::VK_VERSION_1_3[:anchor-prefix: extension-] ifndef::VK_VERSION_1_3[:anchor-prefix:] // tag::VK_KHR_dynamic_rendering-features[] * [[{anchor-prefix}features-dynamicRendering]] pname:dynamicRendering specifies that the implementation supports dynamic render pass instances using the flink:vkCmdBeginRendering command. // end::VK_KHR_dynamic_rendering-features[] :refpage: VkPhysicalDeviceDynamicRenderingFeatures include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDynamicRenderingFeatures.adoc[] -- endif::VK_VERSION_1_3,VK_KHR_dynamic_rendering[] ifdef::VK_EXT_rgba10x6_formats[] [open,refpage='VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT',desc='Structure describing whether rendering to VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 formats can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-formatRgba10x6WithoutYCbCrSampler]] pname:formatRgba10x6WithoutYCbCrSampler indicates that ename:VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 can: be used with a sname:VkImageView with pname:subresourceRange.aspectMask equal to ename:VK_IMAGE_ASPECT_COLOR_BIT without a <> enabled. :refpage: VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.adoc[] -- endif::VK_EXT_rgba10x6_formats[] ifdef::VK_EXT_pipeline_robustness[] [open,refpage='VkPhysicalDevicePipelineRobustnessFeaturesEXT',desc='Structure describing whether an implementation supports robustness requests on a per-pipeline stage granularity',type='structs'] -- The sname:VkPhysicalDevicePipelineRobustnessFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePipelineRobustnessFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-pipelineRobustness]] pname:pipelineRobustness indicates that robustness can: be requested on a per-pipeline-stage granularity. [NOTE] .Note ==== Enabling <> may, on some platforms, incur a minor performance cost when <> is disabled, even for pipelines which do not make use of any robustness features. If robustness is not needed, <> should not be enabled by an application. ==== :refpage: VkPhysicalDevicePipelineRobustnessFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePipelineRobustnessFeaturesEXT.adoc[] -- endif::VK_EXT_pipeline_robustness[] ifdef::VK_EXT_image_view_min_lod[] [open,refpage='VkPhysicalDeviceImageViewMinLodFeaturesEXT',desc='Structure describing whether clamping the min LOD of a image view is supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceImageViewMinLodFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceImageViewMinLodFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-minLod]] pname:minLod indicates whether the implementation supports clamping the minimum LOD value during <>, <> and <> with a given slink:VkImageView by slink:VkImageViewMinLodCreateInfoEXT::pname:minLod. :refpage: VkPhysicalDeviceImageViewMinLodFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceImageViewMinLodFeaturesEXT.adoc[] -- endif::VK_EXT_image_view_min_lod[] ifdef::VK_EXT_rasterization_order_attachment_access[] [open,refpage='VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT',desc='Structure describing whether rasterization order attachment access can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.adoc[] ifdef::VK_ARM_rasterization_order_attachment_access[] or the equivalent include::{generated}/api/structs/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.adoc[] endif::VK_ARM_rasterization_order_attachment_access[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-rasterizationOrderColorAttachmentAccess]] pname:rasterizationOrderColorAttachmentAccess indicates that rasterization order access to color and input attachments is supported by the implementation. * [[features-rasterizationOrderDepthAttachmentAccess]] pname:rasterizationOrderDepthAttachmentAccess indicates that rasterization order access to the depth aspect of depth/stencil and input attachments is supported by the implementation. * [[features-rasterizationOrderStencilAttachmentAccess]] pname:rasterizationOrderStencilAttachmentAccess indicates that rasterization order access to the stencil aspect of depth/stencil and input attachments is supported by the implementation. :refpage: VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.adoc[] -- endif::VK_EXT_rasterization_order_attachment_access[] ifdef::VK_EXT_subpass_merge_feedback[] [open,refpage='VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT',desc='Structure describing whether subpass merging feedback can be supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-subpassMergeFeedback]] pname:subpassMergeFeedback indicates whether the implementation supports feedback of subpass merging. :refpage: VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.adoc[] -- endif::VK_EXT_subpass_merge_feedback[] ifdef::VK_NV_linear_color_attachment[] [open,refpage='VkPhysicalDeviceLinearColorAttachmentFeaturesNV',desc='Structure describing whether <> rendering is supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceLinearColorAttachmentFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-linearColorAttachment]] pname:linearColorAttachment indicates whether the implementation supports renderable <> :refpage: VkPhysicalDeviceLinearColorAttachmentFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.adoc[] -- endif::VK_NV_linear_color_attachment[] ifdef::VK_EXT_attachment_feedback_loop_layout[] [open,refpage='VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT',desc='Structure indicating support for a render feedback loop image layout',type='structs'] -- The sname:VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-attachmentFeedbackLoopLayout]] pname:attachmentFeedbackLoopLayout indicates whether the implementation supports using ename:VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT image layout for images created with ename:VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT. include::{generated}/validity/structs/VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.adoc[] -- endif::VK_EXT_attachment_feedback_loop_layout[] ifdef::VK_EXT_nested_command_buffer[] [open,refpage='VkPhysicalDeviceNestedCommandBufferFeaturesEXT',desc='Structure describing whether nested command buffers are supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceNestedCommandBufferFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceNestedCommandBufferFeaturesEXT.adoc[] This structure describes the following features: * [[features-nestedCommandBuffer]] pname:nestedCommandBuffer indicates the implementation supports nested command buffers, which allows <> to execute other <>. * [[features-nestedCommandBufferRendering]] pname:nestedCommandBufferRendering indicates that it is valid to call flink:vkCmdExecuteCommands inside a <> recorded with ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT. * [[features-nestedCommandBufferSimultaneousUse]] pname:nestedCommandBufferSimultaneousUse indicates that the implementation supports nested command buffers with command buffers that are recorded with ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT. :refpage: VkPhysicalDeviceNestedCommandBufferFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceNestedCommandBufferFeaturesEXT.adoc[] -- endif::VK_EXT_nested_command_buffer[] ifdef::VK_EXT_graphics_pipeline_library[] [open,refpage='VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT',desc='Structure describing support for graphics pipeline libraries',type='structs'] -- The sname:VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-graphicsPipelineLibrary]] pname:graphicsPipelineLibrary indicates that the implementation supports <>. :refpage: VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.adoc[] -- endif::VK_EXT_graphics_pipeline_library[] ifdef::VK_EXT_multisampled_render_to_single_sampled[] [open,refpage='VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT',desc='Structure describing whether multisampled rendering to single-sampled attachments is supported',type='structs'] -- The sname:VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-multisampledRenderToSingleSampled]] pname:multisampledRenderToSingleSampled indicates that the implementation supports multisampled rendering to single-sampled render pass attachments. :refpage: VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.adoc[] -- endif::VK_EXT_multisampled_render_to_single_sampled[] ifdef::VK_EXT_image_2d_view_of_3d[] [open,refpage='VkPhysicalDeviceImage2DViewOf3DFeaturesEXT',desc='Structure describing whether single-slice 2D views of 3D images can be used in image descriptors',type='structs'] -- The sname:VkPhysicalDeviceImage2DViewOf3DFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-image2DViewOf3D]] pname:image2DViewOf3D indicates that the implementation supports using a 2D view of a 3D image in a descriptor of type ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE if the image is created using ename:VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT. * [[features-sampler2DViewOf3D]] pname:sampler2DViewOf3D indicates that the implementation supports using a 2D view of a 3D image in a descriptor of type ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER if the image is created using ename:VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT. :refpage: VkPhysicalDeviceImage2DViewOf3DFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.adoc[] -- endif::VK_EXT_image_2d_view_of_3d[] ifdef::VK_EXT_image_sliced_view_of_3d[] [open,refpage='VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT',desc='Structure describing whether slice-based views of 3D images can be used in storage image descriptors',type='structs'] -- The sname:VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.adoc[] The members of the sname:VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT structure describe the following features: * [[features-imageSlicedViewOf3D]] pname:imageSlicedViewOf3D indicates that the implementation supports using a sliced view of a 3D image in a descriptor of type ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE by using a slink:VkImageViewSlicedCreateInfoEXT structure when creating the view. :refpage: VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.adoc[] -- endif::VK_EXT_image_sliced_view_of_3d[] ifdef::VK_EXT_image_compression_control[] [open,refpage='VkPhysicalDeviceImageCompressionControlFeaturesEXT',desc='Structure describing whether image compression controls can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceImageCompressionControlFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceImageCompressionControlFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-imageCompressionControl]] pname:imageCompressionControl indicates that the implementation supports providing controls for image compression at image creation time. :refpage: VkPhysicalDeviceImageCompressionControlFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceImageCompressionControlFeaturesEXT.adoc[] -- ifdef::VK_EXT_image_compression_control_swapchain[] [open,refpage='VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT',desc='Structure describing whether per-swapchain image compression controls can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-imageCompressionControlSwapchain]] pname:imageCompressionControlSwapchain indicates that the implementation supports controlling image controls per swapchain and querying image compression properties per surface. :refpage: VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.adoc[] -- endif::VK_EXT_image_compression_control_swapchain[] endif::VK_EXT_image_compression_control[] ifdef::VK_KHR_ray_tracing_position_fetch[] [open,refpage='VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR',desc='Structure describing support for fetching vertex positions of hit triangles',type='structs'] -- The sname:VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-rayTracingPositionFetch]] pname:rayTracingPositionFetch indicates that the implementation supports fetching the object space vertex positions of a hit triangle. :refpage: VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.adoc[] -- endif::VK_KHR_ray_tracing_position_fetch[] ifdef::VK_AMD_shader_early_and_late_fragment_tests[] [open,refpage='VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD',desc='Structure describing whether early and late fragment tests can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderEarlyAndLateFragmentTests]] pname:shaderEarlyAndLateFragmentTests indicates whether the implementation supports the code:EarlyAndLateFragmentTestsAMD {ExecutionMode}. :refpage: VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.adoc[] -- endif::VK_AMD_shader_early_and_late_fragment_tests[] ifdef::VK_EXT_non_seamless_cube_map[] [open,refpage='VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT',desc='Structure describing features to disable seamless cube maps',type='structs'] -- The sname:VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-nonSeamlessCubeMap]] pname:nonSeamlessCubeMap indicates that the implementation supports ename:VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT. :refpage: VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.adoc[] -- endif::VK_EXT_non_seamless_cube_map[] ifdef::VK_EXT_shader_module_identifier[] [open,refpage='VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT',desc='Structure describing whether querying and providing an identifier of a shader module is supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderModuleIdentifier]] pname:shaderModuleIdentifier indicates whether the implementation supports querying an identifier of a slink:VkShaderModule or slink:VkShaderModuleCreateInfo structure, and creating pipelines from identifiers only. :refpage: VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.adoc[] -- endif::VK_EXT_shader_module_identifier[] ifdef::VK_QCOM_tile_properties[] [open,refpage='VkPhysicalDeviceTilePropertiesFeaturesQCOM',desc='Structure describing tile properties features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceTilePropertiesFeaturesQCOM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceTilePropertiesFeaturesQCOM.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-tileProperties]] pname:tileProperties indicates that the implementation supports queries for returning tile properties. :refpage: VkPhysicalDeviceTilePropertiesFeaturesQCOM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceTilePropertiesFeaturesQCOM.adoc[] -- endif::VK_QCOM_tile_properties[] ifdef::VK_QCOM_image_processing[] [open,refpage='VkPhysicalDeviceImageProcessingFeaturesQCOM',desc='Structure describing image processing features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceImageProcessingFeaturesQCOM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceImageProcessingFeaturesQCOM.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-textureSampleWeighted]] pname:textureSampleWeighted indicates that the implementation supports shader modules that declare the pname:TextureSampleWeightedQCOM capability. * [[features-textureBoxFilter]] pname:textureBoxFilter indicates that the implementation supports shader modules that declare the pname:TextureBoxFilterQCOM capability. * [[features-textureBlockMatch]] pname:textureBlockMatch indicates that the implementation supports shader modules that declare the pname:TextureBlockMatchQCOM capability. :refpage: VkPhysicalDeviceImageProcessingFeaturesQCOM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceImageProcessingFeaturesQCOM.adoc[] -- endif::VK_QCOM_image_processing[] ifdef::VK_QCOM_image_processing2[] [open,refpage='VkPhysicalDeviceImageProcessing2FeaturesQCOM',desc='Structure describing image processing features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceImageProcessing2FeaturesQCOM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceImageProcessing2FeaturesQCOM.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-textureBlockMatch2]] pname:textureBlockMatch2 indicates that the implementation supports shader modules that declare the code:TextureBlockMatch2QCOM capability. :refpage: VkPhysicalDeviceImageProcessing2FeaturesQCOM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceImageProcessing2FeaturesQCOM.adoc[] -- endif::VK_QCOM_image_processing2[] ifdef::VK_EXT_depth_clamp_zero_one[] [open,refpage='VkPhysicalDeviceDepthClampZeroOneFeaturesEXT',desc='Structure describing feature to control zero to one depth clamping',type='structs'] -- The sname:VkPhysicalDeviceDepthClampZeroOneFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDepthClampZeroOneFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-depthClampZeroOne]] pname:depthClampZeroOne indicates that the implementation supports clamping the depth to a range of `0` to `1`. :refpage: VkPhysicalDeviceDepthClampZeroOneFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDepthClampZeroOneFeaturesEXT.adoc[] -- endif::VK_EXT_depth_clamp_zero_one[] ifdef::VK_EXT_shader_tile_image[] [open,refpage='VkPhysicalDeviceShaderTileImageFeaturesEXT',desc='Structure describing tile image features supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderTileImageFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderTileImageFeaturesEXT.adoc[] The members of the sname:VkPhysicalDeviceShaderTileImageFeaturesEXT structure describe the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderTileImageColorReadAccess]] pname:shaderTileImageColorReadAccess indicates that the implementation supports the code:TileImageColorReadAccessEXT SPIR-V capability. * [[features-shaderTileImageDepthReadAccess]] pname:shaderTileImageDepthReadAccess indicates that the implementation supports the code:TileImageDepthReadAccessEXT SPIR-V capability. * [[features-shaderTileImageStencilReadAccess]] pname:shaderTileImageStencilReadAccess indicates that the implementation supports the code:TileImageStencilReadAccessEXT SPIR-V capability. :refpage: VkPhysicalDeviceShaderTileImageFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderTileImageFeaturesEXT.adoc[] -- endif::VK_EXT_shader_tile_image[] ifdef::VK_EXT_depth_bias_control[] [open,refpage='VkPhysicalDeviceDepthBiasControlFeaturesEXT',desc='Structure indicating support for depth bias scaling and representation control',type='structs'] -- The sname:VkPhysicalDeviceDepthBiasControlFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDepthBiasControlFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-depthBiasControl]] pname:depthBiasControl indicates whether the implementation supports the fname:vkCmdSetDepthBias2EXT command and the sname:VkDepthBiasRepresentationInfoEXT structure. * [[features-leastRepresentableValueForceUnormRepresentation]] pname:leastRepresentableValueForceUnormRepresentation indicates whether the implementation supports using the ename:VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT depth bias representation. * [[features-floatRepresentation]] pname:floatRepresentation indicates whether the implementation supports using the ename:VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT depth bias representation. * [[features-depthBiasExact]] pname:depthBiasExact indicates whether the implementation supports forcing depth bias to not be scaled to ensure a minimum resolvable difference using sname:VkDepthBiasRepresentationInfoEXT::pname:depthBiasExact. include::{generated}/validity/structs/VkPhysicalDeviceDepthBiasControlFeaturesEXT.adoc[] -- endif::VK_EXT_depth_bias_control[] ifdef::VK_EXT_device_address_binding_report[] [open,refpage='VkPhysicalDeviceAddressBindingReportFeaturesEXT',desc='Structure describing the virtual allocation reporting feature supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceAddressBindingReportFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceAddressBindingReportFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-reportAddressBinding]] pname:reportAddressBinding indicates whether this implementation supports reporting the binding of GPU virtual address ranges to Vulkan objects. :refpage: VkPhysicalDeviceAddressBindingReportFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceAddressBindingReportFeaturesEXT.adoc[] -- endif::VK_EXT_device_address_binding_report[] ifdef::VK_NV_optical_flow[] [open,refpage='VkPhysicalDeviceOpticalFlowFeaturesNV',desc='Structure describing the optical flow features supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceOpticalFlowFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceOpticalFlowFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-opticalFlow]] pname:opticalFlow indicates whether the implementation supports optical flow. :refpage: VkPhysicalDeviceOpticalFlowFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceOpticalFlowFeaturesNV.adoc[] -- endif::VK_NV_optical_flow[] ifdef::VK_EXT_device_fault[] [open,refpage='VkPhysicalDeviceFaultFeaturesEXT',desc='Structure indicating support for device fault reporting',type='structs'] -- The sname:VkPhysicalDeviceFaultFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFaultFeaturesEXT.adoc[] The members of the sname:VkPhysicalDeviceFaultFeaturesEXT structure describe the following features: * [[features-deviceFault]] pname:deviceFault indicates that the implementation supports the reporting of device fault information. * [[features-deviceFaultVendorBinary]] pname:deviceFaultVendorBinary indicates that the implementation supports the generation of vendor-specific binary crash dumps. These may provide additional information when imported into vendor-specific external tools. :refpage: VkPhysicalDeviceFaultFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceFaultFeaturesEXT.adoc[] -- endif::VK_EXT_device_fault[] ifdef::VK_EXT_pipeline_library_group_handles[] [open,refpage='VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT',desc='Structure describing whether querying shader group handles from a pipeline library is supported by the implementation',type='structs'] -- The sname:VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.adoc[] This structure describes the following features: * [[features-pipelineLibraryGroupHandles]] pname:pipelineLibraryGroupHandles indicates whether the implementation supports querying group handles directly from a ray tracing pipeline library, and guarantees bitwise identical group handles for such libraries when linked into other pipelines. :refpage: VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.adoc[] -- endif::VK_EXT_pipeline_library_group_handles[] ifdef::VK_EXT_shader_object[] [open,refpage='VkPhysicalDeviceShaderObjectFeaturesEXT',desc='Structure describing whether shader objects can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderObjectFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderObjectFeaturesEXT.adoc[] This structure describes the following feature: * [[features-shaderObject]] pname:shaderObject indicates whether the implementation supports <>. :refpage: VkPhysicalDeviceShaderObjectFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderObjectFeaturesEXT.adoc[] -- endif::VK_EXT_shader_object[] ifdef::VK_ARM_shader_core_builtins[] [open,refpage='VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM',desc='Structure describing the shader core builtins features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-shaderCoreBuiltins]] pname:shaderCoreBuiltins indicates whether the implementation supports the SPIR-V code:CoreBuiltinsARM capability. :refpage: VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.adoc[] -- endif::VK_ARM_shader_core_builtins[] ifdef::VK_EXT_frame_boundary[] [open,refpage='VkPhysicalDeviceFrameBoundaryFeaturesEXT',desc='Structure describing the frame boundary features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceFrameBoundaryFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceFrameBoundaryFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-frameBoundary]] pname:frameBoundary indicates whether the implementation supports frame boundary information. :refpage: VkPhysicalDeviceFrameBoundaryFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceFrameBoundaryFeaturesEXT.adoc[] -- endif::VK_EXT_frame_boundary[] ifdef::VK_EXT_swapchain_maintenance1[] [open,refpage='VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT',desc='Structure describing whether implementation supports swapchain maintenance1 functionality',type='structs'] -- The sname:VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-swapchainMaintenance1]] pname:swapchainMaintenance1 indicates that the implementation supports the following: ** slink:VkSwapchainPresentFenceInfoEXT, specifying a fence that is signaled when the resources associated with a present operation can: be safely destroyed. ** slink:VkSwapchainPresentModesCreateInfoEXT and slink:VkSwapchainPresentModeInfoEXT, allowing the swapchain to switch present modes without a need for recreation. ** slink:VkSwapchainPresentScalingCreateInfoEXT, specifying the scaling behavior of the swapchain in presence of window resizing. ** The ename:VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT flag, allowing the implementation to defer the allocation of swapchain image memory until first acquisition. ** flink:vkReleaseSwapchainImagesEXT, allowing acquired swapchain images to be released without presenting them. :refpage: VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.adoc[] -- endif::VK_EXT_swapchain_maintenance1[] ifdef::VK_EXT_dynamic_rendering_unused_attachments[] [open,refpage='VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT',desc='Structure describing the dynamic rendering unused attachment features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-dynamicRenderingUnusedAttachments]] pname:dynamicRenderingUnusedAttachments indicates that the implementation supports binding graphics pipelines within a render pass instance where any pipeline slink:VkPipelineRenderingCreateInfo::pname:pColorAttachmentFormats element with a format other than ename:VK_FORMAT_UNDEFINED is allowed with a corresponding slink:VkRenderingInfo::pname:pColorAttachments element with a pname:imageView equal to dlink:VK_NULL_HANDLE, or any pipeline slink:VkPipelineRenderingCreateInfo::pname:pColorAttachmentFormats element with a ename:VK_FORMAT_UNDEFINED format is allowed with a corresponding slink:VkRenderingInfo::pname:pColorAttachments element with a non-dlink:VK_NULL_HANDLE pname:imageView. Also a slink:VkPipelineRenderingCreateInfo::pname:depthAttachmentFormat other than ename:VK_FORMAT_UNDEFINED is allowed with a dlink:VK_NULL_HANDLE slink:VkRenderingInfo::pname:pDepthAttachment, or a slink:VkPipelineRenderingCreateInfo::pname:depthAttachmentFormat of ename:VK_FORMAT_UNDEFINED is allowed with a non-dlink:VK_NULL_HANDLE slink:VkRenderingInfo::pname:pDepthAttachment. Also a slink:VkPipelineRenderingCreateInfo::pname:stencilAttachmentFormat other than ename:VK_FORMAT_UNDEFINED is allowed with a dlink:VK_NULL_HANDLE slink:VkRenderingInfo::pname:pStencilAttachment, or a slink:VkPipelineRenderingCreateInfo::pname:stencilAttachmentFormat of ename:VK_FORMAT_UNDEFINED is allowed with a non-dlink:VK_NULL_HANDLE slink:VkRenderingInfo::pname:pStencilAttachment. Any writes to a slink:VkRenderingInfo::pname:pColorAttachments, slink:VkRenderingInfo::pname:pDepthAttachment, or slink:VkRenderingInfo::pname:pStencilAttachment with dlink:VK_NULL_HANDLE are discarded. :refpage: VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.adoc[] -- endif::VK_EXT_dynamic_rendering_unused_attachments[] ifdef::VK_NV_ray_tracing_invocation_reorder[] [open,refpage='VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV',desc='Structure describing feature to control ray tracing invocation reordering',type='structs'] -- The sname:VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-rayTracingInvocationReorder]] pname:rayTracingInvocationReorder indicates that the implementation supports `SPV_NV_shader_invocation_reorder`. :refpage: VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.adoc[] -- endif::VK_NV_ray_tracing_invocation_reorder[] ifdef::VK_NV_extended_sparse_address_space[] [open,refpage='VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV',desc='Structure describing feature to use extended sparse address space',type='structs'] -- The sname:VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-extendedSparseAddressSpace]] pname:extendedSparseAddressSpace indicates that the implementation supports allowing certain usages of sparse memory resources to exceed sname:VkPhysicalDeviceLimits::pname:sparseAddressSpaceSize. See slink:VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV. :refpage: VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.adoc[] -- endif::VK_NV_extended_sparse_address_space[] ifdef::VK_QCOM_multiview_per_view_viewports[] [open,refpage='VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM',desc='Structure describing multiview per view viewports features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.adoc[] This structure describes the following features: * [[features-multiview-per-view-viewports]] pname:multiviewPerViewViewports indicates that the implementation supports multiview per-view viewports. :refpage: VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.adoc[] -- endif::VK_QCOM_multiview_per_view_viewports[] ifdef::VK_QCOM_multiview_per_view_render_areas[] [open,refpage='VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM',desc='Structure describing multiview per view render areas features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.adoc[] This structure describes the following features: * [[features-multiview-per-view-render-areas]] pname:multiviewPerViewRenderAreas indicates that the implementation supports multiview per-view render areas. :refpage: VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.adoc[] -- endif::VK_QCOM_multiview_per_view_render_areas[] ifdef::VK_HUAWEI_cluster_culling_shader[] [open,refpage='VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI',desc='Structure describing whether cluster culling shader is enabled',type='structs'] -- The sname:VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.adoc[] * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-clustercullingShader]] pname:clustercullingShader specifies whether cluster culling shader is supported. * [[features-multiviewClusterCullingShader]] pname:multiviewClusterCullingShader specifies whether multiview is supported. :refpage: VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.adoc[] -- endif::VK_HUAWEI_cluster_culling_shader[] ifdef::VK_AMDX_shader_enqueue[] [open,refpage='VkPhysicalDeviceShaderEnqueueFeaturesAMDX',desc='Structure describing whether shader enqueue within execution graphs are supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceShaderEnqueueFeaturesAMDX structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceShaderEnqueueFeaturesAMDX.adoc[] This structure describes the following feature: * [[features-shaderEnqueue]] pname:shaderEnqueue indicates whether the implementation supports <>. :refpage: VkPhysicalDeviceShaderEnqueueFeaturesAMDX include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceShaderEnqueueFeaturesAMDX.adoc[] -- endif::VK_AMDX_shader_enqueue[] ifdef::VK_QCOM_filter_cubic_clamp[] [open,refpage='VkPhysicalDeviceCubicClampFeaturesQCOM',desc='Structure describing cubic clamp features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceCubicClampFeaturesQCOM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCubicClampFeaturesQCOM.adoc[] This structure describes the following features: * [[features-filter-cubic-range-clamp]] pname:cubicRangeClamp indicates that the implementation supports cubic filtering in combination with a <>. :refpage: VkPhysicalDeviceCubicClampFeaturesQCOM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCubicClampFeaturesQCOM.adoc[] -- endif::VK_QCOM_filter_cubic_clamp[] ifdef::VK_QCOM_ycbcr_degamma[] [open,refpage='VkPhysicalDeviceYcbcrDegammaFeaturesQCOM',desc='Structure describing {YCbCr} degamma features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceYcbcrDegammaFeaturesQCOM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.adoc[] This structure describes the following features: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-ycbcr-degamma]] pname:ycbcrDegamma indicates whether the implementation supports <>. :refpage: VkPhysicalDeviceYcbcrDegammaFeaturesQCOM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.adoc[] -- endif::VK_QCOM_ycbcr_degamma[] ifdef::VK_QCOM_filter_cubic_weights[] [open,refpage='VkPhysicalDeviceCubicWeightsFeaturesQCOM',desc='Structure describing cubic weight selection features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceCubicWeightsFeaturesQCOM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCubicWeightsFeaturesQCOM.adoc[] This structure describes the following feature: * [[features-filter-cubic-weight-selection]] pname:selectableCubicWeights indicates that the implementation supports the selection of filter cubic weights. :refpage: VkPhysicalDeviceCubicWeightsFeaturesQCOM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCubicWeightsFeaturesQCOM.adoc[] -- endif::VK_QCOM_filter_cubic_weights[] ifdef::VK_NV_descriptor_pool_overallocation[] [open,refpage='VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV',desc='Structure describing feature to allow descriptor pool overallocation',type='structs'] -- The sname:VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.adoc[] This structure describes the following feature: * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-descriptorPoolOverallocation]] pname:descriptorPoolOverallocation indicates that the implementation allows the application to opt into descriptor pool overallocation by creating the descriptor pool with ename:VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV and/or ename:VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV flags. :refpage: VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.adoc[] -- endif::VK_NV_descriptor_pool_overallocation[] ifdef::VK_NV_cuda_kernel_launch[] [open,refpage='VkPhysicalDeviceCudaKernelLaunchFeaturesNV',desc='Structure describing whether cuda kernel launch is supported by the implementation',type='structs'] -- The sname:VkPhysicalDeviceCudaKernelLaunchFeaturesNV structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceCudaKernelLaunchFeaturesNV.adoc[] This structure describes the following features: * [[features-cudaKernelLaunchFeatures]] pname:cudaKernelLaunchFeatures is non-zero if cuda kernel launch is supported. :refpage: VkPhysicalDeviceCudaKernelLaunchFeaturesNV include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceCudaKernelLaunchFeaturesNV.adoc[] -- endif::VK_NV_cuda_kernel_launch[] ifdef::VK_ANDROID_external_format_resolve[] [open,refpage='VkPhysicalDeviceExternalFormatResolveFeaturesANDROID',desc='Structure describing whether external format resolves are supported',type='structs'] -- The sname:VkPhysicalDeviceExternalFormatResolveFeaturesANDROID structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.adoc[] * pname:sType is a elink:VkStructureType value identifying this structure. * pname:pNext is `NULL` or a pointer to a structure extending this structure. * [[features-externalFormatResolve]] pname:externalFormatResolve specifies whether external format resolves are supported. :refpage: VkPhysicalDeviceExternalFormatResolveFeaturesANDROID include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.adoc[] -- endif::VK_ANDROID_external_format_resolve[] ifdef::VK_ARM_scheduling_controls[] [open,refpage='VkPhysicalDeviceSchedulingControlsFeaturesARM',desc='Structure describing scheduling controls features that can be supported by an implementation',type='structs'] -- The sname:VkPhysicalDeviceSchedulingControlsFeaturesARM structure is defined as: include::{generated}/api/structs/VkPhysicalDeviceSchedulingControlsFeaturesARM.adoc[] This structure describes the following features: * [[features-schedulingControls]] pname:schedulingControls indicates that the implementation supports scheduling controls. :refpage: VkPhysicalDeviceSchedulingControlsFeaturesARM include::{chapters}/features.adoc[tag=features] include::{generated}/validity/structs/VkPhysicalDeviceSchedulingControlsFeaturesARM.adoc[] -- endif::VK_ARM_scheduling_controls[] [[features-requirements]] == Feature Requirements All Vulkan graphics implementations must: support the following features: ifdef::VK_KHR_portability_subset[] * <>, unless the `apiext:VK_KHR_portability_subset` extension is enabled. endif::VK_KHR_portability_subset[] ifndef::VK_KHR_portability_subset[] * <> endif::VK_KHR_portability_subset[] ifdef::VK_VERSION_1_1[] * <>, if Vulkan 1.1 is supported. ifdef::VKSC_VERSION_1_0[] Vulkan SC 1.0 does not require pname:multiview to be supported <>. ifdef::hidden[] // tag::scdeviation[] * slink:VkPhysicalDeviceVulkan11Features::pname:multiview is made optional <>. // end::scdeviation[] endif::hidden[] endif::VKSC_VERSION_1_0[] ifdef::VK_KHR_shader_draw_parameters[] * <>, if the `apiext:VK_KHR_shader_draw_parameters` extension is supported. endif::VK_KHR_shader_draw_parameters[] endif::VK_VERSION_1_1[] ifdef::VK_VERSION_1_2,VK_KHR_uniform_buffer_standard_layout[] * <>, if Vulkan 1.2 or the `apiext:VK_KHR_uniform_buffer_standard_layout` extension is supported. endif::VK_VERSION_1_2,VK_KHR_uniform_buffer_standard_layout[] ifdef::VK_KHR_variable_pointers[] * <>, if the `apiext:VK_KHR_variable_pointers` extension is supported. endif::VK_KHR_variable_pointers[] ifdef::VK_KHR_8bit_storage[] * <>, if the `apiext:VK_KHR_8bit_storage` extension is supported. endif::VK_KHR_8bit_storage[] ifdef::VK_VERSION_1_2,VK_KHR_8bit_storage[] * <>, if <> is enabled. endif::VK_VERSION_1_2,VK_KHR_8bit_storage[] ifdef::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] * If ifdef::VK_VERSION_1_2[the <> feature is supported, or if] the `apiext:VK_EXT_descriptor_indexing` extension is supported: ** <> ** <> ** <> ** <> ** <> ** <> ** <> ** <> ** <> ** <> (see also <>) ** <> (see also <>) ** <> (see also <>) ** <> ** <> ** <> endif::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] ifdef::VK_VERSION_1_3[] * If Vulkan 1.3 is supported: ** <> ** <> endif::VK_VERSION_1_3[] ifdef::VK_VERSION_1_3,VK_EXT_inline_uniform_block[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_EXT_inline_uniform_block` extension is supported. ifdef::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_EXT_inline_uniform_block` extension is supported; and if ifdef::VK_VERSION_1_2[the <> feature is supported, or] the `apiext:VK_EXT_descriptor_indexing` extension is supported. endif::VK_VERSION_1_2,VK_EXT_descriptor_indexing[] endif::VK_VERSION_1_3,VK_EXT_inline_uniform_block[] ifdef::VK_EXT_scalar_block_layout[] * <>, if the `apiext:VK_EXT_scalar_block_layout` extension is supported. endif::VK_EXT_scalar_block_layout[] ifdef::VK_VERSION_1_2[] * <>, if Vulkan 1.2 is supported. endif::VK_VERSION_1_2[] ifdef::VK_VERSION_1_2+VK_KHR_sampler_mirror_clamp_to_edge[] * <>, if the `apiext:VK_KHR_sampler_mirror_clamp_to_edge` extension is supported. endif::VK_VERSION_1_2+VK_KHR_sampler_mirror_clamp_to_edge[] ifdef::VK_VERSION_1_2+VK_KHR_draw_indirect_count[] * <>, if the `apiext:VK_KHR_draw_indirect_count` extension is supported. endif::VK_VERSION_1_2+VK_KHR_draw_indirect_count[] ifdef::VK_VERSION_1_2+VK_EXT_sampler_filter_minmax[] * <>, if the `apiext:VK_EXT_sampler_filter_minmax` extension is supported. endif::VK_VERSION_1_2+VK_EXT_sampler_filter_minmax[] ifdef::VK_VERSION_1_2+VK_EXT_shader_viewport_index_layer[] * <>, if the `apiext:VK_EXT_shader_viewport_index_layer` extension is supported. * <>, if the `apiext:VK_EXT_shader_viewport_index_layer` extension is supported. endif::VK_VERSION_1_2+VK_EXT_shader_viewport_index_layer[] ifdef::VK_VERSION_1_3,VK_EXT_subgroup_size_control[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_EXT_subgroup_size_control` extension is supported. * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_EXT_subgroup_size_control` extension is supported. endif::VK_VERSION_1_3,VK_EXT_subgroup_size_control[] ifdef::VK_EXT_device_memory_report[] * <>, if the `apiext:VK_EXT_device_memory_report` extension is supported. endif::VK_EXT_device_memory_report[] ifdef::VK_EXT_global_priority_query[] * <>, if the `apiext:VK_EXT_global_priority_query` extension is supported. endif::VK_EXT_global_priority_query[] ifdef::VK_KHR_global_priority[] * <>, if the `apiext:VK_KHR_global_priority` extension is supported. endif::VK_KHR_global_priority[] ifdef::VK_VERSION_1_2,VK_KHR_imageless_framebuffer[] * <>, if Vulkan 1.2 or the `apiext:VK_KHR_imageless_framebuffer` extension is supported. endif::VK_VERSION_1_2,VK_KHR_imageless_framebuffer[] ifdef::VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts[] * <>, if Vulkan 1.2 or the `apiext:VK_KHR_separate_depth_stencil_layouts` extension is supported. endif::VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts[] ifdef::VK_VERSION_1_2,VK_EXT_host_query_reset[] * <>, if Vulkan 1.2 or the `apiext:VK_EXT_host_query_reset` extension is supported. endif::VK_VERSION_1_2,VK_EXT_host_query_reset[] ifdef::VK_VERSION_1_2,VK_KHR_timeline_semaphore[] * <>, if Vulkan 1.2 or the `apiext:VK_KHR_timeline_semaphore` extension is supported. ifdef::VKSC_VERSION_1_0[] Vulkan SC 1.0 does not require pname:timelineSemaphore to be supported <>. ifdef::hidden[] // tag::scdeviation[] * slink:VkPhysicalDeviceVulkan12Features::pname:timelineSemaphore is made optional <>. // end::scdeviation[] endif::hidden[] endif::VKSC_VERSION_1_0[] endif::VK_VERSION_1_2,VK_KHR_timeline_semaphore[] ifdef::VK_KHR_acceleration_structure[] * If the `apiext:VK_KHR_acceleration_structure` extension is supported: ** <> ** All the features required by ifdef::VK_VERSION_1_2[the <> feature if Vulkan 1.2 is supported, or] the `apiext:VK_EXT_descriptor_indexing` extension. ** <> ** <> from ifdef::VK_VERSION_1_2[Vulkan 1.2 or] the `apiext:VK_KHR_buffer_device_address` extension. endif::VK_KHR_acceleration_structure[] ifdef::VK_KHR_ray_tracing_pipeline[] * If the `apiext:VK_KHR_ray_tracing_pipeline` extension is supported: ** <> ** <> ** <>, if <> is supported ** the `apiext:VK_KHR_pipeline_library` extension must: be supported. endif::VK_KHR_ray_tracing_pipeline[] ifdef::VK_KHR_ray_query[] * <>, if the `apiext:VK_KHR_ray_query` extension is supported. endif::VK_KHR_ray_query[] ifdef::VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_EXT_pipeline_creation_cache_control` extension is supported. endif::VK_VERSION_1_3,VK_EXT_pipeline_creation_cache_control[] ifdef::VK_VERSION_1_2,VK_KHR_shader_subgroup_extended_types[] * <>, if Vulkan 1.2 or the `apiext:VK_KHR_shader_subgroup_extended_types` extension is supported. endif::VK_VERSION_1_2,VK_KHR_shader_subgroup_extended_types[] ifdef::VK_KHR_sampler_ycbcr_conversion[] * <>, if the `apiext:VK_KHR_sampler_ycbcr_conversion` extension is supported. endif::VK_KHR_sampler_ycbcr_conversion[] ifdef::VK_KHR_pipeline_executable_properties[] * <>, if the `apiext:VK_KHR_pipeline_executable_properties` extension is supported. endif::VK_KHR_pipeline_executable_properties[] ifdef::VK_VERSION_1_3,VK_EXT_texture_compression_astc_hdr[] * <>, if the `apiext:VK_EXT_texture_compression_astc_hdr` extension is supported. endif::VK_VERSION_1_3,VK_EXT_texture_compression_astc_hdr[] ifdef::VK_EXT_depth_clip_enable[] * <>, if the `apiext:VK_EXT_depth_clip_enable` extension is supported. endif::VK_EXT_depth_clip_enable[] ifdef::VK_EXT_memory_priority[] * <>, if the `apiext:VK_EXT_memory_priority` extension is supported. endif::VK_EXT_memory_priority[] ifdef::VK_EXT_ycbcr_image_arrays[] * <>, if the `apiext:VK_EXT_ycbcr_image_arrays` extension is supported. endif::VK_EXT_ycbcr_image_arrays[] ifdef::VK_EXT_index_type_uint8[] * <>, if the `apiext:VK_EXT_index_type_uint8` extension is supported. endif::VK_EXT_index_type_uint8[] ifdef::VK_EXT_primitive_topology_list_restart[] * <>, if the `apiext:VK_EXT_primitive_topology_list_restart` extension is supported. endif::VK_EXT_primitive_topology_list_restart[] ifdef::VK_VERSION_1_3,VK_EXT_shader_demote_to_helper_invocation[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_EXT_shader_demote_to_helper_invocation` extension is supported. endif::VK_VERSION_1_3,VK_EXT_shader_demote_to_helper_invocation[] ifdef::VK_VERSION_1_3,VK_EXT_texel_buffer_alignment[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_EXT_texel_buffer_alignment` extension is supported. endif::VK_VERSION_1_3,VK_EXT_texel_buffer_alignment[] ifdef::VK_KHR_vulkan_memory_model,VKSC_VERSION_1_0[] * <>, ifdef::VKSC_VERSION_1_0[] if Vulkan SC 1.0 <> or ifdef::hidden[] // tag::scdeviation[] * slink:VkPhysicalDeviceVulkan12Features::pname:vulkanMemoryModel must: be reported as ename:VK_TRUE <>. // end::scdeviation[] endif::hidden[] endif::VKSC_VERSION_1_0[] if the `apiext:VK_KHR_vulkan_memory_model` extension is supported. endif::VK_KHR_vulkan_memory_model,VKSC_VERSION_1_0[] ifdef::VK_VERSION_1_3,VK_KHR_buffer_device_address[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_KHR_buffer_device_address` extension is supported. endif::VK_VERSION_1_3,VK_KHR_buffer_device_address[] ifdef::VK_KHR_performance_query[] * <>, if the `apiext:VK_KHR_performance_query` extension is supported. endif::VK_KHR_performance_query[] ifdef::VK_EXT_transform_feedback[] * <>, if the `apiext:VK_EXT_transform_feedback` extension is supported. endif::VK_EXT_transform_feedback[] ifdef::VK_EXT_conditional_rendering[] * <>, if the `apiext:VK_EXT_conditional_rendering` extension is supported. endif::VK_EXT_conditional_rendering[] ifdef::VK_EXT_vertex_attribute_divisor[] * <>, if the `apiext:VK_EXT_vertex_attribute_divisor` extension is supported. endif::VK_EXT_vertex_attribute_divisor[] ifdef::VK_EXT_fragment_density_map[] * <>, if the `apiext:VK_EXT_fragment_density_map` extension is supported. endif::VK_EXT_fragment_density_map[] ifdef::VK_KHR_shader_clock[] * <>, if the `apiext:VK_KHR_shader_clock` extension is supported. endif::VK_KHR_shader_clock[] ifdef::VK_KHR_shader_atomic_int64[] * <>, if the `apiext:VK_KHR_shader_atomic_int64` extension is supported. endif::VK_KHR_shader_atomic_int64[] ifdef::VK_VERSION_1_2,VK_KHR_shader_atomic_int64[] * <>, if the <> or <> features are supported. endif::VK_VERSION_1_2,VK_KHR_shader_atomic_int64[] ifdef::VK_KHR_shader_float16_int8[] * <> or <>, if the `apiext:VK_KHR_shader_float16_int8` extension is supported. endif::VK_KHR_shader_float16_int8[] ifdef::VK_EXT_fragment_shader_interlock[] * <> or <> or <>, if the `apiext:VK_EXT_fragment_shader_interlock` extension is supported. endif::VK_EXT_fragment_shader_interlock[] ifdef::VK_EXT_line_rasterization[] * <> or <> or <> or <> or <> or <>, if the `apiext:VK_EXT_line_rasterization` extension is supported. endif::VK_EXT_line_rasterization[] ifdef::VK_KHR_16bit_storage[] * <>, if the `apiext:VK_KHR_16bit_storage` extension is supported. endif::VK_KHR_16bit_storage[] ifdef::VK_VERSION_1_1,VK_KHR_16bit_storage[] * <>, if <> is enabled. endif::VK_VERSION_1_1,VK_KHR_16bit_storage[] ifdef::VK_VERSION_1_3,VK_EXT_image_robustness[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_EXT_image_robustness` extension is supported. endif::VK_VERSION_1_3,VK_EXT_image_robustness[] ifdef::VK_EXT_4444_formats[] * <>, if the `apiext:VK_EXT_4444_formats` extension is supported. endif::VK_EXT_4444_formats[] ifdef::VK_EXT_mutable_descriptor_type,VK_VALVE_mutable_descriptor_type[] * <>, if the `apiext:VK_EXT_mutable_descriptor_type` or `apiext:VK_VALVE_mutable_descriptor_type` extension is supported. endif::VK_EXT_mutable_descriptor_type,VK_VALVE_mutable_descriptor_type[] ifdef::VK_EXT_shader_image_atomic_int64[] * <> and <>, if the `apiext:VK_EXT_shader_image_atomic_int64` extension is supported. * <>, if the <> feature is supported. endif::VK_EXT_shader_image_atomic_int64[] ifdef::VK_EXT_shader_atomic_float[] * <>, if the <> feature is supported. * <>, if the <> feature is supported. endif::VK_EXT_shader_atomic_float[] ifdef::VK_EXT_primitives_generated_query[] * <>, if the `apiext:VK_EXT_primitives_generated_query` extension is supported. endif::VK_EXT_primitives_generated_query[] ifdef::VK_KHR_fragment_shading_rate[] * <>, if the `apiext:VK_KHR_fragment_shading_rate` extension is supported. endif::VK_KHR_fragment_shading_rate[] ifdef::VK_EXT_pipeline_protected_access[] * <>, if the `apiext:VK_EXT_pipeline_protected_access` extension is supported. endif::VK_EXT_pipeline_protected_access[] ifdef::VK_EXT_legacy_dithering[] * <>, if the `apiext:VK_EXT_legacy_dithering` extension is supported. endif::VK_EXT_legacy_dithering[] ifdef::VK_VERSION_1_3,VK_KHR_shader_terminate_invocation[] * <> if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_KHR_shader_terminate_invocation` extension is supported. endif::VK_VERSION_1_3,VK_KHR_shader_terminate_invocation[] ifdef::VK_VERSION_1_3,VK_KHR_zero_initialize_workgroup_memory[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_KHR_zero_initialize_workgroup_memory` extension is supported. endif::VK_VERSION_1_3,VK_KHR_zero_initialize_workgroup_memory[] ifdef::VK_KHR_workgroup_memory_explicit_layout[] * <>, if the `apiext:VK_KHR_workgroup_memory_explicit_layout` extension is supported. endif::VK_KHR_workgroup_memory_explicit_layout[] ifdef::VK_EXT_vertex_input_dynamic_state[] * <>, if the `apiext:VK_EXT_vertex_input_dynamic_state` extension is supported. endif::VK_EXT_vertex_input_dynamic_state[] ifdef::VK_VERSION_1_3,VK_KHR_synchronization2[] * <> if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_KHR_synchronization2` extension is supported. endif::VK_VERSION_1_3,VK_KHR_synchronization2[] ifdef::VK_EXT_provoking_vertex[] * <>, if the `apiext:VK_EXT_provoking_vertex` extension is supported. endif::VK_EXT_provoking_vertex[] ifdef::VK_EXT_descriptor_buffer[] * <>, if the `<>` extension is supported. endif::VK_EXT_descriptor_buffer[] ifdef::VK_KHR_shader_subgroup_uniform_control_flow[] * <>, if the `apiext:VK_KHR_shader_subgroup_uniform_control_flow` extension is supported. endif::VK_KHR_shader_subgroup_uniform_control_flow[] ifdef::VK_EXT_border_color_swizzle[] * <> if the `apiext:VK_EXT_border_color_swizzle` extension is supported. endif::VK_EXT_border_color_swizzle[] ifdef::VK_EXT_multi_draw[] * <>, if the `apiext:VK_EXT_multi_draw` extension is supported. endif::VK_EXT_multi_draw[] ifdef::VK_EXT_shader_atomic_float2[] * <>, if the <> feature is supported. endif::VK_EXT_shader_atomic_float2[] ifdef::VK_KHR_present_id[] * <>, if the `apiext:VK_KHR_present_id` extension is supported. endif::VK_KHR_present_id[] ifdef::VK_KHR_present_wait[] * <>, if the `apiext:VK_KHR_present_wait` extension is supported. endif::VK_KHR_present_wait[] ifdef::VK_EXT_host_image_copy[] * <>, if the `<>` extension is supported. endif::VK_EXT_host_image_copy[] ifdef::VK_VERSION_1_3,VK_KHR_shader_integer_dot_product[] * <> if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_KHR_shader_integer_dot_product` extension is supported. endif::VK_VERSION_1_3,VK_KHR_shader_integer_dot_product[] ifdef::VK_VERSION_1_3,VK_KHR_maintenance4[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_KHR_maintenance4` extension is supported. endif::VK_VERSION_1_3,VK_KHR_maintenance4[] ifdef::VK_KHR_maintenance5[] * <>, if the `apiext:VK_KHR_maintenance5` extension is supported. endif::VK_KHR_maintenance5[] ifdef::VK_EXT_image_2d_view_of_3d[] * <>, if the `apiext:VK_EXT_image_2d_view_of_3d` extension is supported. endif::VK_EXT_image_2d_view_of_3d[] ifdef::VK_EXT_image_sliced_view_of_3d[] * <>, if the `apiext:VK_EXT_image_sliced_view_of_3d` extension is supported. endif::VK_EXT_image_sliced_view_of_3d[] ifdef::VK_VERSION_1_3,VK_EXT_private_data[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_EXT_private_data` extension is supported. endif::VK_VERSION_1_3,VK_EXT_private_data[] ifdef::VK_EXT_extended_dynamic_state[] * <>, if the `apiext:VK_EXT_extended_dynamic_state` extension is supported. endif::VK_EXT_extended_dynamic_state[] ifdef::VK_EXT_extended_dynamic_state2[] * <>, if the `apiext:VK_EXT_extended_dynamic_state2` extension is supported. endif::VK_EXT_extended_dynamic_state2[] ifdef::VK_EXT_depth_clip_control[] * <>, if the `apiext:VK_EXT_depth_clip_control` extension is supported. endif::VK_EXT_depth_clip_control[] ifdef::VK_EXT_image_view_min_lod[] * <>, if the `apiext:VK_EXT_image_view_min_lod` extension is supported. endif::VK_EXT_image_view_min_lod[] ifdef::VK_NV_external_sci_sync[] * At least one of <> and <>, and at least one of <> and <>, if the `apiext:VK_NV_external_sci_sync` extension is supported. endif::VK_NV_external_sci_sync[] ifdef::VK_NV_external_sci_sync2[] * At least one of <> and <>, and at least one of <> and <>, if the `apiext:VK_NV_external_sci_sync2` extension is supported. endif::VK_NV_external_sci_sync2[] ifdef::VK_NV_external_memory_sci_buf[] * At least one of <> and <>, if the `apiext:VK_NV_external_memory_sci_buf` extension is supported. endif::VK_NV_external_memory_sci_buf[] ifdef::VK_NV_linear_color_attachment[] * <>, if the `apiext:VK_NV_linear_color_attachment` extension is supported. endif::VK_NV_linear_color_attachment[] ifdef::VK_NV_present_barrier[] * <>, if the `apiext:VK_NV_present_barrier` extension is supported. endif::VK_NV_present_barrier[] ifdef::VK_EXT_graphics_pipeline_library[] * <>, if the `apiext:VK_EXT_graphics_pipeline_library` extension is supported. endif::VK_EXT_graphics_pipeline_library[] ifdef::VK_VERSION_1_3,VK_KHR_dynamic_rendering[] * <>, if ifdef::VK_VERSION_1_3[Vulkan 1.3 or] the `apiext:VK_KHR_dynamic_rendering` extension is supported. endif::VK_VERSION_1_3,VK_KHR_dynamic_rendering[] ifdef::VK_EXT_nested_command_buffer[] * <>, if the `apiext:VK_EXT_nested_command_buffer` extension is supported. endif::VK_EXT_nested_command_buffer[] ifdef::VK_EXT_mesh_shader[] * <> and <>, if the `apiext:VK_EXT_mesh_shader` extension is supported. endif::VK_EXT_mesh_shader[] ifdef::VK_EXT_mesh_shader+VK_KHR_fragment_shading_rate[] * <> if <> feature is supported. endif::VK_EXT_mesh_shader+VK_KHR_fragment_shading_rate[] ifdef::VK_EXT_subpass_merge_feedback[] * <>, if the `apiext:VK_EXT_subpass_merge_feedback` extension is supported. endif::VK_EXT_subpass_merge_feedback[] ifdef::VK_KHR_ray_tracing_maintenance1[] * <>, if the `apiext:VK_KHR_ray_tracing_maintenance1` extension is supported. endif::VK_KHR_ray_tracing_maintenance1[] ifdef::VK_EXT_color_write_enable[] * <>, if the `apiext:VK_EXT_color_write_enable` extension is supported. endif::VK_EXT_color_write_enable[] ifdef::VK_EXT_multisampled_render_to_single_sampled[] * <>, if the `apiext:VK_EXT_multisampled_render_to_single_sampled` extension is supported. endif::VK_EXT_multisampled_render_to_single_sampled[] ifdef::VK_EXT_image_compression_control[] * <>, if the `apiext:VK_EXT_image_compression_control` extension is supported. ifdef::VK_EXT_image_compression_control_swapchain[] * <>, if the `apiext:VK_EXT_image_compression_control_swapchain` extension is supported. endif::VK_EXT_image_compression_control_swapchain[] endif::VK_EXT_image_compression_control[] ifdef::VK_AMD_shader_early_and_late_fragment_tests[] * <>, if the `apiext:VK_AMD_shader_early_and_late_fragment_tests` extension is supported. endif::VK_AMD_shader_early_and_late_fragment_tests[] ifdef::VK_EXT_non_seamless_cube_map[] * <>, if the `apiext:VK_EXT_non_seamless_cube_map` extension is supported. endif::VK_EXT_non_seamless_cube_map[] ifdef::VK_EXT_shader_module_identifier[] * <>, if `apiext:VK_EXT_shader_module_identifier` extension is supported. endif::VK_EXT_shader_module_identifier[] ifdef::VK_EXT_pipeline_robustness[] * <>, if the `apiext:VK_EXT_pipeline_robustness` extension is supported. endif::VK_EXT_pipeline_robustness[] ifdef::VK_QCOM_image_processing[] * <>, <>, and <> if `apiext:VK_QCOM_image_processing` extension is supported. endif::VK_QCOM_image_processing[] ifdef::VK_QCOM_image_processing2[] * <> if `apiext:VK_QCOM_image_processing2` extension is supported. endif::VK_QCOM_image_processing2[] ifdef::VK_QCOM_tile_properties[] * <> if `apiext:VK_QCOM_tile_properties` extension is supported. endif::VK_QCOM_tile_properties[] ifdef::VK_EXT_attachment_feedback_loop_layout[] * <>, if the `apiext:VK_EXT_attachment_feedback_loop_layout` extension is supported. endif::VK_EXT_attachment_feedback_loop_layout[] ifdef::VK_EXT_depth_clamp_zero_one[] * <>, if the `apiext:VK_EXT_depth_clamp_zero_one` extension is supported. endif::VK_EXT_depth_clamp_zero_one[] ifdef::VK_EXT_device_fault[] * <>, if the `apiext:VK_EXT_device_fault` extension is supported. endif::VK_EXT_device_fault[] ifdef::VK_EXT_device_address_binding_report[] * <>, if the `apiext:VK_EXT_device_address_binding_report` extension is supported. endif::VK_EXT_device_address_binding_report[] ifdef::VK_EXT_opacity_micromap[] * <>, if the `apiext:VK_EXT_opacity_micromap` extension is supported. endif::VK_EXT_opacity_micromap[] ifdef::VK_EXT_frame_boundary[] * <>, if the `apiext:VK_EXT_frame_boundary` extension is supported. endif::VK_EXT_frame_boundary[] ifdef::VK_NV_displacement_micromap[] * <>, if the `apiext:VK_NV_displacement_micromap` extension is supported. endif::VK_NV_displacement_micromap[] ifdef::VK_EXT_pipeline_library_group_handles[] * <>, if the `apiext:VK_EXT_pipeline_library_group_handles` extension is supported. endif::VK_EXT_pipeline_library_group_handles[] ifdef::VK_EXT_swapchain_maintenance1[] * <>, if the `apiext:VK_EXT_swapchain_maintenance1` extension is supported. endif::VK_EXT_swapchain_maintenance1[] ifdef::VK_EXT_extended_dynamic_state3[] * <>, if the <> feature is supported. * <>, if the <> feature is supported. * <>, if the <> feature is supported. * <>, if the <> feature is supported. * <>, if the <> feature is supported. ifdef::VK_EXT_transform_feedback[] * <>, if the <> feature is supported. endif::VK_EXT_transform_feedback[] ifdef::VK_EXT_conservative_rasterization[] * `apiext:VK_EXT_conservative_rasterization` extension, if the <> feature is supported. * `apiext:VK_EXT_conservative_rasterization` extension, if the <> feature is supported. endif::VK_EXT_conservative_rasterization[] ifdef::VK_EXT_sample_locations[] * `apiext:VK_EXT_sample_locations` extension, if the <> feature is supported. endif::VK_EXT_sample_locations[] ifdef::VK_EXT_blend_operation_advanced[] * `apiext:VK_EXT_blend_operation_advanced` extension, if the <> feature is supported. endif::VK_EXT_blend_operation_advanced[] ifdef::VK_EXT_provoking_vertex[] * <>, if the <> feature is supported. endif::VK_EXT_provoking_vertex[] ifdef::VK_EXT_line_rasterization[] * `apiext:VK_EXT_line_rasterization` extension, if the <> feature is supported. * `apiext:VK_EXT_line_rasterization` extension, if the <> feature is supported. endif::VK_EXT_line_rasterization[] ifdef::VK_EXT_depth_clip_control[] * <>, if the <> feature is supported. endif::VK_EXT_depth_clip_control[] ifdef::VK_NV_clip_space_w_scaling[] * `apiext:VK_NV_clip_space_w_scaling` extension, if the <> feature is supported. endif::VK_NV_clip_space_w_scaling[] ifdef::VK_NV_viewport_swizzle[] * `apiext:VK_NV_viewport_swizzle` extension, if the <> feature is supported. endif::VK_NV_viewport_swizzle[] ifdef::VK_NV_fragment_coverage_to_color[] * `apiext:VK_NV_fragment_coverage_to_color` extension, if the <> feature is supported. * `apiext:VK_NV_fragment_coverage_to_color` extension, if the <> feature is supported. endif::VK_NV_fragment_coverage_to_color[] ifdef::VK_NV_framebuffer_mixed_samples[] * `apiext:VK_NV_framebuffer_mixed_samples` extension, if the <> feature is supported. * `apiext:VK_NV_framebuffer_mixed_samples` extension, if the <> feature is supported. * `apiext:VK_NV_framebuffer_mixed_samples` extension, if the <> feature is supported. endif::VK_NV_framebuffer_mixed_samples[] ifdef::VK_NV_coverage_reduction_mode[] * <>, if the <> feature is supported. endif::VK_NV_coverage_reduction_mode[] ifdef::VK_NV_representative_fragment_test[] * <>, if the <> feature is supported. endif::VK_NV_representative_fragment_test[] ifdef::VK_NV_shading_rate_image[] * <>, if the <> feature is supported. endif::VK_NV_shading_rate_image[] endif::VK_EXT_extended_dynamic_state3[] ifdef::VK_QCOM_multiview_per_view_viewports[] * <>, if the `apiext:VK_QCOM_multiview_per_view_viewports` extension is supported. endif::VK_QCOM_multiview_per_view_viewports[] ifdef::VK_EXT_attachment_feedback_loop_dynamic_state[] * <>, if the `apiext:VK_EXT_attachment_feedback_loop_dynamic_state` extension is supported. endif::VK_EXT_attachment_feedback_loop_dynamic_state[] ifdef::VK_KHR_ray_tracing_position_fetch[] * <>, if the `apiext:VK_KHR_ray_tracing_position_fetch` extension is supported. endif::VK_KHR_ray_tracing_position_fetch[] ifdef::VK_EXT_shader_object[] * <>, if the `apiext:VK_EXT_shader_object` extension is supported. endif::VK_EXT_shader_object[] ifdef::VK_EXT_shader_tile_image[] * <>, if the `apiext:VK_EXT_shader_tile_image` extension is supported. endif::VK_EXT_shader_tile_image[] ifdef::VK_EXT_depth_bias_control[] * <>, if the `apiext:VK_EXT_depth_bias_control` extension is supported. endif::VK_EXT_depth_bias_control[] ifdef::VK_NV_device_generated_commands_compute[] * <>, if the `apiext:VK_NV_device_generated_commands_compute` extension is supported. endif::VK_NV_device_generated_commands_compute[] ifdef::VK_AMDX_shader_enqueue[] * <> if the `apiext:VK_AMDX_shader_enqueue` extension is supported. endif::VK_AMDX_shader_enqueue[] ifdef::VK_KHR_cooperative_matrix[] * <> if the `apiext:VK_KHR_cooperative_matrix` extension is supported. endif::VK_KHR_cooperative_matrix[] ifdef::VK_QCOM_ycbcr_degamma[] * <>, if the `apiext:VK_QCOM_ycbcr_degamma` extension is supported. endif::VK_QCOM_ycbcr_degamma[] ifdef::VK_NV_descriptor_pool_overallocation[] * <>, if the `apiext:VK_NV_descriptor_pool_overallocation` extension is supported. endif::VK_NV_descriptor_pool_overallocation[] ifdef::VK_ANDROID_external_format_resolve[] * <>, if the `apiext:VK_ANDROID_external_format_resolve` extension is supported. endif::VK_ANDROID_external_format_resolve[] ifdef::VK_NV_extended_sparse_address_space[] * <>, if the `apiext:VK_NV_extended_sparse_address_space` extension is supported. endif::VK_NV_extended_sparse_address_space[] ifdef::VK_ARM_scheduling_controls[] * <>, if the `apiext:VK_ARM_scheduling_controls` extension is supported. endif::VK_ARM_scheduling_controls[] All other features defined in the Specification are optional:. ifdef::VK_VERSION_1_3[] [[profile-features]] == Profile Features [[profile-features-roadmap-2022]] === Roadmap 2022 Implementations that claim support for the <> profile must: support the following features: * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> * <> endif::VK_VERSION_1_3[]