Fields

• apiVersion :: Word32

  apiVersion is the version of Vulkan supported by the device, encoded as described in https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#extendingvulkan-coreversions-versionnumbers.

• driverVersion :: Word32

  driverVersion is the vendor-specified version of the driver.

• vendorID :: Word32

  vendorID is a unique identifier for the vendor (see below) of the physical device.

• deviceID :: Word32

  deviceID is a unique identifier for the physical device among devices available from the vendor.

• deviceType :: PhysicalDeviceType

  deviceType is a PhysicalDeviceType specifying the type of device.

• deviceName :: ByteString

  deviceName is an array of MAX_PHYSICAL_DEVICE_NAME_SIZE char containing a null-terminated UTF-8 string which is the name of the device.

• pipelineCacheUUID :: ByteString

  pipelineCacheUUID is an array of UUID_SIZE uint8_t values representing a universally unique identifier for the device.

• limits :: PhysicalDeviceLimits

  limits is the PhysicalDeviceLimits structure specifying device-specific limits of the physical device. See Limits for details.

• sparseProperties :: PhysicalDeviceSparseProperties

  sparseProperties is the PhysicalDeviceSparseProperties structure specifying various sparse related properties of the physical device. See Sparse Properties for details.

Fields

• applicationName :: Maybe ByteString

  pApplicationName is NULL or is a pointer to a null-terminated UTF-8 string containing the name of the application.

• applicationVersion :: Word32

  applicationVersion is an unsigned integer variable containing the developer-supplied version number of the application.

• engineName :: Maybe ByteString

  pEngineName is NULL or is a pointer to a null-terminated UTF-8 string containing the name of the engine (if any) used to create the application.

• engineVersion :: Word32

  engineVersion is an unsigned integer variable containing the developer-supplied version number of the engine used to create the application.

• apiVersion :: Word32

  apiVersion must be the highest version of Vulkan that the application is designed to use, encoded as described in https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#extendingvulkan-coreversions-versionnumbers. The patch version number specified in apiVersion is ignored when creating an instance object. Only the major and minor versions of the instance must match those requested in apiVersion.

Fields

• next :: Chain es

  pNext is NULL or a pointer to an extension-specific structure.

• flags :: InstanceCreateFlags

  flags is reserved for future use.

• applicationInfo :: Maybe ApplicationInfo

  pApplicationInfo is NULL or a pointer to a ApplicationInfo structure. If not NULL, this information helps implementations recognize behavior inherent to classes of applications. ApplicationInfo is defined in detail below.

• enabledLayerNames :: Vector ByteString

  ppEnabledLayerNames is a pointer to an array of enabledLayerCount null-terminated UTF-8 strings containing the names of layers to enable for the created instance. See the https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#extendingvulkan-layers section for further details.

• enabledExtensionNames :: Vector ByteString

  ppEnabledExtensionNames is a pointer to an array of enabledExtensionCount null-terminated UTF-8 strings containing the names of extensions to enable.

Fields

• queueFlags :: QueueFlags

  queueFlags is a bitmask of QueueFlagBits indicating capabilities of the queues in this queue family.

• queueCount :: Word32

  queueCount is the unsigned integer count of queues in this queue family. Each queue family must support at least one queue.

• timestampValidBits :: Word32

  timestampValidBits is the unsigned integer count of meaningful bits in the timestamps written via cmdWriteTimestamp. The valid range for the count is 36..64 bits, or a value of 0, indicating no support for timestamps. Bits outside the valid range are guaranteed to be zeros.

• minImageTransferGranularity :: Extent3D

  minImageTransferGranularity is the minimum granularity supported for image transfer operations on the queues in this queue family.

Fields

• memoryTypeCount :: Word32

  memoryTypeCount is the number of valid elements in the memoryTypes array.

• memoryTypes :: Vector MemoryType

  memoryTypes is an array of MAX_MEMORY_TYPES MemoryType structures describing the memory types that can be used to access memory allocated from the heaps specified by memoryHeaps.

• memoryHeapCount :: Word32

  memoryHeapCount is the number of valid elements in the memoryHeaps array.

• memoryHeaps :: Vector MemoryHeap

  memoryHeaps is an array of MAX_MEMORY_HEAPS MemoryHeap structures describing the memory heaps from which memory can be allocated.

Fields

• propertyFlags :: MemoryPropertyFlags

  propertyFlags is a bitmask of MemoryPropertyFlagBits of properties for this memory type.

• heapIndex :: Word32

  heapIndex describes which memory heap this memory type corresponds to, and must be less than memoryHeapCount from the PhysicalDeviceMemoryProperties structure.

Fields

• size :: DeviceSize

  size is the total memory size in bytes in the heap.

• flags :: MemoryHeapFlags

  flags is a bitmask of MemoryHeapFlagBits specifying attribute flags for the heap.

Fields

• linearTilingFeatures :: FormatFeatureFlags

  linearTilingFeatures is a bitmask of FormatFeatureFlagBits specifying features supported by images created with a tiling parameter of IMAGE_TILING_LINEAR.

• optimalTilingFeatures :: FormatFeatureFlags

  optimalTilingFeatures is a bitmask of FormatFeatureFlagBits specifying features supported by images created with a tiling parameter of IMAGE_TILING_OPTIMAL.

• bufferFeatures :: FormatFeatureFlags

  bufferFeatures is a bitmask of FormatFeatureFlagBits specifying features supported by buffers.

Fields

• maxExtent :: Extent3D
   
• maxMipLevels :: Word32
   
• maxArrayLayers :: Word32
   
• sampleCounts :: SampleCountFlags
   
• maxResourceSize :: DeviceSize
   

Fields

• robustBufferAccess :: Bool

  robustBufferAccess specifies that accesses to buffers are bounds-checked against the range of the buffer descriptor (as determined by DescriptorBufferInfo::range, BufferViewCreateInfo::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 OpImageTexelPointer and the coordinate is less than zero or greater than or equal to the number of whole elements in the bound range.

    • The pointer was not formed by OpImageTexelPointer and the object pointed to is not wholly contained within the bound range. This includes accesses performed via variable pointers where the buffer descriptor being accessed cannot be statically determined. Uninitialized pointers and pointers equal to OpConstantNull are treated as pointing to a zero-sized object, so all accesses through such pointers are considered to be out of bounds. Buffer accesses through buffer device addresses are not bounds-checked. If the cooperativeMatrixRobustBufferAccess feature is not enabled, then accesses using OpCooperativeMatrixLoadNV and OpCooperativeMatrixStoreNV may not be bounds-checked.

      Note

      If a SPIR-V OpLoad instruction loads a structure and the tail end of the structure is out of bounds, then all members of the structure are considered out of bounds even if the members at the end are not statically used.

    • If any buffer access 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.

  • Out-of-bounds buffer loads will return any of the following values:

    • Values from anywhere within the memory range(s) bound to the buffer (possibly including bytes of memory past the end of the buffer, up to the end of the bound range).

    • Zero values, or (0,0,0,x) vectors for vector reads where x is a valid value represented in the type of the vector components and may be any of:

      • 0, 1, or the maximum representable positive integer value, for signed or unsigned integer components
      • 0.0 or 1.0, for floating-point components
  • Out-of-bounds writes may modify values within the memory range(s) bound to the buffer, but must not modify any other memory.
  • Out-of-bounds atomics may modify values within the memory range(s) bound to the buffer, but must not modify any other memory, and return an undefined value.

  • Vertex input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than either:

    • vertexBufferRangeSize, if bindingStride == 0; or
    • (vertexBufferRangeSize - (vertexBufferRangeSize % bindingStride))

    where vertexBufferRangeSize is the byte size of the memory range bound to the vertex buffer binding and 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 (0,0,0,x) vectors, as described above.
  • If robustBufferAccess is not enabled, applications must not perform out of bounds accesses.
• fullDrawIndexUint32 :: Bool

  fullDrawIndexUint32 specifies the full 32-bit range of indices is supported for indexed draw calls when using a IndexType of INDEX_TYPE_UINT32. maxDrawIndexedIndexValue is the maximum index value that may be used (aside from the primitive restart index, which is always 232-1 when the IndexType is INDEX_TYPE_UINT32). If this feature is supported, maxDrawIndexedIndexValue must be 232-1; otherwise it must be no smaller than 224-1. See maxDrawIndexedIndexValue.

• imageCubeArray :: Bool

  imageCubeArray specifies whether image views with a ImageViewType of IMAGE_VIEW_TYPE_CUBE_ARRAY can be created, and that the corresponding SampledCubeArray and ImageCubeArray SPIR-V capabilities can be used in shader code.

• independentBlend :: Bool

  independentBlend specifies whether the PipelineColorBlendAttachmentState settings are controlled independently per-attachment. If this feature is not enabled, the PipelineColorBlendAttachmentState settings for all color attachments must be identical. Otherwise, a different PipelineColorBlendAttachmentState can be provided for each bound color attachment.

• geometryShader :: Bool

  geometryShader specifies whether geometry shaders are supported. If this feature is not enabled, the SHADER_STAGE_GEOMETRY_BIT and PIPELINE_STAGE_GEOMETRY_SHADER_BIT enum values must not be used. This also specifies whether shader modules can declare the Geometry capability.

• tessellationShader :: Bool

  tessellationShader specifies whether tessellation control and evaluation shaders are supported. If this feature is not enabled, the SHADER_STAGE_TESSELLATION_CONTROL_BIT, SHADER_STAGE_TESSELLATION_EVALUATION_BIT, PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, and STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO enum values must not be used. This also specifies whether shader modules can declare the Tessellation capability.

• sampleRateShading :: Bool

  sampleRateShading specifies whether Sample Shading and multisample interpolation are supported. If this feature is not enabled, the sampleShadingEnable member of the PipelineMultisampleStateCreateInfo structure must be set to FALSE and the minSampleShading member is ignored. This also specifies whether shader modules can declare the SampleRateShading capability.

• dualSrcBlend :: Bool

  dualSrcBlend specifies whether blend operations which take two sources are supported. If this feature is not enabled, the BLEND_FACTOR_SRC1_COLOR, BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, BLEND_FACTOR_SRC1_ALPHA, and BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA enum values must not be used as source or destination blending factors. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#framebuffer-dsb.

• logicOp :: Bool

  logicOp specifies whether logic operations are supported. If this feature is not enabled, the logicOpEnable member of the PipelineColorBlendStateCreateInfo structure must be set to FALSE, and the logicOp member is ignored.

• multiDrawIndirect :: Bool

  multiDrawIndirect specifies whether multiple draw indirect is supported. If this feature is not enabled, the drawCount parameter to the cmdDrawIndirect and cmdDrawIndexedIndirect commands must be 0 or 1. The maxDrawIndirectCount member of the PhysicalDeviceLimits structure must also be 1 if this feature is not supported. See maxDrawIndirectCount.

• drawIndirectFirstInstance :: Bool

  drawIndirectFirstInstance specifies whether indirect draw calls support the firstInstance parameter. If this feature is not enabled, the firstInstance member of all DrawIndirectCommand and DrawIndexedIndirectCommand structures that are provided to the cmdDrawIndirect and cmdDrawIndexedIndirect commands must be 0.

• depthClamp :: Bool

  depthClamp specifies whether depth clamping is supported. If this feature is not enabled, the depthClampEnable member of the PipelineRasterizationStateCreateInfo structure must be set to FALSE. Otherwise, setting depthClampEnable to TRUE will enable depth clamping.

• depthBiasClamp :: Bool

  depthBiasClamp specifies whether depth bias clamping is supported. If this feature is not enabled, the depthBiasClamp member of the PipelineRasterizationStateCreateInfo structure must be set to 0.0 unless the DYNAMIC_STATE_DEPTH_BIAS dynamic state is enabled, and the depthBiasClamp parameter to cmdSetDepthBias must be set to 0.0.

• fillModeNonSolid :: Bool

  fillModeNonSolid specifies whether point and wireframe fill modes are supported. If this feature is not enabled, the POLYGON_MODE_POINT and POLYGON_MODE_LINE enum values must not be used.

• depthBounds :: Bool

  depthBounds specifies whether depth bounds tests are supported. If this feature is not enabled, the depthBoundsTestEnable member of the PipelineDepthStencilStateCreateInfo structure must be set to FALSE. When depthBoundsTestEnable is set to FALSE, the minDepthBounds and maxDepthBounds members of the PipelineDepthStencilStateCreateInfo structure are ignored.

• wideLines :: Bool

  wideLines specifies whether lines with width other than 1.0 are supported. If this feature is not enabled, the lineWidth member of the PipelineRasterizationStateCreateInfo structure must be set to 1.0 unless the DYNAMIC_STATE_LINE_WIDTH dynamic state is enabled, and the lineWidth parameter to cmdSetLineWidth must be set to 1.0. When this feature is supported, the range and granularity of supported line widths are indicated by the lineWidthRange and lineWidthGranularity members of the PhysicalDeviceLimits structure, respectively.

• largePoints :: Bool

  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 pointSizeRange and pointSizeGranularity members of the PhysicalDeviceLimits structure, respectively.

• alphaToOne :: Bool

  alphaToOne specifies whether the implementation is able to replace the alpha value of the color fragment output from the fragment shader with the maximum representable alpha value for fixed-point colors or 1.0 for floating-point colors. If this feature is not enabled, then the alphaToOneEnable member of the PipelineMultisampleStateCreateInfo structure must be set to FALSE. Otherwise setting alphaToOneEnable to TRUE will enable alpha-to-one behavior.

• multiViewport :: Bool

  multiViewport specifies whether more than one viewport is supported. If this feature is not enabled:

  • The viewportCount and scissorCount members of the PipelineViewportStateCreateInfo structure must be set to 1.
  • The firstViewport and viewportCount parameters to the cmdSetViewport command must be set to 0 and 1, respectively.
  • The firstScissor and scissorCount parameters to the cmdSetScissor command must be set to 0 and 1, respectively.
  • The exclusiveScissorCount member of the PipelineViewportExclusiveScissorStateCreateInfoNV structure must be set to 0 or 1.
  • The firstExclusiveScissor and exclusiveScissorCount parameters to the cmdSetExclusiveScissorNV command must be set to 0 and 1, respectively.
• samplerAnisotropy :: Bool

  samplerAnisotropy specifies whether anisotropic filtering is supported. If this feature is not enabled, the anisotropyEnable member of the SamplerCreateInfo structure must be FALSE.

• textureCompressionETC2 :: Bool

  textureCompressionETC2 specifies whether all of the ETC2 and EAC compressed texture formats are supported. If this feature is enabled, then the FORMAT_FEATURE_SAMPLED_IMAGE_BIT, FORMAT_FEATURE_BLIT_SRC_BIT and FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:

  • FORMAT_ETC2_R8G8B8_UNORM_BLOCK
  • FORMAT_ETC2_R8G8B8_SRGB_BLOCK
  • FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
  • FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
  • FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
  • FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
  • FORMAT_EAC_R11_UNORM_BLOCK
  • FORMAT_EAC_R11_SNORM_BLOCK
  • FORMAT_EAC_R11G11_UNORM_BLOCK
  • FORMAT_EAC_R11G11_SNORM_BLOCK

  To query for additional properties, or if the feature is not enabled, getPhysicalDeviceFormatProperties and getPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.

• textureCompressionASTC_LDR :: Bool

  textureCompressionASTC_LDR specifies whether all of the ASTC LDR compressed texture formats are supported. If this feature is enabled, then the FORMAT_FEATURE_SAMPLED_IMAGE_BIT, FORMAT_FEATURE_BLIT_SRC_BIT and FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:

  • FORMAT_ASTC_4x4_UNORM_BLOCK
  • FORMAT_ASTC_4x4_SRGB_BLOCK
  • FORMAT_ASTC_5x4_UNORM_BLOCK
  • FORMAT_ASTC_5x4_SRGB_BLOCK
  • FORMAT_ASTC_5x5_UNORM_BLOCK
  • FORMAT_ASTC_5x5_SRGB_BLOCK
  • FORMAT_ASTC_6x5_UNORM_BLOCK
  • FORMAT_ASTC_6x5_SRGB_BLOCK
  • FORMAT_ASTC_6x6_UNORM_BLOCK
  • FORMAT_ASTC_6x6_SRGB_BLOCK
  • FORMAT_ASTC_8x5_UNORM_BLOCK
  • FORMAT_ASTC_8x5_SRGB_BLOCK
  • FORMAT_ASTC_8x6_UNORM_BLOCK
  • FORMAT_ASTC_8x6_SRGB_BLOCK
  • FORMAT_ASTC_8x8_UNORM_BLOCK
  • FORMAT_ASTC_8x8_SRGB_BLOCK
  • FORMAT_ASTC_10x5_UNORM_BLOCK
  • FORMAT_ASTC_10x5_SRGB_BLOCK
  • FORMAT_ASTC_10x6_UNORM_BLOCK
  • FORMAT_ASTC_10x6_SRGB_BLOCK
  • FORMAT_ASTC_10x8_UNORM_BLOCK
  • FORMAT_ASTC_10x8_SRGB_BLOCK
  • FORMAT_ASTC_10x10_UNORM_BLOCK
  • FORMAT_ASTC_10x10_SRGB_BLOCK
  • FORMAT_ASTC_12x10_UNORM_BLOCK
  • FORMAT_ASTC_12x10_SRGB_BLOCK
  • FORMAT_ASTC_12x12_UNORM_BLOCK
  • FORMAT_ASTC_12x12_SRGB_BLOCK

  To query for additional properties, or if the feature is not enabled, getPhysicalDeviceFormatProperties and getPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.

• textureCompressionBC :: Bool

  textureCompressionBC specifies whether all of the BC compressed texture formats are supported. If this feature is enabled, then the FORMAT_FEATURE_SAMPLED_IMAGE_BIT, FORMAT_FEATURE_BLIT_SRC_BIT and FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:

  • FORMAT_BC1_RGB_UNORM_BLOCK
  • FORMAT_BC1_RGB_SRGB_BLOCK
  • FORMAT_BC1_RGBA_UNORM_BLOCK
  • FORMAT_BC1_RGBA_SRGB_BLOCK
  • FORMAT_BC2_UNORM_BLOCK
  • FORMAT_BC2_SRGB_BLOCK
  • FORMAT_BC3_UNORM_BLOCK
  • FORMAT_BC3_SRGB_BLOCK
  • FORMAT_BC4_UNORM_BLOCK
  • FORMAT_BC4_SNORM_BLOCK
  • FORMAT_BC5_UNORM_BLOCK
  • FORMAT_BC5_SNORM_BLOCK
  • FORMAT_BC6H_UFLOAT_BLOCK
  • FORMAT_BC6H_SFLOAT_BLOCK
  • FORMAT_BC7_UNORM_BLOCK
  • FORMAT_BC7_SRGB_BLOCK

  To query for additional properties, or if the feature is not enabled, getPhysicalDeviceFormatProperties and getPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.

• occlusionQueryPrecise :: Bool

  occlusionQueryPrecise specifies whether occlusion queries returning actual sample counts are supported. Occlusion queries are created in a QueryPool by specifying the queryType of QUERY_TYPE_OCCLUSION in the QueryPoolCreateInfo structure which is passed to createQueryPool. If this feature is enabled, queries of this type can enable QUERY_CONTROL_PRECISE_BIT in the flags parameter to cmdBeginQuery. 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 QUERY_CONTROL_PRECISE_BIT is set, occlusion queries will report the actual number of samples passed.

• pipelineStatisticsQuery :: Bool

  pipelineStatisticsQuery specifies whether the pipeline statistics queries are supported. If this feature is not enabled, queries of type QUERY_TYPE_PIPELINE_STATISTICS cannot be created, and none of the QueryPipelineStatisticFlagBits bits can be set in the pipelineStatistics member of the QueryPoolCreateInfo structure.

• vertexPipelineStoresAndAtomics :: Bool

  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 buffers, and storage buffer variables used by these stages in shader modules must be decorated with the NonWritable decoration (or the readonly memory qualifier in GLSL).

• fragmentStoresAndAtomics :: Bool

  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 buffers, and storage buffer variables used by the fragment stage in shader modules must be decorated with the NonWritable decoration (or the readonly memory qualifier in GLSL).

• shaderTessellationAndGeometryPointSize :: Bool

  shaderTessellationAndGeometryPointSize specifies whether the PointSize built-in decoration is available in the tessellation control, tessellation evaluation, and geometry shader stages. If this feature is not enabled, members decorated with the PointSize built-in decoration must not be read from or written to and all points written from a tessellation or geometry shader will have a size of 1.0. This also specifies whether shader modules can declare the TessellationPointSize capability for tessellation control and evaluation shaders, or if the shader modules can declare the GeometryPointSize capability for geometry shaders. An implementation supporting this feature must also support one or both of the tessellationShader or geometryShader features.

• shaderImageGatherExtended :: Bool

  shaderImageGatherExtended specifies whether the extended set of image gather instructions are available in shader code. If this feature is not enabled, the OpImage*Gather instructions do not support the Offset and ConstOffsets operands. This also specifies whether shader modules can declare the ImageGatherExtended capability.

• shaderStorageImageExtendedFormats :: Bool

  shaderStorageImageExtendedFormats specifies whether all the “storage image extended formats” below are supported; if this feature is supported, then the FORMAT_FEATURE_STORAGE_IMAGE_BIT must be supported in optimalTilingFeatures for the following formats:

  • FORMAT_R16G16_SFLOAT
  • FORMAT_B10G11R11_UFLOAT_PACK32
  • FORMAT_R16_SFLOAT
  • FORMAT_R16G16B16A16_UNORM
  • FORMAT_A2B10G10R10_UNORM_PACK32
  • FORMAT_R16G16_UNORM
  • FORMAT_R8G8_UNORM
  • FORMAT_R16_UNORM
  • FORMAT_R8_UNORM
  • FORMAT_R16G16B16A16_SNORM
  • FORMAT_R16G16_SNORM
  • FORMAT_R8G8_SNORM
  • FORMAT_R16_SNORM
  • FORMAT_R8_SNORM
  • FORMAT_R16G16_SINT
  • FORMAT_R8G8_SINT
  • FORMAT_R16_SINT
  • FORMAT_R8_SINT
  • FORMAT_A2B10G10R10_UINT_PACK32
  • FORMAT_R16G16_UINT
  • FORMAT_R8G8_UINT
  • FORMAT_R16_UINT
  • FORMAT_R8_UINT

  Note

  shaderStorageImageExtendedFormats feature only adds a guarantee of format support, which is specified for the whole physical device. Therefore enabling or disabling the feature via createDevice has no practical effect.

  To query for additional properties, or if the feature is not supported, getPhysicalDeviceFormatProperties and getPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats, as usual rules allow.

  FORMAT_R32G32_UINT, FORMAT_R32G32_SINT, and FORMAT_R32G32_SFLOAT from StorageImageExtendedFormats SPIR-V capability, are already covered by core Vulkan mandatory format support.

• shaderStorageImageMultisample :: Bool

  shaderStorageImageMultisample specifies whether multisampled storage images are supported. If this feature is not enabled, images that are created with a usage that includes IMAGE_USAGE_STORAGE_BIT must be created with samples equal to SAMPLE_COUNT_1_BIT. This also specifies whether shader modules can declare the StorageImageMultisample capability.

• shaderStorageImageReadWithoutFormat :: Bool

  shaderStorageImageReadWithoutFormat specifies whether storage images require a format qualifier to be specified when reading from storage images. If this feature is not enabled, the OpImageRead instruction must not have an OpTypeImage of Unknown. This also specifies whether shader modules can declare the StorageImageReadWithoutFormat capability.

• shaderStorageImageWriteWithoutFormat :: Bool

  shaderStorageImageWriteWithoutFormat specifies whether storage images require a format qualifier to be specified when writing to storage images. If this feature is not enabled, the OpImageWrite instruction must not have an OpTypeImage of Unknown. This also specifies whether shader modules can declare the StorageImageWriteWithoutFormat capability.

• shaderUniformBufferArrayDynamicIndexing :: Bool

  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 DESCRIPTOR_TYPE_UNIFORM_BUFFER or 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 UniformBufferArrayDynamicIndexing capability.

• shaderSampledImageArrayDynamicIndexing :: Bool

  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 DESCRIPTOR_TYPE_SAMPLER, DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or 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 SampledImageArrayDynamicIndexing capability.

• shaderStorageBufferArrayDynamicIndexing :: Bool

  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 DESCRIPTOR_TYPE_STORAGE_BUFFER or 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 StorageBufferArrayDynamicIndexing capability.

• shaderStorageImageArrayDynamicIndexing :: Bool

  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 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 StorageImageArrayDynamicIndexing capability.

• shaderClipDistance :: Bool

  shaderClipDistance specifies whether clip distances are supported in shader code. If this feature is not enabled, any members decorated with the ClipDistance built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare the ClipDistance capability.

• shaderCullDistance :: Bool

  shaderCullDistance specifies whether cull distances are supported in shader code. If this feature is not enabled, any members decorated with the CullDistance built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare the CullDistance capability.

• shaderFloat64 :: Bool

  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 Float64 capability. Declaring and using 64-bit floats is enabled for all storage classes that SPIR-V allows with the Float64 capability.

• shaderInt64 :: Bool

  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 Int64 capability. Declaring and using 64-bit integers is enabled for all storage classes that SPIR-V allows with the Int64 capability.

• shaderInt16 :: Bool

  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 Int16 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the Int16 SPIR-V capability: Declaring and using 16-bit integers in the Private, Workgroup, and Function storage classes is enabled, while declaring them in the interface storage classes (e.g., UniformConstant, Uniform, StorageBuffer, Input, Output, and PushConstant) is not enabled.

• shaderResourceResidency :: Bool

  shaderResourceResidency specifies whether image operations that return resource residency information are supported in shader code. If this feature is not enabled, the OpImageSparse* instructions must not be used in shader code. This also specifies whether shader modules can declare the SparseResidency capability. The feature requires at least one of the sparseResidency* features to be supported.

• shaderResourceMinLod :: Bool

  shaderResourceMinLod specifies whether image operations specifying the minimum resource LOD are supported in shader code. If this feature is not enabled, the MinLod image operand must not be used in shader code. This also specifies whether shader modules can declare the MinLod capability.

• sparseBinding :: Bool

  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 bindBufferMemory and bindImageMemory commands. In this case, buffers and images must not be created with BUFFER_CREATE_SPARSE_BINDING_BIT and IMAGE_CREATE_SPARSE_BINDING_BIT set in the flags member of the BufferCreateInfo and ImageCreateInfo structures, respectively. Otherwise resource memory can be managed as described in Sparse Resource Features.

• sparseResidencyBuffer :: Bool

  sparseResidencyBuffer specifies whether the device can access partially resident buffers. If this feature is not enabled, buffers must not be created with BUFFER_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the BufferCreateInfo structure.

• sparseResidencyImage2D :: Bool

  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 imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_1_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidencyImage3D :: Bool

  sparseResidencyImage3D specifies whether the device can access partially resident 3D images. If this feature is not enabled, images with an imageType of IMAGE_TYPE_3D must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidency2Samples :: Bool

  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 imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_2_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidency4Samples :: Bool

  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 imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_4_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidency8Samples :: Bool

  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 imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_8_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidency16Samples :: Bool

  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 imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_16_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidencyAliased :: Bool

  sparseResidencyAliased specifies whether the physical device can correctly access data aliased into multiple locations. If this feature is not enabled, the BUFFER_CREATE_SPARSE_ALIASED_BIT and IMAGE_CREATE_SPARSE_ALIASED_BIT enum values must not be used in flags members of the BufferCreateInfo and ImageCreateInfo structures, respectively.

• variableMultisampleRate :: Bool

  variableMultisampleRate specifies whether all pipelines that will be bound to a command buffer during a subpass with no attachments must have the same value for PipelineMultisampleStateCreateInfo::rasterizationSamples. If set to TRUE, the implementation supports variable multisample rates in a subpass with no attachments. If set to FALSE, then all pipelines bound in such a subpass must have the same multisample rate. This has no effect in situations where a subpass uses any attachments.

• inheritedQueries :: Bool

  inheritedQueries specifies whether a secondary command buffer may be executed while a query is active.

Fields

• residencyStandard2DBlockShape :: Bool

  residencyStandard2DBlockShape is TRUE if the physical device will access all single-sample 2D sparse resources using the standard sparse image block shapes (based on image format), as described in the Standard Sparse Image Block Shapes (Single Sample) table. If this property is not supported the value returned in the imageGranularity member of the SparseImageFormatProperties structure for single-sample 2D images is not required to match the standard sparse image block dimensions listed in the table.

• residencyStandard2DMultisampleBlockShape :: Bool

  residencyStandard2DMultisampleBlockShape is TRUE if the physical device will access all multisample 2D sparse resources using the standard sparse image block shapes (based on image format), as described in the Standard Sparse Image Block Shapes (MSAA) table. If this property is not supported, the value returned in the imageGranularity member of the SparseImageFormatProperties structure for multisample 2D images is not required to match the standard sparse image block dimensions listed in the table.

• residencyStandard3DBlockShape :: Bool

  residencyStandard3DBlockShape is TRUE if the physical device will access all 3D sparse resources using the standard sparse image block shapes (based on image format), as described in the Standard Sparse Image Block Shapes (Single Sample) table. If this property is not supported, the value returned in the imageGranularity member of the SparseImageFormatProperties structure for 3D images is not required to match the standard sparse image block dimensions listed in the table.

• residencyAlignedMipSize :: Bool

  residencyAlignedMipSize is TRUE if images with mip level dimensions that are not integer multiples of the corresponding dimensions of the sparse image block may be placed in the mip tail. If this property is not reported, only mip levels with dimensions smaller than the imageGranularity member of the SparseImageFormatProperties structure will be placed in the mip tail. If this property is reported the implementation is allowed to return SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT in the flags member of SparseImageFormatProperties, indicating that mip level dimensions that are not integer multiples of the corresponding dimensions of the sparse image block will be placed in the mip tail.

• residencyNonResidentStrict :: Bool

  residencyNonResidentStrict specifies whether the physical device can consistently access non-resident regions of a resource. If this property is TRUE, access to non-resident regions of resources will be guaranteed to return values as if the resource were populated with 0; writes to non-resident regions will be discarded.

Fields

• maxImageDimension1D :: Word32

  maxImageDimension1D is the maximum dimension (width) supported for all images created with an imageType of IMAGE_TYPE_1D.

• maxImageDimension2D :: Word32

  maxImageDimension2D is the maximum dimension (width or height) supported for all images created with an imageType of IMAGE_TYPE_2D and without IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in flags.

• maxImageDimension3D :: Word32

  maxImageDimension3D is the maximum dimension (width, height, or depth) supported for all images created with an imageType of IMAGE_TYPE_3D.

• maxImageDimensionCube :: Word32

  maxImageDimensionCube is the maximum dimension (width or height) supported for all images created with an imageType of IMAGE_TYPE_2D and with IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in flags.

• maxImageArrayLayers :: Word32

  maxImageArrayLayers is the maximum number of layers (arrayLayers) for an image.

• maxTexelBufferElements :: Word32

  maxTexelBufferElements is the maximum number of addressable texels for a buffer view created on a buffer which was created with the BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set in the usage member of the BufferCreateInfo structure.

• maxUniformBufferRange :: Word32

  maxUniformBufferRange is the maximum value that can be specified in the range member of any DescriptorBufferInfo structures passed to a call to updateDescriptorSets for descriptors of type DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC.

• maxStorageBufferRange :: Word32

  maxStorageBufferRange is the maximum value that can be specified in the range member of any DescriptorBufferInfo structures passed to a call to updateDescriptorSets for descriptors of type DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC.

• maxPushConstantsSize :: Word32

  maxPushConstantsSize is the maximum size, in bytes, of the pool of push constant memory. For each of the push constant ranges indicated by the pPushConstantRanges member of the PipelineLayoutCreateInfo structure, (offset + size) must be less than or equal to this limit.

• maxMemoryAllocationCount :: Word32

  maxMemoryAllocationCount is the maximum number of device memory allocations, as created by allocateMemory, which can simultaneously exist.

• maxSamplerAllocationCount :: Word32

  maxSamplerAllocationCount is the maximum number of sampler objects, as created by createSampler, which can simultaneously exist on a device.

• bufferImageGranularity :: DeviceSize

  bufferImageGranularity is the granularity, in bytes, at which buffer or linear image resources, and optimal image resources can be bound to adjacent offsets in the same DeviceMemory object without aliasing. See Buffer-Image Granularity for more details.

• sparseAddressSpaceSize :: DeviceSize

  sparseAddressSpaceSize is the total amount of address space available, in bytes, for sparse memory resources. This is an upper bound on the sum of the size of all sparse resources, regardless of whether any memory is bound to them.

• maxBoundDescriptorSets :: Word32

  maxBoundDescriptorSets is the maximum number of descriptor sets that can be simultaneously used by a pipeline. All DescriptorSet decorations in shader modules must have a value less than maxBoundDescriptorSets. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sets.

• maxPerStageDescriptorSamplers :: Word32

  maxPerStageDescriptorSamplers is the maximum number of samplers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_SAMPLER or DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sampler and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-combinedimagesampler.

• maxPerStageDescriptorUniformBuffers :: Word32

  maxPerStageDescriptorUniformBuffers is the maximum number of uniform buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbuffer and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbufferdynamic.

• maxPerStageDescriptorStorageBuffers :: Word32

  maxPerStageDescriptorStorageBuffers is the maximum number of storage buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebuffer and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebufferdynamic.

• maxPerStageDescriptorSampledImages :: Word32

  maxPerStageDescriptorSampledImages is the maximum number of sampled images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, DESCRIPTOR_TYPE_SAMPLED_IMAGE, or DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-combinedimagesampler, https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sampledimage, and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformtexelbuffer.

• maxPerStageDescriptorStorageImages :: Word32

  maxPerStageDescriptorStorageImages is the maximum number of storage images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_IMAGE, or DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storageimage, and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagetexelbuffer.

• maxPerStageDescriptorInputAttachments :: Word32

  maxPerStageDescriptorInputAttachments is the maximum number of input attachments that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. These are only supported for the fragment stage. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-inputattachment.

• maxPerStageResources :: Word32

  maxPerStageResources is the maximum number of resources that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, DESCRIPTOR_TYPE_SAMPLED_IMAGE, DESCRIPTOR_TYPE_STORAGE_IMAGE, DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, DESCRIPTOR_TYPE_UNIFORM_BUFFER, DESCRIPTOR_TYPE_STORAGE_BUFFER, DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, or DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. For the fragment shader stage the framebuffer color attachments also count against this limit.

• maxDescriptorSetSamplers :: Word32

  maxDescriptorSetSamplers is the maximum number of samplers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_SAMPLER or DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sampler and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-combinedimagesampler.

• maxDescriptorSetUniformBuffers :: Word32

  maxDescriptorSetUniformBuffers is the maximum number of uniform buffers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbuffer and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbufferdynamic.

• maxDescriptorSetUniformBuffersDynamic :: Word32

  maxDescriptorSetUniformBuffersDynamic is the maximum number of dynamic uniform buffers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbufferdynamic.

• maxDescriptorSetStorageBuffers :: Word32

  maxDescriptorSetStorageBuffers is the maximum number of storage buffers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebuffer and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebufferdynamic.

• maxDescriptorSetStorageBuffersDynamic :: Word32

  maxDescriptorSetStorageBuffersDynamic is the maximum number of dynamic storage buffers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebufferdynamic.

• maxDescriptorSetSampledImages :: Word32

  maxDescriptorSetSampledImages is the maximum number of sampled images that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, DESCRIPTOR_TYPE_SAMPLED_IMAGE, or DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-combinedimagesampler, https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sampledimage, and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformtexelbuffer.

• maxDescriptorSetStorageImages :: Word32

  maxDescriptorSetStorageImages is the maximum number of storage images that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_IMAGE, or DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storageimage, and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagetexelbuffer.

• maxDescriptorSetInputAttachments :: Word32

  maxDescriptorSetInputAttachments is the maximum number of input attachments that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-inputattachment.

• maxVertexInputAttributes :: Word32

  maxVertexInputAttributes is the maximum number of vertex input attributes that can be specified for a graphics pipeline. These are described in the array of VertexInputAttributeDescription structures that are provided at graphics pipeline creation time via the pVertexAttributeDescriptions member of the PipelineVertexInputStateCreateInfo structure. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-attrib and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-input.

• maxVertexInputBindings :: Word32

  maxVertexInputBindings is the maximum number of vertex buffers that can be specified for providing vertex attributes to a graphics pipeline. These are described in the array of VertexInputBindingDescription structures that are provided at graphics pipeline creation time via the pVertexBindingDescriptions member of the PipelineVertexInputStateCreateInfo structure. The binding member of VertexInputBindingDescription must be less than this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-input.

• maxVertexInputAttributeOffset :: Word32

  maxVertexInputAttributeOffset is the maximum vertex input attribute offset that can be added to the vertex input binding stride. The offset member of the VertexInputAttributeDescription structure must be less than or equal to this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-input.

• maxVertexInputBindingStride :: Word32

  maxVertexInputBindingStride is the maximum vertex input binding stride that can be specified in a vertex input binding. The stride member of the VertexInputBindingDescription structure must be less than or equal to this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-input.

• maxVertexOutputComponents :: Word32

  maxVertexOutputComponents is the maximum number of components of output variables which can be output by a vertex shader. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#shaders-vertex.

• maxTessellationGenerationLevel :: Word32

  maxTessellationGenerationLevel is the maximum tessellation generation level supported by the fixed-function tessellation primitive generator. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#tessellation.

• maxTessellationPatchSize :: Word32

  maxTessellationPatchSize is the maximum patch size, in vertices, of patches that can be processed by the tessellation control shader and tessellation primitive generator. The patchControlPoints member of the PipelineTessellationStateCreateInfo structure specified at pipeline creation time and the value provided in the OutputVertices execution mode of shader modules must be less than or equal to this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#tessellation.

• maxTessellationControlPerVertexInputComponents :: Word32

  maxTessellationControlPerVertexInputComponents is the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation control shader stage.

• maxTessellationControlPerVertexOutputComponents :: Word32

  maxTessellationControlPerVertexOutputComponents is the maximum number of components of per-vertex output variables which can be output from the tessellation control shader stage.

• maxTessellationControlPerPatchOutputComponents :: Word32

  maxTessellationControlPerPatchOutputComponents is the maximum number of components of per-patch output variables which can be output from the tessellation control shader stage.

• maxTessellationControlTotalOutputComponents :: Word32

  maxTessellationControlTotalOutputComponents is the maximum total number of components of per-vertex and per-patch output variables which can be output from the tessellation control shader stage.

• maxTessellationEvaluationInputComponents :: Word32

  maxTessellationEvaluationInputComponents is the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation evaluation shader stage.

• maxTessellationEvaluationOutputComponents :: Word32

  maxTessellationEvaluationOutputComponents is the maximum number of components of per-vertex output variables which can be output from the tessellation evaluation shader stage.

• maxGeometryShaderInvocations :: Word32

  maxGeometryShaderInvocations is the maximum invocation count supported for instanced geometry shaders. The value provided in the Invocations execution mode of shader modules must be less than or equal to this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#geometry.

• maxGeometryInputComponents :: Word32

  maxGeometryInputComponents is the maximum number of components of input variables which can be provided as inputs to the geometry shader stage.

• maxGeometryOutputComponents :: Word32

  maxGeometryOutputComponents is the maximum number of components of output variables which can be output from the geometry shader stage.

• maxGeometryOutputVertices :: Word32

  maxGeometryOutputVertices is the maximum number of vertices which can be emitted by any geometry shader.

• maxGeometryTotalOutputComponents :: Word32

  maxGeometryTotalOutputComponents is the maximum total number of components of output, across all emitted vertices, which can be output from the geometry shader stage.

• maxFragmentInputComponents :: Word32

  maxFragmentInputComponents is the maximum number of components of input variables which can be provided as inputs to the fragment shader stage.

• maxFragmentOutputAttachments :: Word32

  maxFragmentOutputAttachments is the maximum number of output attachments which can be written to by the fragment shader stage.

• maxFragmentDualSrcAttachments :: Word32

  maxFragmentDualSrcAttachments is the maximum number of output attachments which can be written to by the fragment shader stage when blending is enabled and one of the dual source blend modes is in use. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#framebuffer-dsb and dualSrcBlend.

• maxFragmentCombinedOutputResources :: Word32

  maxFragmentCombinedOutputResources is the total number of storage buffers, storage images, and output buffers which can be used in the fragment shader stage.

• maxComputeSharedMemorySize :: Word32

  maxComputeSharedMemorySize is the maximum total storage size, in bytes, available for variables declared with the Workgroup storage class in shader modules (or with the shared storage qualifier in GLSL) in the compute shader stage. The amount of storage consumed by the variables declared with the Workgroup storage class is implementation-dependent. However, the amount of storage consumed may not exceed the largest block size that would be obtained if all active variables declared with Workgroup storage class were assigned offsets in an arbitrary order by successively taking the smallest valid offset according to the Standard Storage Buffer Layout rules. (This is equivalent to using the GLSL std430 layout rules.)

• maxComputeWorkGroupCount :: (Word32, Word32, Word32)

  maxComputeWorkGroupCount[3] is the maximum number of local workgroups that can be dispatched by a single dispatch command. These three values represent the maximum number of local workgroups for the X, Y, and Z dimensions, respectively. The workgroup count parameters to the dispatch commands must be less than or equal to the corresponding limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#dispatch.

• maxComputeWorkGroupInvocations :: Word32

  maxComputeWorkGroupInvocations is the maximum total number of compute shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the LocalSize execution mode in shader modules or by the object decorated by the WorkgroupSize decoration, must be less than or equal to this limit.

• maxComputeWorkGroupSize :: (Word32, Word32, Word32)

  maxComputeWorkGroupSize[3] is the maximum size of a local compute workgroup, per dimension. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The x, y, and z sizes, as specified by the LocalSize execution mode or by the object decorated by the WorkgroupSize decoration in shader modules, must be less than or equal to the corresponding limit.

• subPixelPrecisionBits :: Word32

  subPixelPrecisionBits is the number of bits of subpixel precision in framebuffer coordinates xf and yf. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#primsrast.

• subTexelPrecisionBits :: Word32

  subTexelPrecisionBits is the number of bits of precision in the division along an axis of an image used for minification and magnification filters. 2subTexelPrecisionBits is the actual number of divisions along each axis of the image represented. Sub-texel values calculated during image sampling will snap to these locations when generating the filtered results.

• mipmapPrecisionBits :: Word32

  mipmapPrecisionBits is the number of bits of division that the LOD calculation for mipmap fetching get snapped to when determining the contribution from each mip level to the mip filtered results. 2mipmapPrecisionBits is the actual number of divisions.

• maxDrawIndexedIndexValue :: Word32

  maxDrawIndexedIndexValue is the maximum index value that can be used for indexed draw calls when using 32-bit indices. This excludes the primitive restart index value of 0xFFFFFFFF. See fullDrawIndexUint32.

• maxDrawIndirectCount :: Word32

  maxDrawIndirectCount is the maximum draw count that is supported for indirect draw calls. See multiDrawIndirect.

• maxSamplerLodBias :: Float

  maxSamplerLodBias is the maximum absolute sampler LOD bias. The sum of the mipLodBias member of the SamplerCreateInfo structure and the Bias operand of image sampling operations in shader modules (or 0 if no Bias operand is provided to an image sampling operation) are clamped to the range [-maxSamplerLodBias,+maxSamplerLodBias]. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#samplers-mipLodBias.

• maxSamplerAnisotropy :: Float

  maxSamplerAnisotropy is the maximum degree of sampler anisotropy. The maximum degree of anisotropic filtering used for an image sampling operation is the minimum of the maxAnisotropy member of the SamplerCreateInfo structure and this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#samplers-maxAnisotropy.

• maxViewports :: Word32

  maxViewports is the maximum number of active viewports. The viewportCount member of the PipelineViewportStateCreateInfo structure that is provided at pipeline creation must be less than or equal to this limit.

• maxViewportDimensions :: (Word32, Word32)

  maxViewportDimensions[2] are the maximum viewport dimensions in the X (width) and Y (height) dimensions, respectively. The maximum viewport dimensions must be greater than or equal to the largest image which can be created and used as a framebuffer attachment. See Controlling the Viewport.

• viewportBoundsRange :: (Float, Float)

  viewportBoundsRange[2] is the [minimum, maximum] range that the corners of a viewport must be contained in. This range must be at least [-2 × size, 2 × size - 1], where size = max(maxViewportDimensions[0], maxViewportDimensions[1]). See Controlling the Viewport.

  Note

  The intent of the viewportBoundsRange limit is to allow a maximum sized viewport to be arbitrarily shifted relative to the output target as long as at least some portion intersects. This would give a bounds limit of [-size + 1, 2 × size - 1] which would allow all possible non-empty-set intersections of the output target and the viewport. Since these numbers are typically powers of two, picking the signed number range using the smallest possible number of bits ends up with the specified range.

• viewportSubPixelBits :: Word32

  viewportSubPixelBits is the number of bits of subpixel precision for viewport bounds. The subpixel precision that floating-point viewport bounds are interpreted at is given by this limit.

• minMemoryMapAlignment :: Word64

  minMemoryMapAlignment is the minimum required alignment, in bytes, of host visible memory allocations within the host address space. When mapping a memory allocation with mapMemory, subtracting offset bytes from the returned pointer will always produce an integer multiple of this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#memory-device-hostaccess.

• minTexelBufferOffsetAlignment :: DeviceSize

  minTexelBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the BufferViewCreateInfo structure for texel buffers. If texelBufferAlignment is enabled, this limit is equivalent to the maximum of the uniformTexelBufferOffsetAlignmentBytes and storageTexelBufferOffsetAlignmentBytes members of PhysicalDeviceTexelBufferAlignmentPropertiesEXT, but smaller alignment is optionally: allowed by storageTexelBufferOffsetSingleTexelAlignment and uniformTexelBufferOffsetSingleTexelAlignment. If texelBufferAlignment is not enabled, BufferViewCreateInfo::offset must be a multiple of this value.

• minUniformBufferOffsetAlignment :: DeviceSize

  minUniformBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the DescriptorBufferInfo structure for uniform buffers. When a descriptor of type DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC is updated, the offset must be an integer multiple of this limit. Similarly, dynamic offsets for uniform buffers must be multiples of this limit.

• minStorageBufferOffsetAlignment :: DeviceSize

  minStorageBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the DescriptorBufferInfo structure for storage buffers. When a descriptor of type DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC is updated, the offset must be an integer multiple of this limit. Similarly, dynamic offsets for storage buffers must be multiples of this limit.

• minTexelOffset :: Int32

  minTexelOffset is the minimum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.

• maxTexelOffset :: Word32

  maxTexelOffset is the maximum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.

• minTexelGatherOffset :: Int32

  minTexelGatherOffset is the minimum offset value for the Offset, ConstOffset, or ConstOffsets image operands of any of the OpImage*Gather image instructions.

• maxTexelGatherOffset :: Word32

  maxTexelGatherOffset is the maximum offset value for the Offset, ConstOffset, or ConstOffsets image operands of any of the OpImage*Gather image instructions.

• minInterpolationOffset :: Float

  minInterpolationOffset is the minimum negative offset value for the offset operand of the InterpolateAtOffset extended instruction.

• maxInterpolationOffset :: Float

  maxInterpolationOffset is the maximum positive offset value for the offset operand of the InterpolateAtOffset extended instruction.

• subPixelInterpolationOffsetBits :: Word32

  subPixelInterpolationOffsetBits is the number of subpixel fractional bits that the x and y offsets to the InterpolateAtOffset extended instruction may be rounded to as fixed-point values.

• maxFramebufferWidth :: Word32

  maxFramebufferWidth is the maximum width for a framebuffer. The width member of the FramebufferCreateInfo structure must be less than or equal to this limit.

• maxFramebufferHeight :: Word32

  maxFramebufferHeight is the maximum height for a framebuffer. The height member of the FramebufferCreateInfo structure must be less than or equal to this limit.

• maxFramebufferLayers :: Word32

  maxFramebufferLayers is the maximum layer count for a layered framebuffer. The layers member of the FramebufferCreateInfo structure must be less than or equal to this limit.

• framebufferColorSampleCounts :: SampleCountFlags

  framebufferColorSampleCounts is a bitmask1 of SampleCountFlagBits indicating the color sample counts that are supported for all framebuffer color attachments with floating- or fixed-point formats. There is no limit that specifies the color sample counts that are supported for all color attachments with integer formats.

• framebufferDepthSampleCounts :: SampleCountFlags

  framebufferDepthSampleCounts is a bitmask1 of SampleCountFlagBits indicating the supported depth sample counts for all framebuffer depth/stencil attachments, when the format includes a depth component.

• framebufferStencilSampleCounts :: SampleCountFlags

  framebufferStencilSampleCounts is a bitmask1 of SampleCountFlagBits indicating the supported stencil sample counts for all framebuffer depth/stencil attachments, when the format includes a stencil component.

• framebufferNoAttachmentsSampleCounts :: SampleCountFlags

  framebufferNoAttachmentsSampleCounts is a bitmask1 of SampleCountFlagBits indicating the supported sample counts for a framebuffer with no attachments.

• maxColorAttachments :: Word32

  maxColorAttachments is the maximum number of color attachments that can be used by a subpass in a render pass. The colorAttachmentCount member of the SubpassDescription structure must be less than or equal to this limit.

• sampledImageColorSampleCounts :: SampleCountFlags

  sampledImageColorSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample counts supported for all 2D images created with IMAGE_TILING_OPTIMAL, usage containing IMAGE_USAGE_SAMPLED_BIT, and a non-integer color format.

• sampledImageIntegerSampleCounts :: SampleCountFlags

  sampledImageIntegerSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample counts supported for all 2D images created with IMAGE_TILING_OPTIMAL, usage containing IMAGE_USAGE_SAMPLED_BIT, and an integer color format.

• sampledImageDepthSampleCounts :: SampleCountFlags

  sampledImageDepthSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample counts supported for all 2D images created with IMAGE_TILING_OPTIMAL, usage containing IMAGE_USAGE_SAMPLED_BIT, and a depth format.

• sampledImageStencilSampleCounts :: SampleCountFlags

  sampledImageStencilSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample supported for all 2D images created with IMAGE_TILING_OPTIMAL, usage containing IMAGE_USAGE_SAMPLED_BIT, and a stencil format.

• storageImageSampleCounts :: SampleCountFlags

  storageImageSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample counts supported for all 2D images created with IMAGE_TILING_OPTIMAL, and usage containing IMAGE_USAGE_STORAGE_BIT.

• maxSampleMaskWords :: Word32

  maxSampleMaskWords is the maximum number of array elements of a variable decorated with the SampleMask built-in decoration.

• timestampComputeAndGraphics :: Bool

  timestampComputeAndGraphics specifies support for timestamps on all graphics and compute queues. If this limit is set to TRUE, all queues that advertise the QUEUE_GRAPHICS_BIT or QUEUE_COMPUTE_BIT in the QueueFamilyProperties::queueFlags support QueueFamilyProperties::timestampValidBits of at least 36. See Timestamp Queries.

• timestampPeriod :: Float

  timestampPeriod is the number of nanoseconds required for a timestamp query to be incremented by 1. See Timestamp Queries.

• maxClipDistances :: Word32

  maxClipDistances is the maximum number of clip distances that can be used in a single shader stage. The size of any array declared with the ClipDistance built-in decoration in a shader module must be less than or equal to this limit.

• maxCullDistances :: Word32

  maxCullDistances is the maximum number of cull distances that can be used in a single shader stage. The size of any array declared with the CullDistance built-in decoration in a shader module must be less than or equal to this limit.

• maxCombinedClipAndCullDistances :: Word32

  maxCombinedClipAndCullDistances is the maximum combined number of clip and cull distances that can be used in a single shader stage. The sum of the sizes of any pair of arrays declared with the ClipDistance and CullDistance built-in decoration used by a single shader stage in a shader module must be less than or equal to this limit.

• discreteQueuePriorities :: Word32

  discreteQueuePriorities is the number of discrete priorities that can be assigned to a queue based on the value of each member of DeviceQueueCreateInfo::pQueuePriorities. This must be at least 2, and levels must be spread evenly over the range, with at least one level at 1.0, and another at 0.0. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#devsandqueues-priority.

• pointSizeRange :: (Float, Float)

  pointSizeRange[2] is the range [minimum,maximum] of supported sizes for points. Values written to variables decorated with the PointSize built-in decoration are clamped to this range.

• lineWidthRange :: (Float, Float)

  lineWidthRange[2] is the range [minimum,maximum] of supported widths for lines. Values specified by the lineWidth member of the PipelineRasterizationStateCreateInfo or the lineWidth parameter to cmdSetLineWidth are clamped to this range.

• pointSizeGranularity :: Float

  pointSizeGranularity is the granularity of supported point sizes. Not all point sizes in the range defined by pointSizeRange are supported. This limit specifies the granularity (or increment) between successive supported point sizes.

• lineWidthGranularity :: Float

  lineWidthGranularity is the granularity of supported line widths. Not all line widths in the range defined by lineWidthRange are supported. This limit specifies the granularity (or increment) between successive supported line widths.

• strictLines :: Bool

  strictLines specifies whether lines are rasterized according to the preferred method of rasterization. If set to FALSE, lines may be rasterized under a relaxed set of rules. If set to TRUE, lines are rasterized as per the strict definition. See Basic Line Segment Rasterization.

• standardSampleLocations :: Bool

  standardSampleLocations specifies whether rasterization uses the standard sample locations as documented in Multisampling. If set to TRUE, the implementation uses the documented sample locations. If set to FALSE, the implementation may use different sample locations.

• optimalBufferCopyOffsetAlignment :: DeviceSize

  optimalBufferCopyOffsetAlignment is the optimal buffer offset alignment in bytes for cmdCopyBufferToImage and cmdCopyImageToBuffer. The per texel alignment requirements are enforced, but applications should use the optimal alignment for optimal performance and power use.

• optimalBufferCopyRowPitchAlignment :: DeviceSize

  optimalBufferCopyRowPitchAlignment is the optimal buffer row pitch alignment in bytes for cmdCopyBufferToImage and cmdCopyImageToBuffer. Row pitch is the number of bytes between texels with the same X coordinate in adjacent rows (Y coordinates differ by one). The per texel alignment requirements are enforced, but applications should use the optimal alignment for optimal performance and power use.

• nonCoherentAtomSize :: DeviceSize

  nonCoherentAtomSize is the size and alignment in bytes that bounds concurrent access to host-mapped device memory.