vkGetPhysicalDeviceFeatures(3) ============================== Name ---- vkGetPhysicalDeviceFeatures - Reports capabilities of a physical device. C Specification --------------- include::../protos/vkGetPhysicalDeviceFeatures.txt[] Parameters ---------- pname:physicalDevice:: A handle to the physical device. pname:pFeatures:: A pointer to a structure that will be written with the device feature set. Description ----------- fname:vkGetPhysicalDeviceFeatures returns the set of physical features supported by the physical device whose handle is passed in pname:physicalDevice. This parameter should be a valid handle to a physical device returned from a successful call to flink:vkEnumeratePhysicalDevices. pname:pFeatures is a pointer to an instance of the sname:VkPhysicalDeviceFeatures structure, the definition of which is: include::../structs/VkPhysicalDeviceFeatures.txt[] Each member of the pname:pFeatures structure represents a feature of the underlying physical device. A brief description of the members follows: * *pname:robustBufferAccess* indicates that out of bounds accesses to buffers via shader operations are well-defined. ** When enabled, out-of-bounds buffer reads will return any of the following values: *** Values from anywhere within the buffer object. *** Zero values, or (0,0,0,x) vectors for vector reads where x is a valid value represented in the type of the vector components and may be any of: **** 0, 1, or the maximum representable positive integer value, for signed or unsigned integer components **** 0.0 or 1.0, for floating-point components ** When enabled, out-of-bounds writes may modify values within the buffer object or be ignored. ** If not enabled, out of bounds accesses may cause undefined behaviour up-to and including process termination. * *pname:fullDrawIndexUint32* indicates the full 32-bit range of indices is supported for indexed draw calls when using a elink:VkIndexType of ename:VK_INDEX_TYPE_UINT32. The ptext:maxDrawIndexedIndexValue limit indicates 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, ptext:maxDrawIndexedIndexValue must be 2^32^-1; otherwise it must be no smaller than 2^24^-1. See <>. [[features-features-fullDrawIndexUint]] * *pname:imageCubeArray* indicates whether image views with a elink:VkImageViewType of ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY can be created and that the corresponding *ImageCubeArray* SPIR-V OpCapability can be used in shader code. * *pname:independentBlend* indicates whether the sname:VkPipelineColorBlendAttachmentState settings are controlled independently per-attachment. If this is features not supported or enabled, the sname:VkPipelineColorBlendAttachmentState settings for the first color attachment will be used for all attachments. Otherwise, a sname:VkPipelineColorBlendAttachmentState must be provided for each bound color attachment. * *pname:geometryShader* indicates whether geometry shaders are supported. If this feature is not supported or enabled, ename:VK_SHADER_STAGE_GEOMETRY_BIT, and ename:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT enum values may not be used. This also indicates whether the *Geometry* SPIR-V OpCapability can be used in shader code. * *pname:tessellationShader* indicates whether tessellation control and evaluation shaders are supported. If this feature is not supported or 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 may not be used. This also indicates whether the *Tessellation* SPIR-V OpCapability can be used in shader code. * *pname:sampleRateShading* indicates whether per-sample shading and multisample interpolation is supported. If this feature is not supported or enabled, the ptext:sampleShadingEnable member of the slink:VkPipelineMultisampleStateCreateInfo structure must be set to ename:VK_FALSE and the ptext:minSampleShading member is ignored. This also indicates whether the *SampleRateShading* SPIR-V OpCapability can be used in shader code. * *pname:dualSourceBlend* indicates whether blend operations which take two sources are supported. If this feature is not supported or 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 may not be used as source or destination blending factors. * *pname:logicOp* indicates whether logic operations are supported. If this feature is not supported or enabled, the ptext:logicOpEnable member of the slink:VkPipelineColorBlendStateCreateInfo structure must be set to ename:VK_FALSE and the pname:logicOp member is ignored. [[features-features-multiDrawIndirect]] * *pname:multiDrawIndirect* indicates whether multi-draw indirect is supported. If this feature is not supported or enabled, the ptext:drawCount parameter to the flink:vkCmdDrawIndirect and flink:vkCmdDrawIndexedIndirect commands must be 1. The ptext:maxDrawIndirectCount member of the slink:VkPhysicalDeviceLimits structure must also be 1 if this feature is not supported. See <>. * *pname:depthClamp* indicates whether depth clamping is supported. If this feature is not supported or enabled, the ptext:depthClampEnable member of the sname:VkPipelineRasterizationStateCreateInfo structure must be set to ename:VK_FALSE. Otherwise, setting ptext:depthClampEnable to ename:VK_TRUE will enable depth clamping. * *pname:depthBiasClamp* indicates whether depth bias clamping is supported. If this feature is not supported or enabled, the ptext:depthBiasClamp parameter to flink:vkCmdSetDepthBias is ignored. * *pname:fillModeNonSolid* indicates whether point and wireframe fill modes are supported. If this feature is not supported or enabled, the ename:VK_POLYGON_MODE_POINT and ename:VK_POLYGON_MODE_LINE enum values may not be used. * *pname:depthBounds* indicates whether depth bounds tests are supported. If this feature is not supported or enabled, the ptext:depthBoundsTestEnable member of the sname:VkPipelineDepthStencilStateCreateInfo structure must be set to ename:VK_FALSE. When ptext:depthBoundsTestEnable is set to ename:VK_FALSE, the values of the flink:vkCmdSetDepthBounds command may not be used. * *pname:wideLines* indicates whether lines with width greater than 1.0 are supported. If this feature is not supported or enabled, the flink:vkCmdSetLineWidth command may not be used. . The range and granularity of supported line widths are indicated by the ptext:lineWidthRange and ptext:lineWidthGranularity members of the slink:VkPhysicalDeviceLimits structure, respectively. * *pname:largePoints* indictates if points with size greater than 1.0 are supported. If this feature is not supported or 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 ptext:pointSizeRange and ptext:pointSizeGranularity members of the ptext:VkPhysicalDeviceLimits structure, respectively. * *pname:textureCompressionETC2* indicates whether the ETC2 and EAC compressed texture formats are supported. If this feature is not supported or enabled, the following formats may not be used to create images: + -- * ename:VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK * ename:VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK * ename:VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK * ename:VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK * ename:VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK * ename:VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK * ename:VK_FORMAT_EAC_R11_UNORM_BLOCK * ename:VK_FORMAT_EAC_R11_SNORM_BLOCK * ename:VK_FORMAT_EAC_R11G11_UNORM_BLOCK * ename:VK_FORMAT_EAC_R11G11_SNORM_BLOCK -- + The fname:vkGetPhysicalDeviceFormatProperties command should be used to check for the supported properties of individual formats. * *pname:textureCompressionASTC_LDR* indicates whether the ASTC LDR compressed texture formats are supported. If this feature is not supported or enabled, the following formats may not be used to create images: + -- * ename:VK_FORMAT_ASTC_4x4_UNORM_BLOCK * ename:VK_FORMAT_ASTC_4x4_SRGB_BLOCK * ename:VK_FORMAT_ASTC_5x4_UNORM_BLOCK * ename:VK_FORMAT_ASTC_5x4_SRGB_BLOCK * ename:VK_FORMAT_ASTC_5x5_UNORM_BLOCK * ename:VK_FORMAT_ASTC_5x5_SRGB_BLOCK * ename:VK_FORMAT_ASTC_6x5_UNORM_BLOCK * ename:VK_FORMAT_ASTC_6x5_SRGB_BLOCK * ename:VK_FORMAT_ASTC_6x6_UNORM_BLOCK * ename:VK_FORMAT_ASTC_6x6_SRGB_BLOCK * ename:VK_FORMAT_ASTC_8x5_UNORM_BLOCK * ename:VK_FORMAT_ASTC_8x5_SRGB_BLOCK * ename:VK_FORMAT_ASTC_8x6_UNORM_BLOCK * ename:VK_FORMAT_ASTC_8x6_SRGB_BLOCK * ename:VK_FORMAT_ASTC_8x8_UNORM_BLOCK * ename:VK_FORMAT_ASTC_8x8_SRGB_BLOCK * ename:VK_FORMAT_ASTC_10x5_UNORM_BLOCK * ename:VK_FORMAT_ASTC_10x5_SRGB_BLOCK * ename:VK_FORMAT_ASTC_10x6_UNORM_BLOCK * ename:VK_FORMAT_ASTC_10x6_SRGB_BLOCK * ename:VK_FORMAT_ASTC_10x8_UNORM_BLOCK * ename:VK_FORMAT_ASTC_10x8_SRGB_BLOCK * ename:VK_FORMAT_ASTC_10x10_UNORM_BLOCK * ename:VK_FORMAT_ASTC_10x10_SRGB_BLOCK * ename:VK_FORMAT_ASTC_12x10_UNORM_BLOCK * ename:VK_FORMAT_ASTC_12x10_SRGB_BLOCK * ename:VK_FORMAT_ASTC_12x12_UNORM_BLOCK * ename:VK_FORMAT_ASTC_12x12_SRGB_BLOCK -- + The fname:vkGetPhysicalDeviceFormatProperties command should be used to check for the supported properties of individual formats. * *pname:textureCompressionBC* indicates whether the BC compressed texture formats are supported. If this feature is not supported or enabled, the following formats may not be used to create images: + -- * ename:VK_FORMAT_BC1_RGB_UNORM_BLOCK * ename:VK_FORMAT_BC1_RGB_SRGB_BLOCK * ename:VK_FORMAT_BC1_RGBA_UNORM_BLOCK * ename:VK_FORMAT_BC1_RGBA_SRGB_BLOCK * ename:VK_FORMAT_BC2_UNORM_BLOCK * ename:VK_FORMAT_BC2_SRGB_BLOCK * ename:VK_FORMAT_BC3_UNORM_BLOCK * ename:VK_FORMAT_BC3_SRGB_BLOCK * ename:VK_FORMAT_BC4_UNORM_BLOCK * ename:VK_FORMAT_BC4_SNORM_BLOCK * ename:VK_FORMAT_BC5_UNORM_BLOCK * ename:VK_FORMAT_BC5_SNORM_BLOCK * ename:VK_FORMAT_BC6H_UFLOAT_BLOCK * ename:VK_FORMAT_BC6H_SFLOAT_BLOCK * ename:VK_FORMAT_BC7_UNORM_BLOCK * ename:VK_FORMAT_BC7_SRGB_BLOCK -- + The fname:vkGetPhysicalDeviceFormatProperties command should be used to check for the supported properties of individual formats. * *pname:occlusionQueryPrecise* indicates whether precise (non-conservative) occlusion queries are supported. Occlusion queries are created in a sname:VkQueryPool by specifying the ptext:queryType of ename:VK_QUERY_TYPE_OCCLUSION in the sname:VkQueryPoolCreateInfo structure which is passed to fname:vkCreateQueryPool. If this feature is supported and enabled, queries of this type may set ename:VK_QUERY_CONTROL_PRECISE_BIT in the ptext:flags parameter to fname:vkCmdBeginQuery. If this feature is not supported, the implementation can only support conservative occlusion queries. When any samples are passed, conservative queries will return between one and the actual number of samples passed. When this feature is enabled and ename:VK_QUERY_CONTROL_PRECISE_BIT is set, occlusion queries will report the actual number of samples passed. * *pname:pipelineStatisticsQuery* indicates whether the pipeline statistics queries are supported. If this feature is not supported or enabled, queries of type ename:VK_QUERY_TYPE_PIPELINE_STATISTICS cannot be created and none of the elink:VkQueryPipelineStatisticFlagBits bits should be set in the ptext:pipelineStatistics member of the sname:VkQueryPoolCreateInfo structure. * pname:vertexPipelineStoresAndAtomics indicates whether storage buffers and images support stores and atomic operations in the vertex, tessellation, and geometry shader stages. If this feature is not supported or enabled, all storage image, storage texel buffers and storage buffer variables in shaders for these stages must be decorated with the *NonWriteable* SPIR-V decoration (or the _readonly_ memory qualifier in GLSL). [[features-features-fragmentStoresAndAtomics]] * pname:fragmentStoresAndAtomics indicates whether storage buffers and images support stores and atomic operations in the fragment shader stage. If this feature is not supported or enabled, all storage image, storage texel buffers and storage buffer variables in shaders for the fragment stage must be decorated with the *NonWriteable* SPIR-V decoration (or the _readonly_ memory qualifier in GLSL). * pname:shaderTessellationAndGeometryPointSize indicates whether the _PointSize_ shader builtin is available in the tessellation control, tessellation evaluation, and geometry shader stages. If this feature is not supported or enabled, the _PointSize_ shader builtin is not available in these shader stages and all points written from a tessellation or geometry shader will have a size of 1.0. This also indicates whether the *TessellationPointSize* SPIR-V OpCapability can be used in shader code for tessellation control and evaluation shaders, or if the *GeometryPointSize* SPIR-V OpCapability can be used in shader code for geometry shaders. An implementation supporting this feature must also support one or both of the _tessellationShader_ or _geometryShader_ features. * *pname:shaderImageGatherExtended* indicates whether the extended set of image gather instructions are available in shader code. If this feature is not supported or enabled, the _textureGatherOffset_ shader instruction only supports offsets that are constant integer expressions and the _textureGatherOffsets_ shader instruction is not supported. This also indicates whether the *ImageGatherExtended* SPIR-V OpCapability can be used in shader code. * *pname:shaderStorageImageExtendedFormats* indicates whether the extended storage image formats are available in shader code. If this feature is not supported or enabled, the formats requiring the *StorageImageExtendedFormats* SPIR-V OpCapability are not supported for resources referenced by the ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE descriptor type. This also indicates whether the *StorageImageExtendedFormats* OpCapability ca be used in shader code. * *pname:shaderStorageImageMultisample* indicates whether multisampled storage images are supported. If this feature is not supported or enabled, images that are created with a ptext:usage that includes ename:VK_IMAGE_USAGE_STORAGE_BIT must be created with ptext:samples equal to 1. This also indicates whether the *StorageImageMultisample* SPIR-V OpCapability can be used in shader code. * *pname:shaderUniformBufferArrayDynamicIndexing* indicates whether arrays of uniform buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not supported or enabled, resources with a descriptor type of ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC can only be indexed by constant integral expressions when aggregated into arrays in shader code. This corresponds to the *UniformBufferArrayDynamicIndexing* SPIR-V OpCapability can be used in shader code. * *pname:shaderSampledImageArrayDynamicIndexing* indicates whether arrays of samplers or sampled images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not supported or enabled, resources with a descriptor type of ename:VK_DESCRIPTOR_TYPE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER and ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE can only be indexed by constant integral expressions when aggregated into arrays in shader code. This also indicates whether the *SampledImageArrayDynamicIndexing* SPIR-V OpCapability can be used in shader code. * *pname:shaderStorageBufferArrayDynamicIndexing* indicates whether arrays of storage buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not supported or enabled, resources with a descriptor type of ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC can only be indexed by constant integral expressions when aggregated into arrays in shader code. This corresponds to the *StorageBufferArrayDynamicIndexing* SPIR-V OpCapability can be used in shader code. * *pname:shaderStorageImageArrayDynamicIndexing* indicates whether arrays of storage images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not supported or enabled, resources with a descriptor type of ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE can only be indexed by constant integral expressions when aggregated into arrays in shader code. This also indicates whether the *StorageImageArrayDynamicIndexing* SPIR-V OpCapability can be used in shader code. * *pname:shaderClipDistance* indicates whether clip distances are supported in shader code. If this feature is not supported or enabled, the _ClipDistance_ shader builtin is not available in the builtin shader input and output blocks. This also indicates whether the *ClipDistance* SPIR-V OpCapability can be used in shader code. * *pname:shaderCullDistance* indicates whether cull distances are suppored in shader code. If this feature is not supported or enabled, the _CullDistance_ shader builtin is not available in the builtin shader input and output blocks. This also indicates whether the *CullDistance* SPIR-V OpCapability can be used in shader code. * *pname:shaderFloat64* indicates whether 64-bit floats (doubles) are supported in shader code. If this feature is not supported or enabled, the 64-bit floating point types cannot be used in shader code. This also indicates whether the *Float64* SPIR-V OpCapability can be used in shader code. * *pname:shaderInt64* indicates whether 64-bit integers (signed and unsigned) are supported in shader code. If this feature is not supported or enabled, the 64-bit integer types cannot be used in shader code. This also indicates whether the *Int64* SPIR-V OpCapability can be used in shader code. * *pname:shaderInt16* indicates whether 16-bit integers (signed and unsigned) are supported in shader code. If this feature is not supported or enabled, the 16-bit integer types cannot be used in shader code. This also indicates whether the *Int16* SPIR-V OpCapability can be used in shader code. * *pname:shaderResourceResidency* indicates whether image operations that return resource residency information are supported in shader code. If this feature is not supported or enabled, the image operations which return resource residency information cannot be used in shader code. This also indicates whether the *SparseResidency* SPIR-V OpCapability can be used in shader code. The feature requires the ptext:sparseNonResident feature to be supported. * *pname:shaderResourceMinLod* indicates whether image operations that specify the minimum resource level-of-detail (LOD) are supported in shader code. If this feature is not supported or enabled, the image operations which specify minimum resource LOD cannot be used in shader code. This also indicates whether the *MinLod* SPIR-V OpCapability can be used in shader code. * *pname:alphaToOne* indicates whether the implementation is able to replace the alpha value of the color fragment output from the fragment shader with the maximum representable alpha value for fixed-point colors or 1.0 for floating-point colors. If this feature is not supported or enabled, then the ptext:alphaToOneEnable member of the sname:VkPipelineColorBlendAttachmentState structure must be set to ename:VK_FALSE. Otherwise setting ptext:alphaToOneEnable to ename:VK_TRUE will enable alpha-to-one behaviour. * *pname:sparseBinding* indicates whether resource memory can be managed at opaque page level instead of at the object level. If this feature is not supported or enabled, resource memory can only be bound on a per-object basis using the fname:vkBindBufferMemory and fname:vkBindImageMemory commands. In this case, buffers and images cannot be created with ename:VK_BUFFER_CREATE_SPARSE_BINDING_BIT and ename:VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in the ptext:flags member of the sname:VkBufferCreateInfo and sname:VkImageCreateInfo structures, respectively. Otherwise resource memory can be managed as described in <>. * *pname:sparseResidencyBuffer* indicates whether the device can access partially resident buffers. If this feature is not supported or enabled, buffers cannot be created with ename:VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT set in the ptext:flags member of the sname:VkBufferCreateInfo structure. * *pname:sparseResidencyImage2D* indicates whether the device can access partially resident 2D images with 1 sample per pixel. If this feature is not supported or enabled, images with an ptext:imageType of ename:VK_IMAGE_TYPE_2D and ptext:samples of 1 cannot be created with ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the ptext:flags member of the sname:VkImageCreateInfo structure. * *pname:sparseResidencyImage3D* indicates whether the device can access partially resident 3D images. If this feature is not supported or enabled, images with an ptext:imageType of ename:VK_IMAGE_TYPE_3D cannot be created with ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the ptext:flags member of the sname:VkImageCreateInfo structure. * *pname:sparseResidency2Samples* indicates whether the physical device can access partially resident 2D images with 2 samples per pixel. If this feature is not supported or enabled, images with an ptext:imageType of ename:VK_IMAGE_TYPE_2D and ptext:samples of 2 cannot be created with ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the ptext:flags member of the sname:VkImageCreateInfo structure. * *pname:sparseResidency4Samples* indicates whether the physical device can access partially resident 2D images with 4 samples per pixel. If this feature is not supported or enabled, images with an ptext:imageType of ename:VK_IMAGE_TYPE_2D and ptext:samples of 4 cannot be created with ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the ptext:flags member of the sname:VkImageCreateInfo structure. * *pname:sparseResidency8Samples* indicates whether the physical device can access partially resident 2D images with 8 samples per pixel. If this feature is not supported or enabled, images with an ptext:imageType of ename:VK_IMAGE_TYPE_2D and ptext:samples of 8 cannot be created with ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the ptext:flags member of the sname:VkImageCreateInfo structure. * *pname:sparseResidency16Samples* indicates whether the physical device can access partially resident 2D images with 16 samples per pixel. If this feature is not supported or enabled, images with an ptext:imageType of ename:VK_IMAGE_TYPE_2D and ptext:samples of 16 cannot be created with ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the ptext:flags member of the sname:VkImageCreateInfo structure. * *pname:sparseResidencyAliased* indicates whether the physical device can correctly access data aliased into multiple locations. If this feature is not supported or enabled, the ename:VK_BUFFER_CREATE_SPARSE_ALIASED_BIT and ename:VK_IMAGE_CREATE_SPARSE_ALIASED_BIT enum values may not be used in ptext:flags members of the sname:VkBufferCreateInfo and sname:VkImageCreateInfo structures, respectively. include::../validity/protos/vkGetPhysicalDeviceFeatures.txt[] See Also -------- flink:vkGetPhysicalDeviceProperties include::footer.txt[]