Safe Haskell	None
Language	Haskell2010

Graphics.Vulkan.Core10.DeviceInitialization

Synopsis

Documentation

newtype VkImageTiling Source #

VkImageTiling - Specifies the tiling arrangement of data in an image

Description

VK_PHYSICAL_DEVICE_TYPE_OTHER - the device does not match any other available types.

VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU - the device is typically one embedded in or tightly coupled with the host.
VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU - the device is typically a separate processor connected to the host via an interlink.
VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU - the device is typically a virtual node in a virtualization environment.
VK_PHYSICAL_DEVICE_TYPE_CPU - the device is typically running on the same processors as the host.

The physical device type is advertised for informational purposes only, and does not directly affect the operation of the system. However, the device type may correlate with other advertised properties or capabilities of the system, such as how many memory heaps there are.

Description

VK_SYSTEM_ALLOCATION_SCOPE_COMMAND specifies that the allocation is scoped to the duration of the Vulkan command.

VK_SYSTEM_ALLOCATION_SCOPE_OBJECT specifies that the allocation is scoped to the lifetime of the Vulkan object that is being created or used.
VK_SYSTEM_ALLOCATION_SCOPE_CACHE specifies that the allocation is scoped to the lifetime of a VkPipelineCache or VkValidationCacheEXT object.
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE specifies that the allocation is scoped to the lifetime of the Vulkan device.
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE specifies that the allocation is scoped to the lifetime of the Vulkan instance.

Most Vulkan commands operate on a single object, or there is a sole object that is being created or manipulated. When an allocation uses an allocation scope of VK_SYSTEM_ALLOCATION_SCOPE_OBJECT or VK_SYSTEM_ALLOCATION_SCOPE_CACHE, the allocation is scoped to the object being created or manipulated.

When an implementation requires host memory, it will make callbacks to the application using the most specific allocator and allocation scope available:

If an allocation is scoped to the duration of a command, the allocator will use the VK_SYSTEM_ALLOCATION_SCOPE_COMMAND allocation scope. The most specific allocator available is used: if the object being created or manipulated has an allocator, that object’s allocator will be used, else if the parent VkDevice has an allocator it will be used, else if the parent VkInstance has an allocator it will be used. Else,
If an allocation is associated with an object of type VkValidationCacheEXT or VkPipelineCache, the allocator will use the VK_SYSTEM_ALLOCATION_SCOPE_CACHE allocation scope. The most specific allocator available is used (cache, else device, else instance). Else,
If an allocation is scoped to the lifetime of an object, that object is being created or manipulated by the command, and that object’s type is not VkDevice or VkInstance, the allocator will use an allocation scope of VK_SYSTEM_ALLOCATION_SCOPE_OBJECT. The most specific allocator available is used (object, else device, else instance). Else,
If an allocation is scoped to the lifetime of a device, the allocator will use an allocation scope of VK_SYSTEM_ALLOCATION_SCOPE_DEVICE. The most specific allocator available is used (device, else instance). Else,
If the allocation is scoped to the lifetime of an instance and the instance has an allocator, its allocator will be used with an allocation scope of VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE.
Otherwise an implementation will allocate memory through an alternative mechanism that is unspecified.

Description

VkInstanceCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VK_QUEUE_GRAPHICS_BIT specifies that queues in this queue family support graphics operations.

VK_QUEUE_COMPUTE_BIT specifies that queues in this queue family support compute operations.
VK_QUEUE_TRANSFER_BIT specifies that queues in this queue family support transfer operations.
VK_QUEUE_SPARSE_BINDING_BIT specifies that queues in this queue family support sparse memory management operations (see Sparse Resources). If any of the sparse resource features are enabled, then at least one queue family must support this bit.

If an implementation exposes any queue family that supports graphics operations, at least one queue family of at least one physical device exposed by the implementation must support both graphics and compute operations.

Note

All commands that are allowed on a queue that supports transfer operations are also allowed on a queue that supports either graphics or compute operations. Thus, if the capabilities of a queue family include VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT, then reporting the VK_QUEUE_TRANSFER_BIT capability separately for that queue family is optional.

For further details see Queues.

Description

VK_IMAGE_CREATE_SPARSE_BINDING_BIT specifies that the image will be backed using sparse memory binding.

VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT specifies that the image can be partially backed using sparse memory binding. Images created with this flag must also be created with the VK_IMAGE_CREATE_SPARSE_BINDING_BIT flag.
VK_IMAGE_CREATE_SPARSE_ALIASED_BIT specifies that the image will be backed using sparse memory binding with memory ranges that might also simultaneously be backing another image (or another portion of the same image). Images created with this flag must also be created with the VK_IMAGE_CREATE_SPARSE_BINDING_BIT flag
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT specifies that the image can be used to create a VkImageView with a different format from the image. For multi-planar formats, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT specifies that a VkImageView can be created of a plane of the image.
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT specifies that the image can be used to create a VkImageView of type VK_IMAGE_VIEW_TYPE_CUBE or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY.
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT specifies that the image can be used to create a VkImageView of type VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY.
VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT specifies that the image can be used with a non-zero value of the splitInstanceBindRegionCount member of a VkBindImageMemoryDeviceGroupInfo structure passed into vkBindImageMemory2. This flag also has the effect of making the image use the standard sparse image block dimensions.
VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT specifies that the image having a compressed format can be used to create a VkImageView with an uncompressed format where each texel in the image view corresponds to a compressed texel block of the image.
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT specifies that the image can be created with usage flags that are not supported for the format the image is created with but are supported for at least one format a VkImageView created from the image can have.
VK_IMAGE_CREATE_DISJOINT_BIT specifies that an image with a multi-planar format must have each plane separately bound to memory, rather than having a single memory binding for the whole image; the presence of this bit distinguishes a disjoint image from an image without this bit set.
VK_IMAGE_CREATE_ALIAS_BIT specifies that two images created with the same creation parameters and aliased to the same memory can interpret the contents of the memory consistently with each other, subject to the rules described in the Memory Aliasing section. This flag further specifies that each plane of a disjoint image can share an in-memory non-linear representation with single-plane images, and that a single-plane image can share an in-memory non-linear representation with a plane of a multi-planar disjoint image, according to the rules in {html_spec_relative}#features-formats-compatible-planes. If the pNext chain includes a VkExternalMemoryImageCreateInfo or VkExternalMemoryImageCreateInfoNV structure whose handleTypes member is not 0, it is as if VK_IMAGE_CREATE_ALIAS_BIT is set.
VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT specifies that an image with a depth or depth/stencil format can be used with custom sample locations when used as a depth/stencil attachment.

See Sparse Resource Features and Sparse Physical Device Features for more details.

Description

The following bits may be set in linearTilingFeatures and optimalTilingFeatures, specifying that the features are supported by images or image views created with the queried vkGetPhysicalDeviceFormatProperties::format:

VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT specifies that an image view can be sampled from.
VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT specifies that an image view can be used as a storage images.
VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT specifies that an image view can be used as storage image that supports atomic operations.
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT specifies that an image view can be used as a framebuffer color attachment and as an input attachment.
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT specifies that an image view can be used as a framebuffer color attachment that supports blending and as an input attachment.
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT specifies that an image view can be used as a framebuffer depth/stencil attachment and as an input attachment.
VK_FORMAT_FEATURE_BLIT_SRC_BIT specifies that an image can be used as srcImage for the vkCmdBlitImage command.
VK_FORMAT_FEATURE_BLIT_DST_BIT specifies that an image can be used as dstImage for the vkCmdBlitImage command.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT specifies that if VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT is also set, an image view can be used with a sampler that has either of magFilter or minFilter set to VK_FILTER_LINEAR, or mipmapMode set to VK_SAMPLER_MIPMAP_MODE_LINEAR. If VK_FORMAT_FEATURE_BLIT_SRC_BIT is also set, an image can be used as the srcImage to vkCmdBlitImage with a filter of VK_FILTER_LINEAR. This bit must only be exposed for formats that also support the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT or VK_FORMAT_FEATURE_BLIT_SRC_BIT.
If the format being queried is a depth/stencil format, this bit only specifies that the depth aspect (not the stencil aspect) of an image of this format supports linear filtering, and that linear filtering of the depth aspect is supported whether depth compare is enabled in the sampler or not. If this bit is not present, linear filtering with depth compare disabled is unsupported and linear filtering with depth compare enabled is supported, but may compute the filtered value in an implementation-dependent manner which differs from the normal rules of linear filtering. The resulting value must be in the range [0,1] and should be proportional to, or a weighted average of, the number of comparison passes or failures.
VK_FORMAT_FEATURE_TRANSFER_SRC_BIT specifies that an image can be used as a source image for copy commands.
VK_FORMAT_FEATURE_TRANSFER_DST_BIT specifies that an image can be used as a destination image for copy commands and clear commands.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT specifies VkImage can be used as a sampled image with a min or max VkSamplerReductionModeEXT. This bit must only be exposed for formats that also support the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG specifies that VkImage can be used with a sampler that has either of magFilter or minFilter set to VK_FILTER_CUBIC_IMG, or be the source image for a blit with filter set to VK_FILTER_CUBIC_IMG. This bit must only be exposed for formats that also support the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT. If the format being queried is a depth/stencil format, this only specifies that the depth aspect is cubic filterable.
VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT specifies that an application can define a sampler Y’CBCR conversion using this format as a source, and that an image of this format can be used with a VkSamplerYcbcrConversionCreateInfo xChromaOffset and/or yChromaOffset of VK_CHROMA_LOCATION_MIDPOINT. Otherwise both xChromaOffset and yChromaOffset must be VK_CHROMA_LOCATION_COSITED_EVEN. If a format does not incorporate chroma downsampling (it is not a “422” or “420” format) but the implementation supports sampler Y’CBCR conversion for this format, the implementation must set VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT.
VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT specifies that an application can define a sampler Y’CBCR conversion using this format as a source, and that an image of this format can be used with a VkSamplerYcbcrConversionCreateInfo xChromaOffset and/or yChromaOffset of VK_CHROMA_LOCATION_COSITED_EVEN. Otherwise both xChromaOffset and yChromaOffset must be VK_CHROMA_LOCATION_MIDPOINT. If neither VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT nor VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT is set, the application must not define a sampler Y’CBCR conversion using this format as a source.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT specifies that the format can do linear sampler filtering (min/magFilter) whilst sampler Y’CBCR conversion is enabled.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT specifies that the format can have different chroma, min, and mag filters.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT specifies that reconstruction is explicit, as described in {html_spec_relative}#textures-chroma-reconstruction. If this bit is not present, reconstruction is implicit by default.
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT specifies that reconstruction can be forcibly made explicit by setting VkSamplerYcbcrConversionCreateInfo::forceExplicitReconstruction to VK_TRUE.
VK_FORMAT_FEATURE_DISJOINT_BIT specifies that a multi-planar image can have the VK_IMAGE_CREATE_DISJOINT_BIT set during image creation. An implementation must not set VK_FORMAT_FEATURE_DISJOINT_BIT for single-plane formats.

The following bits may be set in bufferFeatures, specifying that the features are supported by buffers or buffer views created with the queried vkGetPhysicalDeviceProperties::format:

VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT specifies that the format can be used to create a buffer view that can be bound to a VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER descriptor.
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT specifies that the format can be used to create a buffer view that can be bound to a VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER descriptor.
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT specifies that atomic operations are supported on VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER with this format.
VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT specifies that the format can be used as a vertex attribute format (VkVertexInputAttributeDescription::format).

Parameters

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.

size is the requested size of an allocation.
allocationType is a VkInternalAllocationType value specifying the requested type of an allocation.
allocationScope is a VkSystemAllocationScope value specifying the allocation scope of the lifetime of the allocation, as described here.

Description

This is a purely informational callback.

Parameters

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.

size is the requested size of an allocation.
allocationType is a VkInternalAllocationType value specifying the requested type of an allocation.
allocationScope is a VkSystemAllocationScope value specifying the allocation scope of the lifetime of the allocation, as described here.

Description

Parameters

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.

pOriginal must be either NULL or a pointer previously returned by pfnReallocation or pfnAllocation of the same allocator.
size is the size in bytes of the requested allocation.
alignment is the requested alignment of the allocation in bytes and must be a power of two.
allocationScope is a VkSystemAllocationScope value specifying the allocation scope of the lifetime of the allocation, as described here.

Description

pfnReallocation must return an allocation with enough space for size bytes, and the contents of the original allocation from bytes zero to min(original size, new size) - 1 must be preserved in the returned allocation. If size is larger than the old size, the contents of the additional space are undefined. If satisfying these requirements involves creating a new allocation, then the old allocation should be freed.

If pOriginal is NULL, then pfnReallocation must behave equivalently to a call to PFN_vkAllocationFunction with the same parameter values (without pOriginal).

If size is zero, then pfnReallocation must behave equivalently to a call to PFN_vkFreeFunction with the same pUserData parameter value, and pMemory equal to pOriginal.

If pOriginal is non-NULL, the implementation must ensure that alignment is equal to the alignment used to originally allocate pOriginal.

If this function fails and pOriginal is non-NULL the application must not free the old allocation.

pfnReallocation must follow the same rules for return values as PFN_vkAllocationFunction.

Parameters

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.

size is the size in bytes of the requested allocation.
alignment is the requested alignment of the allocation in bytes and must be a power of two.
allocationScope is a VkSystemAllocationScope value specifying the allocation scope of the lifetime of the allocation, as described here.

Description

If pfnAllocation is unable to allocate the requested memory, it must return NULL. If the allocation was successful, it must return a valid pointer to memory allocation containing at least size bytes, and with the pointer value being a multiple of alignment.

Note

Correct Vulkan operation cannot be assumed if the application does not follow these rules.

For example, pfnAllocation (or pfnReallocation) could cause termination of running Vulkan instance(s) on a failed allocation for debugging purposes, either directly or indirectly. In these circumstances, it cannot be assumed that any part of any affected VkInstance objects are going to operate correctly (even vkDestroyInstance), and the application must ensure it cleans up properly via other means (e.g. process termination).

If pfnAllocation returns NULL, and if the implementation is unable to continue correct processing of the current command without the requested allocation, it must treat this as a run-time error, and generate VK_ERROR_OUT_OF_HOST_MEMORY at the appropriate time for the command in which the condition was detected, as described in Return Codes.

If the implementation is able to continue correct processing of the current command without the requested allocation, then it may do so, and must not generate VK_ERROR_OUT_OF_HOST_MEMORY as a result of this failed allocation.

Parameters

pUserData is the value specified for VkAllocationCallbacks::pUserData in the allocator specified by the application.

pMemory is the allocation to be freed.

Description

pMemory may be NULL, which the callback must handle safely. If pMemory is non-NULL, it must be a pointer previously allocated by pfnAllocation or pfnReallocation. The application should free this memory.

Parameters

Description

Parameters

pCreateInfo points to an instance of VkInstanceCreateInfo controlling creation of the instance.

pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pInstance points a VkInstance handle in which the resulting instance is returned.

Description

vkCreateInstance verifies that the requested layers exist. If not, vkCreateInstance will return VK_ERROR_LAYER_NOT_PRESENT. Next vkCreateInstance verifies that the requested extensions are supported (e.g. in the implementation or in any enabled instance layer) and if any requested extension is not supported, vkCreateInstance must return VK_ERROR_EXTENSION_NOT_PRESENT. After verifying and enabling the instance layers and extensions the VkInstance object is created and returned to the application. If a requested extension is only supported by a layer, both the layer and the extension need to be specified at vkCreateInstance time for the creation to succeed.

Valid Usage

All required extensions for each extension in the VkInstanceCreateInfo::ppEnabledExtensionNames list must also be present in that list.

Valid Usage (Implicit)

pCreateInfo must be a valid pointer to a valid VkInstanceCreateInfo structure

If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pInstance must be a valid pointer to a VkInstance handle

Return Codes

Success: - VK_SUCCESS

Failure

- VK_ERROR_OUT_OF_HOST_MEMORY

```
VK_ERROR_OUT_OF_DEVICE_MEMORY
```
```
VK_ERROR_INITIALIZATION_FAILED
```
```
VK_ERROR_LAYER_NOT_PRESENT
```
```
VK_ERROR_EXTENSION_NOT_PRESENT
```
```
VK_ERROR_INCOMPATIBLE_DRIVER
```

Parameters

instance is the handle of the instance to destroy.

pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Description

Valid Usage

All child objects created using instance must have been destroyed prior to destroying instance

If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here
If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL

Valid Usage (Implicit)

If instance is not NULL, instance must be a valid VkInstance handle

If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure

Host Synchronization

Host access to instance must be externally synchronized

Parameters

instance is a handle to a Vulkan instance previously created with vkCreateInstance.

pPhysicalDeviceCount is a pointer to an integer related to the number of physical devices available or queried, as described below.
pPhysicalDevices is either NULL or a pointer to an array of VkPhysicalDevice handles.

Description

If pPhysicalDevices is NULL, then the number of physical devices available is returned in pPhysicalDeviceCount. Otherwise, pPhysicalDeviceCount must point to a variable set by the user to the number of elements in the pPhysicalDevices array, and on return the variable is overwritten with the number of handles actually written to pPhysicalDevices. If pPhysicalDeviceCount is less than the number of physical devices available, at most pPhysicalDeviceCount structures will be written. If pPhysicalDeviceCount is smaller than the number of physical devices available, VK_INCOMPLETE will be returned instead of VK_SUCCESS, to indicate that not all the available physical devices were returned.

Valid Usage (Implicit)

instance must be a valid VkInstance handle

pPhysicalDeviceCount must be a valid pointer to a uint32_t value
If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a valid pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles

Return Codes

Success

- VK_SUCCESS

```
VK_INCOMPLETE
```

Failure

- VK_ERROR_OUT_OF_HOST_MEMORY

```
VK_ERROR_OUT_OF_DEVICE_MEMORY
```
```
VK_ERROR_INITIALIZATION_FAILED
```

Parameters

The table below defines the various use cases for vkGetDeviceProcAddr and expected return value for each case.

Description

The returned function pointer is of type PFN_vkVoidFunction, and must be cast to the type of the command being queried. The function pointer must only be called with a dispatchable object (the first parameter) that is device or a child of device.

+-----------------------+-----------------------+-----------------------+
| @device@              | @pName@               | return value          |
+=======================+=======================+=======================+
| @NULL@                | *                     | undefined             |
+-----------------------+-----------------------+-----------------------+
| invalid device        | *                     | undefined             |
+-----------------------+-----------------------+-----------------------+
| device                | @NULL@                | undefined             |
+-----------------------+-----------------------+-----------------------+
| device                | core device-level     | fp                    |
|                       | Vulkan command        |                       |
+-----------------------+-----------------------+-----------------------+
| device                | enabled device        | fp                    |
|                       | extension commands    |                       |
+-----------------------+-----------------------+-----------------------+
| device                | * (any @pName@ not    | @NULL@                |
|                       | covered above)        |                       |
+-----------------------+-----------------------+-----------------------+

vkGetDeviceProcAddr behavior

Valid Usage (Implicit)

device must be a valid VkDevice handle

pName must be a null-terminated UTF-8 string

Parameters

instance is the instance that the function pointer will be compatible with, or NULL for commands not dependent on any instance.

pName is the name of the command to obtain.

Description

vkGetInstanceProcAddr itself is obtained in a platform- and loader- specific manner. Typically, the loader library will export this command as a function symbol, so applications can link against the loader library, or load it dynamically and look up the symbol using platform-specific APIs.

The table below defines the various use cases for vkGetInstanceProcAddr and expected return value (“fp” is “function pointer”) for each case.

The returned function pointer is of type PFN_vkVoidFunction, and must be cast to the type of the command being queried.

+-----------------------+-----------------------+-----------------------+
| @instance@            | @pName@               | return value          |
+=======================+=======================+=======================+
| *                     | @NULL@                | undefined             |
+-----------------------+-----------------------+-----------------------+
| invalid instance      | *                     | undefined             |
+-----------------------+-----------------------+-----------------------+
| @NULL@                | 'Graphics.Vulkan.Core | fp                    |
|                       | 10.ExtensionDiscovery |                       |
|                       | .vkEnumerateInstanceE |                       |
|                       | xtensionProperties'   |                       |
+-----------------------+-----------------------+-----------------------+
| @NULL@                | 'Graphics.Vulkan.Core | fp                    |
|                       | 10.LayerDiscovery.vkE |                       |
|                       | numerateInstanceLayer |                       |
|                       | Properties'           |                       |
+-----------------------+-----------------------+-----------------------+
| @NULL@                | 'vkCreateInstance'    | fp                    |
+-----------------------+-----------------------+-----------------------+
| @NULL@                | * (any @pName@ not    | @NULL@                |
|                       | covered above)        |                       |
+-----------------------+-----------------------+-----------------------+
| instance              | core Vulkan command   | fp1                   |
+-----------------------+-----------------------+-----------------------+
| instance              | enabled instance      | fp1                   |
|                       | extension commands    |                       |
|                       | for @instance@        |                       |
+-----------------------+-----------------------+-----------------------+
| instance              | available device      | fp1                   |
|                       | extension2 commands   |                       |
|                       | for @instance@        |                       |
+-----------------------+-----------------------+-----------------------+
| instance              | * (any @pName@ not    | @NULL@                |
|                       | covered above)        |                       |
+-----------------------+-----------------------+-----------------------+

vkGetInstanceProcAddr behavior

1: The returned function pointer must only be called with a dispatchable object (the first parameter) that is instance or a child of instance, e.g. VkInstance, VkPhysicalDevice, VkDevice, VkQueue, or VkCommandBuffer.
2: An “available device extension” is a device extension supported by any physical device enumerated by instance.

Valid Usage (Implicit)

If instance is not NULL, instance must be a valid VkInstance handle

pName must be a null-terminated UTF-8 string

Parameters

physicalDevice is the handle to the physical device whose properties will be queried.

pProperties points to an instance of the VkPhysicalDeviceProperties structure, that will be filled with returned information.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle

pProperties must be a valid pointer to a VkPhysicalDeviceProperties structure

Parameters

physicalDevice is the handle to the physical device whose properties will be queried.

pQueueFamilyPropertyCount is a pointer to an integer related to the number of queue families available or queried, as described below.
pQueueFamilyProperties is either NULL or a pointer to an array of VkQueueFamilyProperties structures.

Description

If pQueueFamilyProperties is NULL, then the number of queue families available is returned in pQueueFamilyPropertyCount. Otherwise, pQueueFamilyPropertyCount must point to a variable set by the user to the number of elements in the pQueueFamilyProperties array, and on return the variable is overwritten with the number of structures actually written to pQueueFamilyProperties. If pQueueFamilyPropertyCount is less than the number of queue families available, at most pQueueFamilyPropertyCount structures will be written.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle

pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value
If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures

Parameters

physicalDevice is the handle to the device to query.

pMemoryProperties points to an instance of VkPhysicalDeviceMemoryProperties structure in which the properties are returned.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle

pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties structure

Parameters

physicalDevice is the physical device from which to query the supported features.

pFeatures is a pointer to a VkPhysicalDeviceFeatures structure in which the physical device features are returned. For each feature, a value of VK_TRUE specifies that the feature is supported on this physical device, and VK_FALSE specifies that the feature is not supported.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle

pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures structure

Parameters

physicalDevice is the physical device from which to query the format properties.

format is the format whose properties are queried.
pFormatProperties is a pointer to a VkFormatProperties structure in which physical device properties for format are returned.

Description

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle

format must be a valid VkFormat value
pFormatProperties must be a valid pointer to a VkFormatProperties structure

Parameters

physicalDevice is the physical device from which to query the image capabilities.

format is a VkFormat value specifying the image format, corresponding to VkImageCreateInfo::format.
type is a VkImageType value specifying the image type, corresponding to VkImageCreateInfo::imageType.
tiling is a VkImageTiling value specifying the image tiling, corresponding to VkImageCreateInfo::tiling.
usage is a bitmask of VkImageUsageFlagBits specifying the intended usage of the image, corresponding to VkImageCreateInfo::usage.
flags is a bitmask of VkImageCreateFlagBits specifying additional parameters of the image, corresponding to VkImageCreateInfo::flags.
pImageFormatProperties points to an instance of the VkImageFormatProperties structure in which capabilities are returned.

Description

The format, type, tiling, usage, and flags parameters correspond to parameters that would be consumed by vkCreateImage (as members of VkImageCreateInfo).

If format is not a supported image format, or if the combination of format, type, tiling, usage, and flags is not supported for images, then vkGetPhysicalDeviceImageFormatProperties returns VK_ERROR_FORMAT_NOT_SUPPORTED.

The limitations on an image format that are reported by vkGetPhysicalDeviceImageFormatProperties have the following property: if usage1 and usage2 of type VkImageUsageFlags are such that the bits set in usage1 are a subset of the bits set in usage2, and flags1 and flags2 of type VkImageCreateFlags are such that the bits set in flags1 are a subset of the bits set in flags2, then the limitations for usage1 and flags1 must be no more strict than the limitations for usage2 and flags2, for all values of format, type, and tiling.

Valid Usage (Implicit)

physicalDevice must be a valid VkPhysicalDevice handle

format must be a valid VkFormat value
type must be a valid VkImageType value
tiling must be a valid VkImageTiling value
usage must be a valid combination of VkImageUsageFlagBits values
usage must not be 0
flags must be a valid combination of VkImageCreateFlagBits values
pImageFormatProperties must be a valid pointer to a VkImageFormatProperties structure

Return Codes

Success: - VK_SUCCESS

Failure

- VK_ERROR_OUT_OF_HOST_MEMORY

```
VK_ERROR_OUT_OF_DEVICE_MEMORY
```
```
VK_ERROR_FORMAT_NOT_SUPPORTED
```

Description

The vendorID and deviceID fields are provided to allow applications to adapt to device characteristics that are not adequately exposed by other Vulkan queries.

Note

These may include performance profiles, hardware errata, or other characteristics.

The vendor identified by vendorID is the entity responsible for the most salient characteristics of the underlying implementation of the VkPhysicalDevice being queried.

Note

For example, in the case of a discrete GPU implementation, this should be the GPU chipset vendor. In the case of a hardware accelerator integrated into a system-on-chip (SoC), this should be the supplier of the silicon IP used to create the accelerator.

If the vendor has a PCI vendor ID, the low 16 bits of vendorID must contain that PCI vendor ID, and the remaining bits must be set to zero. Otherwise, the value returned must be a valid Khronos vendor ID, obtained as described in the Vulkan Documentation and Extensions document in the section “Registering a Vendor ID with Khronos”. Khronos vendor IDs are allocated starting at 0x10000, to distinguish them from the PCI vendor ID namespace.

The vendor is also responsible for the value returned in deviceID. If the implementation is driven primarily by a PCI device with a PCI device ID, the low 16 bits of deviceID must contain that PCI device ID, and the remaining bits must be set to zero. Otherwise, the choice of what values to return may be dictated by operating system or platform policies - but should uniquely identify both the device version and any major configuration options (for example, core count in the case of multicore devices).

Note

The same device ID should be used for all physical implementations of that device version and configuration. For example, all uses of a specific silicon IP GPU version and configuration should use the same device ID, even if those uses occur in different SoCs.

Description

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_APPLICATION_INFO

pNext must be NULL
If pApplicationName is not NULL, pApplicationName must be a null-terminated UTF-8 string
If pEngineName is not NULL, pEngineName must be a null-terminated UTF-8 string

Description

Valid Usage

pfnAllocation must be a valid pointer to a valid user-defined PFN_vkAllocationFunction

pfnReallocation must be a valid pointer to a valid user-defined PFN_vkReallocationFunction
pfnFree must be a valid pointer to a valid user-defined PFN_vkFreeFunction
If either of pfnInternalAllocation or pfnInternalFree is not NULL, both must be valid callbacks

Description

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO

Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT, VkDebugUtilsMessengerCreateInfoEXT, or VkValidationFlagsEXT
Each sType member in the pNext chain must be unique
flags must be 0
If pApplicationInfo is not NULL, pApplicationInfo must be a valid pointer to a valid VkApplicationInfo structure
If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings
If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings

Description

The value returned in minImageTransferGranularity has a unit of compressed texel blocks for images having a block-compressed format, and a unit of texels otherwise.

Possible values of minImageTransferGranularity are:

(0,0,0) which indicates that only whole mip levels must be transferred using the image transfer operations on the corresponding queues. In this case, the following restrictions apply to all offset and extent parameters of image transfer operations:
- The x, y, and z members of a VkOffset3D parameter must always be zero.
- The width, height, and depth members of a VkExtent3D parameter must always match the width, height, and depth of the image subresource corresponding to the parameter, respectively.
(Ax, Ay, Az) where Ax, Ay, and Az are all integer powers of two. In this case the following restrictions apply to all image transfer operations:
- x, y, and z of a VkOffset3D parameter must be integer multiples of Ax, Ay, and Az, respectively.
- width of a VkExtent3D parameter must be an integer multiple of Ax, or else x + width must equal the width of the image subresource corresponding to the parameter.
- height of a VkExtent3D parameter must be an integer multiple of Ay, or else y + height must equal the height of the image subresource corresponding to the parameter.
- depth of a VkExtent3D parameter must be an integer multiple of Az, or else z + depth must equal the depth of the image subresource corresponding to the parameter.
- If the format of the image corresponding to the parameters is one of the block-compressed formats then for the purposes of the above calculations the granularity must be scaled up by the compressed texel block dimensions.

Queues supporting graphics and/or compute operations must report (1,1,1) in minImageTransferGranularity, meaning that there are no additional restrictions on the granularity of image transfer operations for these queues. Other queues supporting image transfer operations are only required to support whole mip level transfers, thus minImageTransferGranularity for queues belonging to such queue families may be (0,0,0).

The Device Memory section describes memory properties queried from the physical device.

For physical device feature queries see the Features chapter.

Description

The VkPhysicalDeviceMemoryProperties structure describes a number of memory heaps as well as a number of memory types that can be used to access memory allocated in those heaps. Each heap describes a memory resource of a particular size, and each memory type describes a set of memory properties (e.g. host cached vs uncached) that can be used with a given memory heap. Allocations using a particular memory type will consume resources from the heap indicated by that memory type’s heap index. More than one memory type may share each heap, and the heaps and memory types provide a mechanism to advertise an accurate size of the physical memory resources while allowing the memory to be used with a variety of different properties.

The number of memory heaps is given by memoryHeapCount and is less than or equal to VK_MAX_MEMORY_HEAPS. Each heap is described by an element of the memoryHeaps array as a VkMemoryHeap structure. The number of memory types available across all memory heaps is given by memoryTypeCount and is less than or equal to VK_MAX_MEMORY_TYPES. Each memory type is described by an element of the memoryTypes array as a VkMemoryType structure.

At least one heap must include VK_MEMORY_HEAP_DEVICE_LOCAL_BIT in VkMemoryHeap::flags. If there are multiple heaps that all have similar performance characteristics, they may all include VK_MEMORY_HEAP_DEVICE_LOCAL_BIT. In a unified memory architecture (UMA) system there is often only a single memory heap which is considered to be equally “local” to the host and to the device, and such an implementation must advertise the heap as device-local.

Each memory type returned by vkGetPhysicalDeviceMemoryProperties must have its propertyFlags set to one of the following values:

0
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
```
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
```
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT

There must be at least one memory type with both the VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT and VK_MEMORY_PROPERTY_HOST_COHERENT_BIT bits set in its propertyFlags. There must be at least one memory type with the VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT bit set in its propertyFlags.

For each pair of elements X and Y returned in memoryTypes, X must be placed at a lower index position than Y if:

either the set of bit flags returned in the propertyFlags member of X is a strict subset of the set of bit flags returned in the propertyFlags member of Y.
or the propertyFlags members of X and Y are equal, and X belongs to a memory heap with greater performance (as determined in an implementation-specific manner).

Note

There is no ordering requirement between X and Y elements for the case their propertyFlags members are not in a subset relation. That potentially allows more than one possible way to order the same set of memory types. Notice that the list of all allowed memory property flag combinations is written in the required order. But if instead VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT was before VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, the list would still be in the required order.

This ordering requirement enables applications to use a simple search loop to select the desired memory type along the lines of:

// Find a memory in `memoryTypeBitsRequirement` that includes all of `requiredProperties`
int32_t findProperties(const VkPhysicalDeviceMemoryProperties* pMemoryProperties,
                       uint32_t memoryTypeBitsRequirement,
                       VkMemoryPropertyFlags requiredProperties) {
    const uint32_t memoryCount = pMemoryProperties->memoryTypeCount;
    for (uint32_t memoryIndex = 0; memoryIndex < memoryCount; ++memoryIndex) {
        const uint32_t memoryTypeBits = (1 << memoryIndex);
        const bool isRequiredMemoryType = memoryTypeBitsRequirement & memoryTypeBits;

        const VkMemoryPropertyFlags properties =
            pMemoryProperties->memoryTypes[memoryIndex].propertyFlags;
        const bool hasRequiredProperties =
            (properties & requiredProperties) == requiredProperties;

        if (isRequiredMemoryType && hasRequiredProperties)
            return static_cast<int32_t>(memoryIndex);
    }

    // failed to find memory type
    return -1;
}

// Try to find an optimal memory type, or if it does not exist try fallback memory type
// `device` is the VkDevice
// `image` is the VkImage that requires memory to be bound
// `memoryProperties` properties as returned by vkGetPhysicalDeviceMemoryProperties
// `requiredProperties` are the property flags that must be present
// `optimalProperties` are the property flags that are preferred by the application
VkMemoryRequirements memoryRequirements;
vkGetImageMemoryRequirements(device, image, &memoryRequirements);
int32_t memoryType =
    findProperties(&memoryProperties, memoryRequirements.memoryTypeBits, optimalProperties);
if (memoryType == -1) // not found; try fallback properties
    memoryType =
        findProperties(&memoryProperties, memoryRequirements.memoryTypeBits, requiredProperties);

Description

Note

If no format feature flags are supported, the format itself is not supported, and images of that format cannot be created.

If format is a block-compression format, then buffers must not support any features for the format.

Members

maxExtent are the maximum image dimensions. See the Allowed Extent Values section below for how these values are constrained by type.

maxMipLevels is the maximum number of mipmap levels. maxMipLevels must be equal to ⌈log2(max(width, height, depth))⌉ + 1, where width, height, and depth are taken from the corresponding members of maxExtent, except when one of the following conditions is true, in which case it may instead be 1:
- vkGetPhysicalDeviceImageFormatProperties::tiling was VK_IMAGE_TILING_LINEAR
- the VkPhysicalDeviceImageFormatInfo2::pNext chain included an instance of VkPhysicalDeviceExternalImageFormatInfo with a handle type included in the handleTypes member for which mipmap image support is not required
maxArrayLayers is the maximum number of array layers. maxArrayLayers must either be equal to 1 or be greater than or equal to the maxImageArrayLayers member of VkPhysicalDeviceLimits. A value of 1 is valid only if tiling is VK_IMAGE_TILING_LINEAR or if type is VK_IMAGE_TYPE_3D.
sampleCounts is a bitmask of VkSampleCountFlagBits specifying all the supported sample counts for this image as described below.
maxResourceSize is an upper bound on the total image size in bytes, inclusive of all image subresources. Implementations may have an address space limit on total size of a resource, which is advertised by this property. maxResourceSize must be at least 231.

Description

Note

There is no mechanism to query the size of an image before creating it, to compare that size against maxResourceSize. If an application attempts to create an image that exceeds this limit, the creation will fail and vkCreateImage will return VK_ERROR_OUT_OF_DEVICE_MEMORY. While the advertised limit must be at least 231, it may not be possible to create an image that approaches that size, particularly for VK_IMAGE_TYPE_1D.

If the combination of parameters to vkGetPhysicalDeviceImageFormatProperties is not supported by the implementation for use in vkCreateImage, then all members of VkImageFormatProperties will be filled with zero.

Note

Filling VkImageFormatProperties with zero for unsupported formats is an exception to the usual rule that output structures have undefined contents on error. This exception was unintentional, but is preserved for backwards compatibility.

Members

The members of the VkPhysicalDeviceFeatures structure describe the following features:

Description

robustBufferAccess specifies that accesses to buffers are bounds-checked against the range of the buffer descriptor (as determined by VkDescriptorBufferInfo::range, VkBufferViewCreateInfo::range, or the size of the buffer). Out of bounds accesses must not cause application termination, and the effects of shader loads, stores, and atomics must conform to an implementation-dependent behavior as described below.
- A buffer access is considered to be out of bounds if any of the following are true:
  - 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.
    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 in a given SPIR-V block is determined to be out of bounds, then any other access of the same type (load, store, or atomic) in the same SPIR-V block that accesses an address less than 16 bytes away from the out of bounds address may also be considered out of bounds.
- Out-of-bounds buffer loads will return any of the following values:
  - Values from anywhere within the memory range(s) bound to the buffer (possibly including bytes of memory past the end of the buffer, up to the end of the bound range).
  - Zero values, or (0,0,0,x) vectors for vector reads where x is a valid value represented in the type of the vector components and may be any of:
    - 0, 1, or the maximum representable positive integer value, for signed or unsigned integer components
    - 0.0 or 1.0, for floating-point components
- Out-of-bounds writes may modify values within the memory range(s) bound to the buffer, but 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, out of bounds accesses may corrupt any memory within the process and cause undefined behavior up to and including application termination.

fullDrawIndexUint32 specifies the full 32-bit range of indices is supported for indexed draw calls when using a VkIndexType of VK_INDEX_TYPE_UINT32. maxDrawIndexedIndexValue is the maximum index value that may be used (aside from the primitive restart index, which is always 232-1 when the VkIndexType is VK_INDEX_TYPE_UINT32). If this feature is supported, maxDrawIndexedIndexValue must be 232-1; otherwise it must be no smaller than 224-1. See maxDrawIndexedIndexValue.
imageCubeArray specifies whether image views with a VkImageViewType of VK_IMAGE_VIEW_TYPE_CUBE_ARRAY can be created, and that the corresponding SampledCubeArray and ImageCubeArray SPIR-V capabilities can be used in shader code.
independentBlend specifies whether the VkPipelineColorBlendAttachmentState settings are controlled independently per-attachment. If this feature is not enabled, the VkPipelineColorBlendAttachmentState settings for all color attachments must be identical. Otherwise, a different VkPipelineColorBlendAttachmentState can be provided for each bound color attachment.
geometryShader specifies whether geometry shaders are supported. If this feature is not enabled, the VK_SHADER_STAGE_GEOMETRY_BIT and VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT enum values must not be used. This also specifies whether shader modules can declare the Geometry capability.
tessellationShader specifies whether tessellation control and evaluation shaders are supported. If this feature is not enabled, the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, and VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO enum values must not be used. This also specifies whether shader modules can declare the Tessellation capability.
sampleRateShading specifies whether Sample Shading and multisample interpolation are supported. If this feature is not enabled, the sampleShadingEnable member of the VkPipelineMultisampleStateCreateInfo structure must be set to VK_FALSE and the minSampleShading member is ignored. This also specifies whether shader modules can declare the SampleRateShading capability.
dualSrcBlend specifies whether blend operations which take two sources are supported. If this feature is not enabled, the VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, and VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA enum values must not be used as source or destination blending factors. See {html_spec_relative}#framebuffer-dsb.
logicOp specifies whether logic operations are supported. If this feature is not enabled, the logicOpEnable member of the VkPipelineColorBlendStateCreateInfo structure must be set to VK_FALSE, and the logicOp member is ignored.
multiDrawIndirect specifies whether multiple draw indirect is supported. If this feature is not enabled, the drawCount parameter to the vkCmdDrawIndirect and vkCmdDrawIndexedIndirect commands must be 0 or 1. The maxDrawIndirectCount member of the VkPhysicalDeviceLimits structure must also be 1 if this feature is not supported. See maxDrawIndirectCount.
drawIndirectFirstInstance specifies whether indirect draw calls support the firstInstance parameter. If this feature is not enabled, the firstInstance member of all VkDrawIndirectCommand and VkDrawIndexedIndirectCommand structures that are provided to the vkCmdDrawIndirect and vkCmdDrawIndexedIndirect commands must be 0.
depthClamp specifies whether depth clamping is supported. If this feature is not enabled, the depthClampEnable member of the VkPipelineRasterizationStateCreateInfo structure must be set to VK_FALSE. Otherwise, setting depthClampEnable to VK_TRUE will enable depth clamping.
depthBiasClamp specifies whether depth bias clamping is supported. If this feature is not enabled, the depthBiasClamp member of the VkPipelineRasterizationStateCreateInfo structure must be set to 0.0 unless the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state is enabled, and the depthBiasClamp parameter to vkCmdSetDepthBias must be set to 0.0.
fillModeNonSolid specifies whether point and wireframe fill modes are supported. If this feature is not enabled, the VK_POLYGON_MODE_POINT and VK_POLYGON_MODE_LINE enum values must not be used.
depthBounds specifies whether depth bounds tests are supported. If this feature is not enabled, the depthBoundsTestEnable member of the VkPipelineDepthStencilStateCreateInfo structure must be set to VK_FALSE. When depthBoundsTestEnable is set to VK_FALSE, the minDepthBounds and maxDepthBounds members of the VkPipelineDepthStencilStateCreateInfo structure are ignored.
wideLines specifies whether lines with width other than 1.0 are supported. If this feature is not enabled, the lineWidth member of the VkPipelineRasterizationStateCreateInfo structure must be set to 1.0 unless the VK_DYNAMIC_STATE_LINE_WIDTH dynamic state is enabled, and the lineWidth parameter to vkCmdSetLineWidth must be set to 1.0. When this feature is supported, the range and granularity of supported line widths are indicated by the lineWidthRange and lineWidthGranularity members of the VkPhysicalDeviceLimits structure, respectively.
largePoints 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 VkPhysicalDeviceLimits structure, respectively.
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 VkPipelineMultisampleStateCreateInfo structure must be set to VK_FALSE. Otherwise setting alphaToOneEnable to VK_TRUE will enable alpha-to-one behavior.
multiViewport specifies whether more than one viewport is supported. If this feature is not enabled, the viewportCount and scissorCount members of the VkPipelineViewportStateCreateInfo structure must be set to 1. Similarly, the viewportCount parameter to the vkCmdSetViewport command and the scissorCount parameter to the vkCmdSetScissor command must be 1, and the firstViewport parameter to the vkCmdSetViewport command and the firstScissor parameter to the vkCmdSetScissor command must be 0.
samplerAnisotropy specifies whether anisotropic filtering is supported. If this feature is not enabled, the anisotropyEnable member of the VkSamplerCreateInfo structure must be VK_FALSE.
textureCompressionETC2 specifies whether all of the ETC2 and EAC compressed texture formats are supported. If this feature is enabled, then the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, VK_FORMAT_FEATURE_BLIT_SRC_BIT and VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:
- ```
VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
```
- ```
VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
```
- ```
VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
```
- ```
VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
```
- ```
VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
```
- ```
VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
```
- ```
VK_FORMAT_EAC_R11_UNORM_BLOCK
```
- ```
VK_FORMAT_EAC_R11_SNORM_BLOCK
```
- ```
VK_FORMAT_EAC_R11G11_UNORM_BLOCK
```
- ```
VK_FORMAT_EAC_R11G11_SNORM_BLOCK
```
vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for additional supported properties of individual formats.

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

```
VK_FORMAT_ASTC_4x4_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_4x4_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_5x4_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_5x4_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_5x5_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_5x5_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_6x5_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_6x5_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_6x6_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_6x6_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_8x5_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_8x5_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_8x6_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_8x6_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_8x8_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_8x8_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_10x5_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_10x5_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_10x6_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_10x6_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_10x8_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_10x8_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_10x10_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_10x10_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_12x10_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_12x10_SRGB_BLOCK
```
```
VK_FORMAT_ASTC_12x12_UNORM_BLOCK
```
```
VK_FORMAT_ASTC_12x12_SRGB_BLOCK
```

vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for additional supported properties of individual formats.

textureCompressionBC specifies whether all of the BC compressed texture formats are supported. If this feature is enabled, then the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, VK_FORMAT_FEATURE_BLIT_SRC_BIT and VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:
- ```
VK_FORMAT_BC1_RGB_UNORM_BLOCK
```
- ```
VK_FORMAT_BC1_RGB_SRGB_BLOCK
```
- ```
VK_FORMAT_BC1_RGBA_UNORM_BLOCK
```
- ```
VK_FORMAT_BC1_RGBA_SRGB_BLOCK
```
- ```
VK_FORMAT_BC2_UNORM_BLOCK
```
- ```
VK_FORMAT_BC2_SRGB_BLOCK
```
- ```
VK_FORMAT_BC3_UNORM_BLOCK
```
- ```
VK_FORMAT_BC3_SRGB_BLOCK
```
- ```
VK_FORMAT_BC4_UNORM_BLOCK
```
- ```
VK_FORMAT_BC4_SNORM_BLOCK
```
- ```
VK_FORMAT_BC5_UNORM_BLOCK
```
- ```
VK_FORMAT_BC5_SNORM_BLOCK
```
- ```
VK_FORMAT_BC6H_UFLOAT_BLOCK
```
- ```
VK_FORMAT_BC6H_SFLOAT_BLOCK
```
- ```
VK_FORMAT_BC7_UNORM_BLOCK
```
- ```
VK_FORMAT_BC7_SRGB_BLOCK
```
vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for additional supported properties of individual formats.
occlusionQueryPrecise specifies whether occlusion queries returning actual sample counts are supported. Occlusion queries are created in a VkQueryPool by specifying the queryType of VK_QUERY_TYPE_OCCLUSION in the VkQueryPoolCreateInfo structure which is passed to vkCreateQueryPool. If this feature is enabled, queries of this type can enable VK_QUERY_CONTROL_PRECISE_BIT in the flags parameter to vkCmdBeginQuery. If this feature is not supported, the implementation supports only boolean occlusion queries. When any samples are passed, boolean queries will return a non-zero result value, otherwise a result value of zero is returned. When this feature is enabled and VK_QUERY_CONTROL_PRECISE_BIT is set, occlusion queries will report the actual number of samples passed.
pipelineStatisticsQuery specifies whether the pipeline statistics queries are supported. If this feature is not enabled, queries of type VK_QUERY_TYPE_PIPELINE_STATISTICS cannot be created, and none of the VkQueryPipelineStatisticFlagBits bits can be set in the pipelineStatistics member of the VkQueryPoolCreateInfo structure.
vertexPipelineStoresAndAtomics 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 NonWriteable decoration (or the readonly memory qualifier in GLSL).
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 NonWriteable decoration (or the readonly memory qualifier in GLSL).
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 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 specifies whether the extended storage image formats are available in shader code. If this feature is not enabled, the formats requiring the StorageImageExtendedFormats capability are not supported for storage images. This also specifies whether shader modules can declare the StorageImageExtendedFormats capability.
shaderStorageImageMultisample specifies whether multisampled storage images are supported. If this feature is not enabled, images that are created with a usage that includes VK_IMAGE_USAGE_STORAGE_BIT must be created with samples equal to VK_SAMPLE_COUNT_1_BIT. This also specifies whether shader modules can declare the StorageImageMultisample capability.
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 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 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 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the UniformBufferArrayDynamicIndexing capability.
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 VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the SampledImageArrayDynamicIndexing capability.
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 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the StorageBufferArrayDynamicIndexing capability.
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 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the StorageImageArrayDynamicIndexing capability.
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 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 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.
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.
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.
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 specifies whether image operations that specify 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 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 vkBindBufferMemory and vkBindImageMemory commands. In this case, buffers and images must not be created with VK_BUFFER_CREATE_SPARSE_BINDING_BIT and VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in the flags member of the VkBufferCreateInfo and VkImageCreateInfo structures, respectively. Otherwise resource memory can be managed as described in Sparse Resource Features.
sparseResidencyBuffer specifies whether the device can access partially resident buffers. If this feature is not enabled, buffers must not be created with VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkBufferCreateInfo structure.
sparseResidencyImage2D 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 VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_1_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidencyImage3D specifies whether the device can access partially resident 3D images. If this feature is not enabled, images with an imageType of VK_IMAGE_TYPE_3D must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidency2Samples 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 VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_2_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidency4Samples 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 VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_4_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidency8Samples 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 VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_8_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidency16Samples 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 VK_IMAGE_TYPE_2D and samples set to VK_SAMPLE_COUNT_16_BIT must not be created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the VkImageCreateInfo structure.
sparseResidencyAliased specifies whether the physical device can correctly access data aliased into multiple locations. If this feature is not enabled, the VK_BUFFER_CREATE_SPARSE_ALIASED_BIT and VK_IMAGE_CREATE_SPARSE_ALIASED_BIT enum values must not be used in flags members of the VkBufferCreateInfo and VkImageCreateInfo structures, respectively.
variableMultisampleRate specifies whether all pipelines that will be bound to a command buffer during a subpass with no attachments must have the same value for VkPipelineMultisampleStateCreateInfo::rasterizationSamples. If set to VK_TRUE, the implementation supports variable multisample rates in a subpass with no attachments. If set to VK_FALSE, then all pipelines bound in such a subpass must have the same multisample rate. This has no effect in situations where a subpass uses any attachments.
inheritedQueries specifies whether a secondary command buffer may be executed while a query is active.

Description

Members

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

maxImageDimension2D is the maximum dimension (width or height) supported for all images created with an imageType of VK_IMAGE_TYPE_2D and without VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in flags.
maxImageDimension3D is the maximum dimension (width, height, or depth) supported for all images created with an imageType of VK_IMAGE_TYPE_3D.
maxImageDimensionCube is the maximum dimension (width or height) supported for all images created with an imageType of VK_IMAGE_TYPE_2D and with VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in flags.
maxImageArrayLayers is the maximum number of layers (arrayLayers) for an image.
maxTexelBufferElements is the maximum number of addressable texels for a buffer view created on a buffer which was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set in the usage member of the VkBufferCreateInfo structure.
maxUniformBufferRange is the maximum value that can be specified in the range member of any VkDescriptorBufferInfo structures passed to a call to vkUpdateDescriptorSets for descriptors of type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC.
maxStorageBufferRange is the maximum value that can be specified in the range member of any VkDescriptorBufferInfo structures passed to a call to vkUpdateDescriptorSets for descriptors of type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC.
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 VkPipelineLayoutCreateInfo structure, (offset + size) must be less than or equal to this limit.
maxMemoryAllocationCount is the maximum number of device memory allocations, as created by vkAllocateMemory, which can simultaneously exist.
maxSamplerAllocationCount is the maximum number of sampler objects, as created by vkCreateSampler, which can simultaneously exist on a device.
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 VkDeviceMemory object without aliasing. See Buffer-Image Granularity for more details.
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 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 {html_spec_relative}#descriptorsets-sets.
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 VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. A descriptor is accessible to a shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See {html_spec_relative}#descriptorsets-sampler and {html_spec_relative}#descriptorsets-combinedimagesampler.
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 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. A descriptor is accessible to a shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See {html_spec_relative}#descriptorsets-uniformbuffer and {html_spec_relative}#descriptorsets-uniformbufferdynamic.
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 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See {html_spec_relative}#descriptorsets-storagebuffer and {html_spec_relative}#descriptorsets-storagebufferdynamic.
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 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, or VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See {html_spec_relative}#descriptorsets-combinedimagesampler, {html_spec_relative}#descriptorsets-sampledimage, and {html_spec_relative}#descriptorsets-uniformtexelbuffer.
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 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. See {html_spec_relative}#descriptorsets-storageimage, and {html_spec_relative}#descriptorsets-storagetexelbuffer.
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 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the VkDescriptorSetLayoutBinding structure has the bit for that shader stage set. These are only supported for the fragment stage. See {html_spec_relative}#descriptorsets-inputattachment.
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 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. For the fragment shader stage the framebuffer color attachments also count against this limit.
maxDescriptorSetSamplers is the maximum number of samplers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. See {html_spec_relative}#descriptorsets-sampler and {html_spec_relative}#descriptorsets-combinedimagesampler.
maxDescriptorSetUniformBuffers is the maximum number of uniform buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. See {html_spec_relative}#descriptorsets-uniformbuffer and {html_spec_relative}#descriptorsets-uniformbufferdynamic.
maxDescriptorSetUniformBuffersDynamic is the maximum number of dynamic uniform buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. See {html_spec_relative}#descriptorsets-uniformbufferdynamic.
maxDescriptorSetStorageBuffers is the maximum number of storage buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. See {html_spec_relative}#descriptorsets-storagebuffer and {html_spec_relative}#descriptorsets-storagebufferdynamic.
maxDescriptorSetStorageBuffersDynamic is the maximum number of dynamic storage buffers that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. See {html_spec_relative}#descriptorsets-storagebufferdynamic.
maxDescriptorSetSampledImages is the maximum number of sampled images that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, or VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. See {html_spec_relative}#descriptorsets-combinedimagesampler, {html_spec_relative}#descriptorsets-sampledimage, and {html_spec_relative}#descriptorsets-uniformtexelbuffer.
maxDescriptorSetStorageImages is the maximum number of storage images that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. See {html_spec_relative}#descriptorsets-storageimage, and {html_spec_relative}#descriptorsets-storagetexelbuffer.
maxDescriptorSetInputAttachments is the maximum number of input attachments that can be included in descriptor bindings in a pipeline layout across all pipeline shader stages and descriptor set numbers. Descriptors with a type of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT bit set count against this limit. See {html_spec_relative}#descriptorsets-inputattachment.
maxVertexInputAttributes is the maximum number of vertex input attributes that can be specified for a graphics pipeline. These are described in the array of VkVertexInputAttributeDescription structures that are provided at graphics pipeline creation time via the pVertexAttributeDescriptions member of the VkPipelineVertexInputStateCreateInfo structure. See {html_spec_relative}#fxvertex-attrib and {html_spec_relative}#fxvertex-input.
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 VkVertexInputBindingDescription structures that are provided at graphics pipeline creation time via the pVertexBindingDescriptions member of the VkPipelineVertexInputStateCreateInfo structure. The binding member of VkVertexInputBindingDescription must be less than this limit. See {html_spec_relative}#fxvertex-input.
maxVertexInputAttributeOffset is the maximum vertex input attribute offset that can be added to the vertex input binding stride. The offset member of the VkVertexInputAttributeDescription structure must be less than or equal to this limit. See {html_spec_relative}#fxvertex-input.
maxVertexInputBindingStride is the maximum vertex input binding stride that can be specified in a vertex input binding. The stride member of the VkVertexInputBindingDescription structure must be less than or equal to this limit. See {html_spec_relative}#fxvertex-input.
maxVertexOutputComponents is the maximum number of components of output variables which can be output by a vertex shader. See {html_spec_relative}#shaders-vertex.
maxTessellationGenerationLevel is the maximum tessellation generation level supported by the fixed-function tessellation primitive generator. See {html_spec_relative}#tessellation.
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 VkPipelineTessellationStateCreateInfo 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 {html_spec_relative}#tessellation.
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 is the maximum number of components of per-vertex output variables which can be output from the tessellation control shader stage.
maxTessellationControlPerPatchOutputComponents is the maximum number of components of per-patch output variables which can be output from the tessellation control shader stage.
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 is the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation evaluation shader stage.
maxTessellationEvaluationOutputComponents is the maximum number of components of per-vertex output variables which can be output from the tessellation evaluation shader stage.
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 {html_spec_relative}#geometry.
maxGeometryInputComponents is the maximum number of components of input variables which can be provided as inputs to the geometry shader stage.
maxGeometryOutputComponents is the maximum number of components of output variables which can be output from the geometry shader stage.
maxGeometryOutputVertices is the maximum number of vertices which can be emitted by any geometry shader.
maxGeometryTotalOutputComponents is the maximum total number of components of output, across all emitted vertices, which can be output from the geometry shader stage.
maxFragmentInputComponents is the maximum number of components of input variables which can be provided as inputs to the fragment shader stage.
maxFragmentOutputAttachments is the maximum number of output attachments which can be written to by the fragment shader stage.
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 {html_spec_relative}#framebuffer-dsb and dualSrcBlend.
maxFragmentCombinedOutputResources is the total number of storage buffers, storage images, and output buffers which can be used in the fragment shader stage.
maxComputeSharedMemorySize is the maximum total storage size, in bytes, of all variables declared with the WorkgroupLocal storage class in shader modules (or with the shared storage qualifier in GLSL) in the compute shader stage.
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 {html_spec_relative}#dispatch.
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 and by the object decorated by the WorkgroupSize decoration must be less than or equal to this limit.
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 specified by the LocalSize execution mode and by the object decorated by the WorkgroupSize decoration in shader modules must be less than or equal to the corresponding limit.
subPixelPrecisionBits is the number of bits of subpixel precision in framebuffer coordinates xf and yf. See {html_spec_relative}#primsrast.
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 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.
Note
For example, if this value is 2 bits then when linearly filtering between two levels, each level could: contribute: 0%, 33%, 66%, or 100% (this is just an example and the amount of contribution should be covered by different equations in the spec).
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 is the maximum draw count that is supported for indirect draw calls. See multiDrawIndirect.
maxSamplerLodBias is the maximum absolute sampler LOD bias. The sum of the mipLodBias member of the VkSamplerCreateInfo 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 {html_spec_relative}#samplers-mipLodBias.
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 VkSamplerCreateInfo structure and this limit. See {html_spec_relative}#samplers-maxAnisotropy.
maxViewports is the maximum number of active viewports. The viewportCount member of the VkPipelineViewportStateCreateInfo structure that is provided at pipeline creation must be less than or equal to this limit.
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[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 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 is the minimum required alignment, in bytes, of host visible memory allocations within the host address space. When mapping a memory allocation with vkMapMemory, subtracting offset bytes from the returned pointer will always produce an integer multiple of this limit. See {html_spec_relative}#memory-device-hostaccess.
minTexelBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the VkBufferViewCreateInfo structure for texel buffers. When a buffer view is created for a buffer which was created with VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set in the usage member of the VkBufferCreateInfo structure, the offset must be an integer multiple of this limit.
minUniformBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the VkDescriptorBufferInfo structure for uniform buffers. When a descriptor of type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_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 is the minimum required alignment, in bytes, for the offset member of the VkDescriptorBufferInfo structure for storage buffers. When a descriptor of type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_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 is the minimum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.
maxTexelOffset is the maximum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.
minTexelGatherOffset is the minimum offset value for the Offset or ConstOffsets image operands of any of the OpImage*Gather image instructions.
maxTexelGatherOffset is the maximum offset value for the Offset or ConstOffsets image operands of any of the OpImage*Gather image instructions.
minInterpolationOffset is the minimum negative offset value for the offset operand of the InterpolateAtOffset extended instruction.
maxInterpolationOffset is the maximum positive offset value for the offset operand of the InterpolateAtOffset extended instruction.
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 is the maximum width for a framebuffer. The width member of the VkFramebufferCreateInfo structure must be less than or equal to this limit.
maxFramebufferHeight is the maximum height for a framebuffer. The height member of the VkFramebufferCreateInfo structure must be less than or equal to this limit.
maxFramebufferLayers is the maximum layer count for a layered framebuffer. The layers member of the VkFramebufferCreateInfo structure must be less than or equal to this limit.
framebufferColorSampleCounts is a bitmask1 of VkSampleCountFlagBits 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 is a bitmask1 of VkSampleCountFlagBits indicating the supported depth sample counts for all framebuffer depth/stencil attachments, when the format includes a depth component.
framebufferStencilSampleCounts is a bitmask1 of VkSampleCountFlagBits indicating the supported stencil sample counts for all framebuffer depth/stencil attachments, when the format includes a stencil component.
framebufferNoAttachmentsSampleCounts is a bitmask1 of VkSampleCountFlagBits indicating the supported sample counts for a framebuffer with no attachments.
maxColorAttachments is the maximum number of color attachments that can be used by a subpass in a render pass. The colorAttachmentCount member of the VkSubpassDescription structure must be less than or equal to this limit.
sampledImageColorSampleCounts is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, usage containing VK_IMAGE_USAGE_SAMPLED_BIT, and a non-integer color format.
sampledImageIntegerSampleCounts is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, usage containing VK_IMAGE_USAGE_SAMPLED_BIT, and an integer color format.
sampledImageDepthSampleCounts is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, usage containing VK_IMAGE_USAGE_SAMPLED_BIT, and a depth format.
sampledImageStencilSampleCounts is a bitmask1 of VkSampleCountFlagBits indicating the sample supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, usage containing VK_IMAGE_USAGE_SAMPLED_BIT, and a stencil format.
storageImageSampleCounts is a bitmask1 of VkSampleCountFlagBits indicating the sample counts supported for all 2D images created with VK_IMAGE_TILING_OPTIMAL, and usage containing VK_IMAGE_USAGE_STORAGE_BIT.
maxSampleMaskWords is the maximum number of array elements of a variable decorated with the SampleMask built-in decoration.
timestampComputeAndGraphics specifies support for timestamps on all graphics and compute queues. If this limit is set to VK_TRUE, all queues that advertise the VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT in the VkQueueFamilyProperties::queueFlags support VkQueueFamilyProperties::timestampValidBits of at least 36. See Timestamp Queries.
timestampPeriod is the number of nanoseconds required for a timestamp query to be incremented by 1. See Timestamp Queries.
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 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 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 is the number of discrete priorities that can be assigned to a queue based on the value of each member of VkDeviceQueueCreateInfo::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 {html_spec_relative}#devsandqueues-priority.
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[2] is the range [minimum,maximum] of supported widths for lines. Values specified by the lineWidth member of the VkPipelineRasterizationStateCreateInfo or the lineWidth parameter to vkCmdSetLineWidth are clamped to this range.
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 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 specifies whether lines are rasterized according to the preferred method of rasterization. If set to VK_FALSE, lines may be rasterized under a relaxed set of rules. If set to VK_TRUE, lines are rasterized as per the strict definition. See Basic Line Segment Rasterization.
standardSampleLocations specifies whether rasterization uses the standard sample locations as documented in Multisampling. If set to VK_TRUE, the implementation uses the documented sample locations. If set to VK_FALSE, the implementation may use different sample locations.
optimalBufferCopyOffsetAlignment is the optimal buffer offset alignment in bytes for vkCmdCopyBufferToImage and vkCmdCopyImageToBuffer. The per texel alignment requirements are enforced, but applications should use the optimal alignment for optimal performance and power use.
optimalBufferCopyRowPitchAlignment is the optimal buffer row pitch alignment in bytes for vkCmdCopyBufferToImage and vkCmdCopyImageToBuffer. 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 is the size and alignment in bytes that bounds concurrent access to host-mapped device memory.
VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles is the maximum number of active discard rectangles. This limit can be queried by setting the pNext pointer from a VkPhysicalDeviceProperties2 object to an instance of VkPhysicalDeviceDiscardRectanglePropertiesEXT and using vkGetPhysicalDeviceProperties2 to fill out the members.
VkPhysicalDevicePointClippingProperties::pointClippingBehavior defines the clipping behavior of points. This limit can be queried by setting the pNext pointer from a VkPhysicalDeviceProperties2 object to an instance of VkPhysicalDevicePointClippingProperties and using vkGetPhysicalDeviceProperties2 to fill out the members.
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor is the maximum value of the number of instances that will repeat the value of vertex attribute data when instanced rendering is enabled. This limit can be queried by setting the pNext pointer from a VkPhysicalDeviceProperties2 object to an instance of VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT and using vkGetPhysicalDeviceProperties2 to fill out the members.

Description

1: For all bitmasks of VkSampleCountFlagBits, the sample count limits defined above represent the minimum supported sample counts for each image type. Individual images may support additional sample counts, which are queried using vkGetPhysicalDeviceImageFormatProperties as described in Supported Sample Counts.

Description

VkQueueFlags is a bitmask type for setting a mask of zero or more VkQueueFlagBits.

Description

VkMemoryPropertyFlags is a bitmask type for setting a mask of zero or more VkMemoryPropertyFlagBits.

Description

VkMemoryHeapFlags is a bitmask type for setting a mask of zero or more VkMemoryHeapFlagBits.

Description

VkImageUsageFlags is a bitmask type for setting a mask of zero or more VkImageUsageFlagBits.

Description

VkImageCreateFlags is a bitmask type for setting a mask of zero or more VkImageCreateFlagBits.

Description

VkFormatFeatureFlags is a bitmask type for setting a mask of zero or more VkFormatFeatureFlagBits.

Description

VkSampleCountFlags is a bitmask type for setting a mask of zero or more VkSampleCountFlagBits.

Eq VkImageTiling Source #
Methods (==) :: VkImageTiling -> VkImageTiling -> Bool # (/=) :: VkImageTiling -> VkImageTiling -> Bool #
Ord VkImageTiling Source #
Methods compare :: VkImageTiling -> VkImageTiling -> Ordering # (<) :: VkImageTiling -> VkImageTiling -> Bool # (<=) :: VkImageTiling -> VkImageTiling -> Bool # (>) :: VkImageTiling -> VkImageTiling -> Bool # (>=) :: VkImageTiling -> VkImageTiling -> Bool # max :: VkImageTiling -> VkImageTiling -> VkImageTiling # min :: VkImageTiling -> VkImageTiling -> VkImageTiling #
Read VkImageTiling Source #
Methods readsPrec :: Int -> ReadS VkImageTiling # readList :: ReadS [VkImageTiling] # readPrec :: ReadPrec VkImageTiling # readListPrec :: ReadPrec [VkImageTiling] #
Show VkImageTiling Source #
Methods showsPrec :: Int -> VkImageTiling -> ShowS # show :: VkImageTiling -> String # showList :: [VkImageTiling] -> ShowS #
Storable VkImageTiling Source #
Methods sizeOf :: VkImageTiling -> Int # alignment :: VkImageTiling -> Int # peekElemOff :: Ptr VkImageTiling -> Int -> IO VkImageTiling # pokeElemOff :: Ptr VkImageTiling -> Int -> VkImageTiling -> IO () # peekByteOff :: Ptr b -> Int -> IO VkImageTiling # pokeByteOff :: Ptr b -> Int -> VkImageTiling -> IO () # peek :: Ptr VkImageTiling -> IO VkImageTiling # poke :: Ptr VkImageTiling -> VkImageTiling -> IO () #

Eq VkImageType Source #
Methods (==) :: VkImageType -> VkImageType -> Bool # (/=) :: VkImageType -> VkImageType -> Bool #
Ord VkImageType Source #
Methods compare :: VkImageType -> VkImageType -> Ordering # (<) :: VkImageType -> VkImageType -> Bool # (<=) :: VkImageType -> VkImageType -> Bool # (>) :: VkImageType -> VkImageType -> Bool # (>=) :: VkImageType -> VkImageType -> Bool # max :: VkImageType -> VkImageType -> VkImageType # min :: VkImageType -> VkImageType -> VkImageType #
Read VkImageType Source #
Methods readsPrec :: Int -> ReadS VkImageType # readList :: ReadS [VkImageType] # readPrec :: ReadPrec VkImageType # readListPrec :: ReadPrec [VkImageType] #
Show VkImageType Source #
Methods showsPrec :: Int -> VkImageType -> ShowS # show :: VkImageType -> String # showList :: [VkImageType] -> ShowS #
Storable VkImageType Source #
Methods sizeOf :: VkImageType -> Int # alignment :: VkImageType -> Int # peekElemOff :: Ptr VkImageType -> Int -> IO VkImageType # pokeElemOff :: Ptr VkImageType -> Int -> VkImageType -> IO () # peekByteOff :: Ptr b -> Int -> IO VkImageType # pokeByteOff :: Ptr b -> Int -> VkImageType -> IO () # peek :: Ptr VkImageType -> IO VkImageType # poke :: Ptr VkImageType -> VkImageType -> IO () #

Eq VkPhysicalDeviceType Source #
Methods (==) :: VkPhysicalDeviceType -> VkPhysicalDeviceType -> Bool # (/=) :: VkPhysicalDeviceType -> VkPhysicalDeviceType -> Bool #
Ord VkPhysicalDeviceType Source #
Methods compare :: VkPhysicalDeviceType -> VkPhysicalDeviceType -> Ordering # (<) :: VkPhysicalDeviceType -> VkPhysicalDeviceType -> Bool # (<=) :: VkPhysicalDeviceType -> VkPhysicalDeviceType -> Bool # (>) :: VkPhysicalDeviceType -> VkPhysicalDeviceType -> Bool # (>=) :: VkPhysicalDeviceType -> VkPhysicalDeviceType -> Bool # max :: VkPhysicalDeviceType -> VkPhysicalDeviceType -> VkPhysicalDeviceType # min :: VkPhysicalDeviceType -> VkPhysicalDeviceType -> VkPhysicalDeviceType #
Read VkPhysicalDeviceType Source #
Methods readsPrec :: Int -> ReadS VkPhysicalDeviceType # readList :: ReadS [VkPhysicalDeviceType] # readPrec :: ReadPrec VkPhysicalDeviceType # readListPrec :: ReadPrec [VkPhysicalDeviceType] #
Show VkPhysicalDeviceType Source #
Methods showsPrec :: Int -> VkPhysicalDeviceType -> ShowS # show :: VkPhysicalDeviceType -> String # showList :: [VkPhysicalDeviceType] -> ShowS #
Storable VkPhysicalDeviceType Source #
Methods sizeOf :: VkPhysicalDeviceType -> Int # alignment :: VkPhysicalDeviceType -> Int # peekElemOff :: Ptr VkPhysicalDeviceType -> Int -> IO VkPhysicalDeviceType # pokeElemOff :: Ptr VkPhysicalDeviceType -> Int -> VkPhysicalDeviceType -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPhysicalDeviceType # pokeByteOff :: Ptr b -> Int -> VkPhysicalDeviceType -> IO () # peek :: Ptr VkPhysicalDeviceType -> IO VkPhysicalDeviceType # poke :: Ptr VkPhysicalDeviceType -> VkPhysicalDeviceType -> IO () #

Eq VkSystemAllocationScope Source #
Methods (==) :: VkSystemAllocationScope -> VkSystemAllocationScope -> Bool # (/=) :: VkSystemAllocationScope -> VkSystemAllocationScope -> Bool #
Ord VkSystemAllocationScope Source #
Methods compare :: VkSystemAllocationScope -> VkSystemAllocationScope -> Ordering # (<) :: VkSystemAllocationScope -> VkSystemAllocationScope -> Bool # (<=) :: VkSystemAllocationScope -> VkSystemAllocationScope -> Bool # (>) :: VkSystemAllocationScope -> VkSystemAllocationScope -> Bool # (>=) :: VkSystemAllocationScope -> VkSystemAllocationScope -> Bool # max :: VkSystemAllocationScope -> VkSystemAllocationScope -> VkSystemAllocationScope # min :: VkSystemAllocationScope -> VkSystemAllocationScope -> VkSystemAllocationScope #
Read VkSystemAllocationScope Source #
Methods readsPrec :: Int -> ReadS VkSystemAllocationScope # readList :: ReadS [VkSystemAllocationScope] # readPrec :: ReadPrec VkSystemAllocationScope # readListPrec :: ReadPrec [VkSystemAllocationScope] #
Show VkSystemAllocationScope Source #
Methods showsPrec :: Int -> VkSystemAllocationScope -> ShowS # show :: VkSystemAllocationScope -> String # showList :: [VkSystemAllocationScope] -> ShowS #
Storable VkSystemAllocationScope Source #
Methods sizeOf :: VkSystemAllocationScope -> Int # alignment :: VkSystemAllocationScope -> Int # peekElemOff :: Ptr VkSystemAllocationScope -> Int -> IO VkSystemAllocationScope # pokeElemOff :: Ptr VkSystemAllocationScope -> Int -> VkSystemAllocationScope -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSystemAllocationScope # pokeByteOff :: Ptr b -> Int -> VkSystemAllocationScope -> IO () # peek :: Ptr VkSystemAllocationScope -> IO VkSystemAllocationScope # poke :: Ptr VkSystemAllocationScope -> VkSystemAllocationScope -> IO () #

Eq VkInternalAllocationType Source #
Methods (==) :: VkInternalAllocationType -> VkInternalAllocationType -> Bool # (/=) :: VkInternalAllocationType -> VkInternalAllocationType -> Bool #
Ord VkInternalAllocationType Source #
Methods compare :: VkInternalAllocationType -> VkInternalAllocationType -> Ordering # (<) :: VkInternalAllocationType -> VkInternalAllocationType -> Bool # (<=) :: VkInternalAllocationType -> VkInternalAllocationType -> Bool # (>) :: VkInternalAllocationType -> VkInternalAllocationType -> Bool # (>=) :: VkInternalAllocationType -> VkInternalAllocationType -> Bool # max :: VkInternalAllocationType -> VkInternalAllocationType -> VkInternalAllocationType # min :: VkInternalAllocationType -> VkInternalAllocationType -> VkInternalAllocationType #
Read VkInternalAllocationType Source #
Methods readsPrec :: Int -> ReadS VkInternalAllocationType # readList :: ReadS [VkInternalAllocationType] # readPrec :: ReadPrec VkInternalAllocationType # readListPrec :: ReadPrec [VkInternalAllocationType] #
Show VkInternalAllocationType Source #
Methods showsPrec :: Int -> VkInternalAllocationType -> ShowS # show :: VkInternalAllocationType -> String # showList :: [VkInternalAllocationType] -> ShowS #
Storable VkInternalAllocationType Source #
Methods sizeOf :: VkInternalAllocationType -> Int # alignment :: VkInternalAllocationType -> Int # peekElemOff :: Ptr VkInternalAllocationType -> Int -> IO VkInternalAllocationType # pokeElemOff :: Ptr VkInternalAllocationType -> Int -> VkInternalAllocationType -> IO () # peekByteOff :: Ptr b -> Int -> IO VkInternalAllocationType # pokeByteOff :: Ptr b -> Int -> VkInternalAllocationType -> IO () # peek :: Ptr VkInternalAllocationType -> IO VkInternalAllocationType # poke :: Ptr VkInternalAllocationType -> VkInternalAllocationType -> IO () #

Eq VkInstanceCreateFlags Source #
Methods (==) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # (/=) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool #
Ord VkInstanceCreateFlags Source #
Methods compare :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Ordering # (<) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # (<=) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # (>) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # (>=) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # max :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # min :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags #
Read VkInstanceCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkInstanceCreateFlags # readList :: ReadS [VkInstanceCreateFlags] # readPrec :: ReadPrec VkInstanceCreateFlags # readListPrec :: ReadPrec [VkInstanceCreateFlags] #
Show VkInstanceCreateFlags Source #
Methods showsPrec :: Int -> VkInstanceCreateFlags -> ShowS # show :: VkInstanceCreateFlags -> String # showList :: [VkInstanceCreateFlags] -> ShowS #
Storable VkInstanceCreateFlags Source #
Methods sizeOf :: VkInstanceCreateFlags -> Int # alignment :: VkInstanceCreateFlags -> Int # peekElemOff :: Ptr VkInstanceCreateFlags -> Int -> IO VkInstanceCreateFlags # pokeElemOff :: Ptr VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkInstanceCreateFlags # pokeByteOff :: Ptr b -> Int -> VkInstanceCreateFlags -> IO () # peek :: Ptr VkInstanceCreateFlags -> IO VkInstanceCreateFlags # poke :: Ptr VkInstanceCreateFlags -> VkInstanceCreateFlags -> IO () #
Bits VkInstanceCreateFlags Source #
Methods (.&.) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # (.\|.) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # xor :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # complement :: VkInstanceCreateFlags -> VkInstanceCreateFlags # shift :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # rotate :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # zeroBits :: VkInstanceCreateFlags # bit :: Int -> VkInstanceCreateFlags # setBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # clearBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # complementBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # testBit :: VkInstanceCreateFlags -> Int -> Bool # bitSizeMaybe :: VkInstanceCreateFlags -> Maybe Int # bitSize :: VkInstanceCreateFlags -> Int # isSigned :: VkInstanceCreateFlags -> Bool # shiftL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # unsafeShiftL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # shiftR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # unsafeShiftR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # rotateL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # rotateR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # popCount :: VkInstanceCreateFlags -> Int #
FiniteBits VkInstanceCreateFlags Source #
Methods finiteBitSize :: VkInstanceCreateFlags -> Int # countLeadingZeros :: VkInstanceCreateFlags -> Int # countTrailingZeros :: VkInstanceCreateFlags -> Int #

Eq VkQueueFlagBits Source #
Methods (==) :: VkQueueFlagBits -> VkQueueFlagBits -> Bool # (/=) :: VkQueueFlagBits -> VkQueueFlagBits -> Bool #
Ord VkQueueFlagBits Source #
Methods compare :: VkQueueFlagBits -> VkQueueFlagBits -> Ordering # (<) :: VkQueueFlagBits -> VkQueueFlagBits -> Bool # (<=) :: VkQueueFlagBits -> VkQueueFlagBits -> Bool # (>) :: VkQueueFlagBits -> VkQueueFlagBits -> Bool # (>=) :: VkQueueFlagBits -> VkQueueFlagBits -> Bool # max :: VkQueueFlagBits -> VkQueueFlagBits -> VkQueueFlagBits # min :: VkQueueFlagBits -> VkQueueFlagBits -> VkQueueFlagBits #
Read VkQueueFlagBits Source #
Methods readsPrec :: Int -> ReadS VkQueueFlagBits # readList :: ReadS [VkQueueFlagBits] # readPrec :: ReadPrec VkQueueFlagBits # readListPrec :: ReadPrec [VkQueueFlagBits] #
Show VkQueueFlagBits Source #
Methods showsPrec :: Int -> VkQueueFlagBits -> ShowS # show :: VkQueueFlagBits -> String # showList :: [VkQueueFlagBits] -> ShowS #
Storable VkQueueFlagBits Source #
Methods sizeOf :: VkQueueFlagBits -> Int # alignment :: VkQueueFlagBits -> Int # peekElemOff :: Ptr VkQueueFlagBits -> Int -> IO VkQueueFlagBits # pokeElemOff :: Ptr VkQueueFlagBits -> Int -> VkQueueFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkQueueFlagBits # pokeByteOff :: Ptr b -> Int -> VkQueueFlagBits -> IO () # peek :: Ptr VkQueueFlagBits -> IO VkQueueFlagBits # poke :: Ptr VkQueueFlagBits -> VkQueueFlagBits -> IO () #
Bits VkQueueFlagBits Source #
Methods (.&.) :: VkQueueFlagBits -> VkQueueFlagBits -> VkQueueFlagBits # (.\|.) :: VkQueueFlagBits -> VkQueueFlagBits -> VkQueueFlagBits # xor :: VkQueueFlagBits -> VkQueueFlagBits -> VkQueueFlagBits # complement :: VkQueueFlagBits -> VkQueueFlagBits # shift :: VkQueueFlagBits -> Int -> VkQueueFlagBits # rotate :: VkQueueFlagBits -> Int -> VkQueueFlagBits # zeroBits :: VkQueueFlagBits # bit :: Int -> VkQueueFlagBits # setBit :: VkQueueFlagBits -> Int -> VkQueueFlagBits # clearBit :: VkQueueFlagBits -> Int -> VkQueueFlagBits # complementBit :: VkQueueFlagBits -> Int -> VkQueueFlagBits # testBit :: VkQueueFlagBits -> Int -> Bool # bitSizeMaybe :: VkQueueFlagBits -> Maybe Int # bitSize :: VkQueueFlagBits -> Int # isSigned :: VkQueueFlagBits -> Bool # shiftL :: VkQueueFlagBits -> Int -> VkQueueFlagBits # unsafeShiftL :: VkQueueFlagBits -> Int -> VkQueueFlagBits # shiftR :: VkQueueFlagBits -> Int -> VkQueueFlagBits # unsafeShiftR :: VkQueueFlagBits -> Int -> VkQueueFlagBits # rotateL :: VkQueueFlagBits -> Int -> VkQueueFlagBits # rotateR :: VkQueueFlagBits -> Int -> VkQueueFlagBits # popCount :: VkQueueFlagBits -> Int #
FiniteBits VkQueueFlagBits Source #
Methods finiteBitSize :: VkQueueFlagBits -> Int # countLeadingZeros :: VkQueueFlagBits -> Int # countTrailingZeros :: VkQueueFlagBits -> Int #

Eq VkMemoryPropertyFlagBits Source #
Methods (==) :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> Bool # (/=) :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> Bool #
Ord VkMemoryPropertyFlagBits Source #
Methods compare :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> Ordering # (<) :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> Bool # (<=) :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> Bool # (>) :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> Bool # (>=) :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> Bool # max :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits # min :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits #
Read VkMemoryPropertyFlagBits Source #
Methods readsPrec :: Int -> ReadS VkMemoryPropertyFlagBits # readList :: ReadS [VkMemoryPropertyFlagBits] # readPrec :: ReadPrec VkMemoryPropertyFlagBits # readListPrec :: ReadPrec [VkMemoryPropertyFlagBits] #
Show VkMemoryPropertyFlagBits Source #
Methods showsPrec :: Int -> VkMemoryPropertyFlagBits -> ShowS # show :: VkMemoryPropertyFlagBits -> String # showList :: [VkMemoryPropertyFlagBits] -> ShowS #
Storable VkMemoryPropertyFlagBits Source #
Methods sizeOf :: VkMemoryPropertyFlagBits -> Int # alignment :: VkMemoryPropertyFlagBits -> Int # peekElemOff :: Ptr VkMemoryPropertyFlagBits -> Int -> IO VkMemoryPropertyFlagBits # pokeElemOff :: Ptr VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkMemoryPropertyFlagBits # pokeByteOff :: Ptr b -> Int -> VkMemoryPropertyFlagBits -> IO () # peek :: Ptr VkMemoryPropertyFlagBits -> IO VkMemoryPropertyFlagBits # poke :: Ptr VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> IO () #
Bits VkMemoryPropertyFlagBits Source #
Methods (.&.) :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits # (.\|.) :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits # xor :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits # complement :: VkMemoryPropertyFlagBits -> VkMemoryPropertyFlagBits # shift :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # rotate :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # zeroBits :: VkMemoryPropertyFlagBits # bit :: Int -> VkMemoryPropertyFlagBits # setBit :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # clearBit :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # complementBit :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # testBit :: VkMemoryPropertyFlagBits -> Int -> Bool # bitSizeMaybe :: VkMemoryPropertyFlagBits -> Maybe Int # bitSize :: VkMemoryPropertyFlagBits -> Int # isSigned :: VkMemoryPropertyFlagBits -> Bool # shiftL :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # unsafeShiftL :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # shiftR :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # unsafeShiftR :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # rotateL :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # rotateR :: VkMemoryPropertyFlagBits -> Int -> VkMemoryPropertyFlagBits # popCount :: VkMemoryPropertyFlagBits -> Int #
FiniteBits VkMemoryPropertyFlagBits Source #
Methods finiteBitSize :: VkMemoryPropertyFlagBits -> Int # countLeadingZeros :: VkMemoryPropertyFlagBits -> Int # countTrailingZeros :: VkMemoryPropertyFlagBits -> Int #

Eq VkMemoryHeapFlagBits Source #
Methods (==) :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> Bool # (/=) :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> Bool #
Ord VkMemoryHeapFlagBits Source #
Methods compare :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> Ordering # (<) :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> Bool # (<=) :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> Bool # (>) :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> Bool # (>=) :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> Bool # max :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits # min :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits #
Read VkMemoryHeapFlagBits Source #
Methods readsPrec :: Int -> ReadS VkMemoryHeapFlagBits # readList :: ReadS [VkMemoryHeapFlagBits] # readPrec :: ReadPrec VkMemoryHeapFlagBits # readListPrec :: ReadPrec [VkMemoryHeapFlagBits] #
Show VkMemoryHeapFlagBits Source #
Methods showsPrec :: Int -> VkMemoryHeapFlagBits -> ShowS # show :: VkMemoryHeapFlagBits -> String # showList :: [VkMemoryHeapFlagBits] -> ShowS #
Storable VkMemoryHeapFlagBits Source #
Methods sizeOf :: VkMemoryHeapFlagBits -> Int # alignment :: VkMemoryHeapFlagBits -> Int # peekElemOff :: Ptr VkMemoryHeapFlagBits -> Int -> IO VkMemoryHeapFlagBits # pokeElemOff :: Ptr VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkMemoryHeapFlagBits # pokeByteOff :: Ptr b -> Int -> VkMemoryHeapFlagBits -> IO () # peek :: Ptr VkMemoryHeapFlagBits -> IO VkMemoryHeapFlagBits # poke :: Ptr VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> IO () #
Bits VkMemoryHeapFlagBits Source #
Methods (.&.) :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits # (.\|.) :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits # xor :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits # complement :: VkMemoryHeapFlagBits -> VkMemoryHeapFlagBits # shift :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # rotate :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # zeroBits :: VkMemoryHeapFlagBits # bit :: Int -> VkMemoryHeapFlagBits # setBit :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # clearBit :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # complementBit :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # testBit :: VkMemoryHeapFlagBits -> Int -> Bool # bitSizeMaybe :: VkMemoryHeapFlagBits -> Maybe Int # bitSize :: VkMemoryHeapFlagBits -> Int # isSigned :: VkMemoryHeapFlagBits -> Bool # shiftL :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # unsafeShiftL :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # shiftR :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # unsafeShiftR :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # rotateL :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # rotateR :: VkMemoryHeapFlagBits -> Int -> VkMemoryHeapFlagBits # popCount :: VkMemoryHeapFlagBits -> Int #
FiniteBits VkMemoryHeapFlagBits Source #
Methods finiteBitSize :: VkMemoryHeapFlagBits -> Int # countLeadingZeros :: VkMemoryHeapFlagBits -> Int # countTrailingZeros :: VkMemoryHeapFlagBits -> Int #

Eq VkImageUsageFlagBits Source #
Methods (==) :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> Bool # (/=) :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> Bool #
Ord VkImageUsageFlagBits Source #
Methods compare :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> Ordering # (<) :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> Bool # (<=) :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> Bool # (>) :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> Bool # (>=) :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> Bool # max :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> VkImageUsageFlagBits # min :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> VkImageUsageFlagBits #
Read VkImageUsageFlagBits Source #
Methods readsPrec :: Int -> ReadS VkImageUsageFlagBits # readList :: ReadS [VkImageUsageFlagBits] # readPrec :: ReadPrec VkImageUsageFlagBits # readListPrec :: ReadPrec [VkImageUsageFlagBits] #
Show VkImageUsageFlagBits Source #
Methods showsPrec :: Int -> VkImageUsageFlagBits -> ShowS # show :: VkImageUsageFlagBits -> String # showList :: [VkImageUsageFlagBits] -> ShowS #
Storable VkImageUsageFlagBits Source #
Methods sizeOf :: VkImageUsageFlagBits -> Int # alignment :: VkImageUsageFlagBits -> Int # peekElemOff :: Ptr VkImageUsageFlagBits -> Int -> IO VkImageUsageFlagBits # pokeElemOff :: Ptr VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkImageUsageFlagBits # pokeByteOff :: Ptr b -> Int -> VkImageUsageFlagBits -> IO () # peek :: Ptr VkImageUsageFlagBits -> IO VkImageUsageFlagBits # poke :: Ptr VkImageUsageFlagBits -> VkImageUsageFlagBits -> IO () #
Bits VkImageUsageFlagBits Source #
Methods (.&.) :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> VkImageUsageFlagBits # (.\|.) :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> VkImageUsageFlagBits # xor :: VkImageUsageFlagBits -> VkImageUsageFlagBits -> VkImageUsageFlagBits # complement :: VkImageUsageFlagBits -> VkImageUsageFlagBits # shift :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # rotate :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # zeroBits :: VkImageUsageFlagBits # bit :: Int -> VkImageUsageFlagBits # setBit :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # clearBit :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # complementBit :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # testBit :: VkImageUsageFlagBits -> Int -> Bool # bitSizeMaybe :: VkImageUsageFlagBits -> Maybe Int # bitSize :: VkImageUsageFlagBits -> Int # isSigned :: VkImageUsageFlagBits -> Bool # shiftL :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # unsafeShiftL :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # shiftR :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # unsafeShiftR :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # rotateL :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # rotateR :: VkImageUsageFlagBits -> Int -> VkImageUsageFlagBits # popCount :: VkImageUsageFlagBits -> Int #
FiniteBits VkImageUsageFlagBits Source #
Methods finiteBitSize :: VkImageUsageFlagBits -> Int # countLeadingZeros :: VkImageUsageFlagBits -> Int # countTrailingZeros :: VkImageUsageFlagBits -> Int #

Eq VkImageCreateFlagBits Source #
Methods (==) :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> Bool # (/=) :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> Bool #
Ord VkImageCreateFlagBits Source #
Methods compare :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> Ordering # (<) :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> Bool # (<=) :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> Bool # (>) :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> Bool # (>=) :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> Bool # max :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> VkImageCreateFlagBits # min :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> VkImageCreateFlagBits #
Read VkImageCreateFlagBits Source #
Methods readsPrec :: Int -> ReadS VkImageCreateFlagBits # readList :: ReadS [VkImageCreateFlagBits] # readPrec :: ReadPrec VkImageCreateFlagBits # readListPrec :: ReadPrec [VkImageCreateFlagBits] #
Show VkImageCreateFlagBits Source #
Methods showsPrec :: Int -> VkImageCreateFlagBits -> ShowS # show :: VkImageCreateFlagBits -> String # showList :: [VkImageCreateFlagBits] -> ShowS #
Storable VkImageCreateFlagBits Source #
Methods sizeOf :: VkImageCreateFlagBits -> Int # alignment :: VkImageCreateFlagBits -> Int # peekElemOff :: Ptr VkImageCreateFlagBits -> Int -> IO VkImageCreateFlagBits # pokeElemOff :: Ptr VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkImageCreateFlagBits # pokeByteOff :: Ptr b -> Int -> VkImageCreateFlagBits -> IO () # peek :: Ptr VkImageCreateFlagBits -> IO VkImageCreateFlagBits # poke :: Ptr VkImageCreateFlagBits -> VkImageCreateFlagBits -> IO () #
Bits VkImageCreateFlagBits Source #
Methods (.&.) :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> VkImageCreateFlagBits # (.\|.) :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> VkImageCreateFlagBits # xor :: VkImageCreateFlagBits -> VkImageCreateFlagBits -> VkImageCreateFlagBits # complement :: VkImageCreateFlagBits -> VkImageCreateFlagBits # shift :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # rotate :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # zeroBits :: VkImageCreateFlagBits # bit :: Int -> VkImageCreateFlagBits # setBit :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # clearBit :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # complementBit :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # testBit :: VkImageCreateFlagBits -> Int -> Bool # bitSizeMaybe :: VkImageCreateFlagBits -> Maybe Int # bitSize :: VkImageCreateFlagBits -> Int # isSigned :: VkImageCreateFlagBits -> Bool # shiftL :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # unsafeShiftL :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # shiftR :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # unsafeShiftR :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # rotateL :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # rotateR :: VkImageCreateFlagBits -> Int -> VkImageCreateFlagBits # popCount :: VkImageCreateFlagBits -> Int #
FiniteBits VkImageCreateFlagBits Source #
Methods finiteBitSize :: VkImageCreateFlagBits -> Int # countLeadingZeros :: VkImageCreateFlagBits -> Int # countTrailingZeros :: VkImageCreateFlagBits -> Int #

Eq VkFormatFeatureFlagBits Source #
Methods (==) :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> Bool # (/=) :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> Bool #
Ord VkFormatFeatureFlagBits Source #
Methods compare :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> Ordering # (<) :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> Bool # (<=) :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> Bool # (>) :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> Bool # (>=) :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> Bool # max :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits # min :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits #
Read VkFormatFeatureFlagBits Source #
Methods readsPrec :: Int -> ReadS VkFormatFeatureFlagBits # readList :: ReadS [VkFormatFeatureFlagBits] # readPrec :: ReadPrec VkFormatFeatureFlagBits # readListPrec :: ReadPrec [VkFormatFeatureFlagBits] #
Show VkFormatFeatureFlagBits Source #
Methods showsPrec :: Int -> VkFormatFeatureFlagBits -> ShowS # show :: VkFormatFeatureFlagBits -> String # showList :: [VkFormatFeatureFlagBits] -> ShowS #
Storable VkFormatFeatureFlagBits Source #
Methods sizeOf :: VkFormatFeatureFlagBits -> Int # alignment :: VkFormatFeatureFlagBits -> Int # peekElemOff :: Ptr VkFormatFeatureFlagBits -> Int -> IO VkFormatFeatureFlagBits # pokeElemOff :: Ptr VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkFormatFeatureFlagBits # pokeByteOff :: Ptr b -> Int -> VkFormatFeatureFlagBits -> IO () # peek :: Ptr VkFormatFeatureFlagBits -> IO VkFormatFeatureFlagBits # poke :: Ptr VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> IO () #
Bits VkFormatFeatureFlagBits Source #
Methods (.&.) :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits # (.\|.) :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits # xor :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits # complement :: VkFormatFeatureFlagBits -> VkFormatFeatureFlagBits # shift :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # rotate :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # zeroBits :: VkFormatFeatureFlagBits # bit :: Int -> VkFormatFeatureFlagBits # setBit :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # clearBit :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # complementBit :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # testBit :: VkFormatFeatureFlagBits -> Int -> Bool # bitSizeMaybe :: VkFormatFeatureFlagBits -> Maybe Int # bitSize :: VkFormatFeatureFlagBits -> Int # isSigned :: VkFormatFeatureFlagBits -> Bool # shiftL :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # unsafeShiftL :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # shiftR :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # unsafeShiftR :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # rotateL :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # rotateR :: VkFormatFeatureFlagBits -> Int -> VkFormatFeatureFlagBits # popCount :: VkFormatFeatureFlagBits -> Int #
FiniteBits VkFormatFeatureFlagBits Source #
Methods finiteBitSize :: VkFormatFeatureFlagBits -> Int # countLeadingZeros :: VkFormatFeatureFlagBits -> Int # countTrailingZeros :: VkFormatFeatureFlagBits -> Int #

Eq VkSampleCountFlagBits Source #
Methods (==) :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> Bool # (/=) :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> Bool #
Ord VkSampleCountFlagBits Source #
Methods compare :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> Ordering # (<) :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> Bool # (<=) :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> Bool # (>) :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> Bool # (>=) :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> Bool # max :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> VkSampleCountFlagBits # min :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> VkSampleCountFlagBits #
Read VkSampleCountFlagBits Source #
Methods readsPrec :: Int -> ReadS VkSampleCountFlagBits # readList :: ReadS [VkSampleCountFlagBits] # readPrec :: ReadPrec VkSampleCountFlagBits # readListPrec :: ReadPrec [VkSampleCountFlagBits] #
Show VkSampleCountFlagBits Source #
Methods showsPrec :: Int -> VkSampleCountFlagBits -> ShowS # show :: VkSampleCountFlagBits -> String # showList :: [VkSampleCountFlagBits] -> ShowS #
Storable VkSampleCountFlagBits Source #
Methods sizeOf :: VkSampleCountFlagBits -> Int # alignment :: VkSampleCountFlagBits -> Int # peekElemOff :: Ptr VkSampleCountFlagBits -> Int -> IO VkSampleCountFlagBits # pokeElemOff :: Ptr VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSampleCountFlagBits # pokeByteOff :: Ptr b -> Int -> VkSampleCountFlagBits -> IO () # peek :: Ptr VkSampleCountFlagBits -> IO VkSampleCountFlagBits # poke :: Ptr VkSampleCountFlagBits -> VkSampleCountFlagBits -> IO () #
Bits VkSampleCountFlagBits Source #
Methods (.&.) :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> VkSampleCountFlagBits # (.\|.) :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> VkSampleCountFlagBits # xor :: VkSampleCountFlagBits -> VkSampleCountFlagBits -> VkSampleCountFlagBits # complement :: VkSampleCountFlagBits -> VkSampleCountFlagBits # shift :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # rotate :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # zeroBits :: VkSampleCountFlagBits # bit :: Int -> VkSampleCountFlagBits # setBit :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # clearBit :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # complementBit :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # testBit :: VkSampleCountFlagBits -> Int -> Bool # bitSizeMaybe :: VkSampleCountFlagBits -> Maybe Int # bitSize :: VkSampleCountFlagBits -> Int # isSigned :: VkSampleCountFlagBits -> Bool # shiftL :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # unsafeShiftL :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # shiftR :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # unsafeShiftR :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # rotateL :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # rotateR :: VkSampleCountFlagBits -> Int -> VkSampleCountFlagBits # popCount :: VkSampleCountFlagBits -> Int #
FiniteBits VkSampleCountFlagBits Source #
Methods finiteBitSize :: VkSampleCountFlagBits -> Int # countLeadingZeros :: VkSampleCountFlagBits -> Int # countTrailingZeros :: VkSampleCountFlagBits -> Int #

VkExtent3D
Fields vkWidth :: Word32 `width` is the width of the extent. vkHeight :: Word32 `height` is the height of the extent. vkDepth :: Word32 `depth` is the depth of the extent.

Eq VkExtent3D Source #
Methods (==) :: VkExtent3D -> VkExtent3D -> Bool # (/=) :: VkExtent3D -> VkExtent3D -> Bool #
Show VkExtent3D Source #
Methods showsPrec :: Int -> VkExtent3D -> ShowS # show :: VkExtent3D -> String # showList :: [VkExtent3D] -> ShowS #
Storable VkExtent3D Source #
Methods sizeOf :: VkExtent3D -> Int # alignment :: VkExtent3D -> Int # peekElemOff :: Ptr VkExtent3D -> Int -> IO VkExtent3D # pokeElemOff :: Ptr VkExtent3D -> Int -> VkExtent3D -> IO () # peekByteOff :: Ptr b -> Int -> IO VkExtent3D # pokeByteOff :: Ptr b -> Int -> VkExtent3D -> IO () # peek :: Ptr VkExtent3D -> IO VkExtent3D # poke :: Ptr VkExtent3D -> VkExtent3D -> IO () #

Eq VkPhysicalDeviceProperties Source #
Methods (==) :: VkPhysicalDeviceProperties -> VkPhysicalDeviceProperties -> Bool # (/=) :: VkPhysicalDeviceProperties -> VkPhysicalDeviceProperties -> Bool #
Show VkPhysicalDeviceProperties Source #
Methods showsPrec :: Int -> VkPhysicalDeviceProperties -> ShowS # show :: VkPhysicalDeviceProperties -> String # showList :: [VkPhysicalDeviceProperties] -> ShowS #
Storable VkPhysicalDeviceProperties Source #
Methods sizeOf :: VkPhysicalDeviceProperties -> Int # alignment :: VkPhysicalDeviceProperties -> Int # peekElemOff :: Ptr VkPhysicalDeviceProperties -> Int -> IO VkPhysicalDeviceProperties # pokeElemOff :: Ptr VkPhysicalDeviceProperties -> Int -> VkPhysicalDeviceProperties -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPhysicalDeviceProperties # pokeByteOff :: Ptr b -> Int -> VkPhysicalDeviceProperties -> IO () # peek :: Ptr VkPhysicalDeviceProperties -> IO VkPhysicalDeviceProperties # poke :: Ptr VkPhysicalDeviceProperties -> VkPhysicalDeviceProperties -> IO () #

Eq VkApplicationInfo Source #
Methods (==) :: VkApplicationInfo -> VkApplicationInfo -> Bool # (/=) :: VkApplicationInfo -> VkApplicationInfo -> Bool #
Show VkApplicationInfo Source #
Methods showsPrec :: Int -> VkApplicationInfo -> ShowS # show :: VkApplicationInfo -> String # showList :: [VkApplicationInfo] -> ShowS #
Storable VkApplicationInfo Source #
Methods sizeOf :: VkApplicationInfo -> Int # alignment :: VkApplicationInfo -> Int # peekElemOff :: Ptr VkApplicationInfo -> Int -> IO VkApplicationInfo # pokeElemOff :: Ptr VkApplicationInfo -> Int -> VkApplicationInfo -> IO () # peekByteOff :: Ptr b -> Int -> IO VkApplicationInfo # pokeByteOff :: Ptr b -> Int -> VkApplicationInfo -> IO () # peek :: Ptr VkApplicationInfo -> IO VkApplicationInfo # poke :: Ptr VkApplicationInfo -> VkApplicationInfo -> IO () #

Eq VkAllocationCallbacks Source #
Methods (==) :: VkAllocationCallbacks -> VkAllocationCallbacks -> Bool # (/=) :: VkAllocationCallbacks -> VkAllocationCallbacks -> Bool #
Show VkAllocationCallbacks Source #
Methods showsPrec :: Int -> VkAllocationCallbacks -> ShowS # show :: VkAllocationCallbacks -> String # showList :: [VkAllocationCallbacks] -> ShowS #
Storable VkAllocationCallbacks Source #
Methods sizeOf :: VkAllocationCallbacks -> Int # alignment :: VkAllocationCallbacks -> Int # peekElemOff :: Ptr VkAllocationCallbacks -> Int -> IO VkAllocationCallbacks # pokeElemOff :: Ptr VkAllocationCallbacks -> Int -> VkAllocationCallbacks -> IO () # peekByteOff :: Ptr b -> Int -> IO VkAllocationCallbacks # pokeByteOff :: Ptr b -> Int -> VkAllocationCallbacks -> IO () # peek :: Ptr VkAllocationCallbacks -> IO VkAllocationCallbacks # poke :: Ptr VkAllocationCallbacks -> VkAllocationCallbacks -> IO () #

Eq VkInstanceCreateInfo Source #
Methods (==) :: VkInstanceCreateInfo -> VkInstanceCreateInfo -> Bool # (/=) :: VkInstanceCreateInfo -> VkInstanceCreateInfo -> Bool #
Show VkInstanceCreateInfo Source #
Methods showsPrec :: Int -> VkInstanceCreateInfo -> ShowS # show :: VkInstanceCreateInfo -> String # showList :: [VkInstanceCreateInfo] -> ShowS #
Storable VkInstanceCreateInfo Source #
Methods sizeOf :: VkInstanceCreateInfo -> Int # alignment :: VkInstanceCreateInfo -> Int # peekElemOff :: Ptr VkInstanceCreateInfo -> Int -> IO VkInstanceCreateInfo # pokeElemOff :: Ptr VkInstanceCreateInfo -> Int -> VkInstanceCreateInfo -> IO () # peekByteOff :: Ptr b -> Int -> IO VkInstanceCreateInfo # pokeByteOff :: Ptr b -> Int -> VkInstanceCreateInfo -> IO () # peek :: Ptr VkInstanceCreateInfo -> IO VkInstanceCreateInfo # poke :: Ptr VkInstanceCreateInfo -> VkInstanceCreateInfo -> IO () #

Eq VkQueueFamilyProperties Source #
Methods (==) :: VkQueueFamilyProperties -> VkQueueFamilyProperties -> Bool # (/=) :: VkQueueFamilyProperties -> VkQueueFamilyProperties -> Bool #
Show VkQueueFamilyProperties Source #
Methods showsPrec :: Int -> VkQueueFamilyProperties -> ShowS # show :: VkQueueFamilyProperties -> String # showList :: [VkQueueFamilyProperties] -> ShowS #
Storable VkQueueFamilyProperties Source #
Methods sizeOf :: VkQueueFamilyProperties -> Int # alignment :: VkQueueFamilyProperties -> Int # peekElemOff :: Ptr VkQueueFamilyProperties -> Int -> IO VkQueueFamilyProperties # pokeElemOff :: Ptr VkQueueFamilyProperties -> Int -> VkQueueFamilyProperties -> IO () # peekByteOff :: Ptr b -> Int -> IO VkQueueFamilyProperties # pokeByteOff :: Ptr b -> Int -> VkQueueFamilyProperties -> IO () # peek :: Ptr VkQueueFamilyProperties -> IO VkQueueFamilyProperties # poke :: Ptr VkQueueFamilyProperties -> VkQueueFamilyProperties -> IO () #

Eq VkPhysicalDeviceMemoryProperties Source #
Methods (==) :: VkPhysicalDeviceMemoryProperties -> VkPhysicalDeviceMemoryProperties -> Bool # (/=) :: VkPhysicalDeviceMemoryProperties -> VkPhysicalDeviceMemoryProperties -> Bool #
Show VkPhysicalDeviceMemoryProperties Source #
Methods showsPrec :: Int -> VkPhysicalDeviceMemoryProperties -> ShowS # show :: VkPhysicalDeviceMemoryProperties -> String # showList :: [VkPhysicalDeviceMemoryProperties] -> ShowS #
Storable VkPhysicalDeviceMemoryProperties Source #
Methods sizeOf :: VkPhysicalDeviceMemoryProperties -> Int # alignment :: VkPhysicalDeviceMemoryProperties -> Int # peekElemOff :: Ptr VkPhysicalDeviceMemoryProperties -> Int -> IO VkPhysicalDeviceMemoryProperties # pokeElemOff :: Ptr VkPhysicalDeviceMemoryProperties -> Int -> VkPhysicalDeviceMemoryProperties -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPhysicalDeviceMemoryProperties # pokeByteOff :: Ptr b -> Int -> VkPhysicalDeviceMemoryProperties -> IO () # peek :: Ptr VkPhysicalDeviceMemoryProperties -> IO VkPhysicalDeviceMemoryProperties # poke :: Ptr VkPhysicalDeviceMemoryProperties -> VkPhysicalDeviceMemoryProperties -> IO () #

VkMemoryType
Fields vkPropertyFlags :: VkMemoryPropertyFlags `propertyFlags` is a bitmask of `VkMemoryPropertyFlagBits` of properties for this memory type. vkHeapIndex :: Word32 `heapIndex` describes which memory heap this memory type corresponds to, and must be less than `memoryHeapCount` from the `VkPhysicalDeviceMemoryProperties` structure.

Eq VkMemoryType Source #
Methods (==) :: VkMemoryType -> VkMemoryType -> Bool # (/=) :: VkMemoryType -> VkMemoryType -> Bool #
Show VkMemoryType Source #
Methods showsPrec :: Int -> VkMemoryType -> ShowS # show :: VkMemoryType -> String # showList :: [VkMemoryType] -> ShowS #
Storable VkMemoryType Source #
Methods sizeOf :: VkMemoryType -> Int # alignment :: VkMemoryType -> Int # peekElemOff :: Ptr VkMemoryType -> Int -> IO VkMemoryType # pokeElemOff :: Ptr VkMemoryType -> Int -> VkMemoryType -> IO () # peekByteOff :: Ptr b -> Int -> IO VkMemoryType # pokeByteOff :: Ptr b -> Int -> VkMemoryType -> IO () # peek :: Ptr VkMemoryType -> IO VkMemoryType # poke :: Ptr VkMemoryType -> VkMemoryType -> IO () #

VkMemoryHeap
Fields vkSize :: VkDeviceSize `size` is the total memory size in bytes in the heap. vkFlags :: VkMemoryHeapFlags `flags` is a bitmask of `VkMemoryHeapFlagBits` specifying attribute flags for the heap.

Eq VkMemoryHeap Source #
Methods (==) :: VkMemoryHeap -> VkMemoryHeap -> Bool # (/=) :: VkMemoryHeap -> VkMemoryHeap -> Bool #
Show VkMemoryHeap Source #
Methods showsPrec :: Int -> VkMemoryHeap -> ShowS # show :: VkMemoryHeap -> String # showList :: [VkMemoryHeap] -> ShowS #
Storable VkMemoryHeap Source #
Methods sizeOf :: VkMemoryHeap -> Int # alignment :: VkMemoryHeap -> Int # peekElemOff :: Ptr VkMemoryHeap -> Int -> IO VkMemoryHeap # pokeElemOff :: Ptr VkMemoryHeap -> Int -> VkMemoryHeap -> IO () # peekByteOff :: Ptr b -> Int -> IO VkMemoryHeap # pokeByteOff :: Ptr b -> Int -> VkMemoryHeap -> IO () # peek :: Ptr VkMemoryHeap -> IO VkMemoryHeap # poke :: Ptr VkMemoryHeap -> VkMemoryHeap -> IO () #

Documentation

See Also

See Also

Description

See Also

Description

See Also

See Also

Description

See Also

Description

See Also

See Also

See Also

See Also

Description

See Also

Description

See Also

See Also

Parameters

Description

See Also

Parameters

Description

See Also

Parameters

Description

See Also

Parameters

Description

See Also

Parameters

Description

See Also

Parameters

Description

See Also

Description

See Also

Description

See Also

Description

See Also

Parameters

Description

Valid Usage

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Description

Valid Usage

Valid Usage (Implicit)

Host Synchronization

See Also

Parameters

Description

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Description

Valid Usage (Implicit)

See Also

Parameters

Description

Valid Usage (Implicit)

See Also

Parameters

Description

Valid Usage (Implicit)

See Also

Parameters

Description

Valid Usage (Implicit)

See Also

Parameters

Description

Valid Usage (Implicit)

Eq VkFormatProperties Source #
Methods (==) :: VkFormatProperties -> VkFormatProperties -> Bool # (/=) :: VkFormatProperties -> VkFormatProperties -> Bool #
Show VkFormatProperties Source #
Methods showsPrec :: Int -> VkFormatProperties -> ShowS # show :: VkFormatProperties -> String # showList :: [VkFormatProperties] -> ShowS #
Storable VkFormatProperties Source #
Methods sizeOf :: VkFormatProperties -> Int # alignment :: VkFormatProperties -> Int # peekElemOff :: Ptr VkFormatProperties -> Int -> IO VkFormatProperties # pokeElemOff :: Ptr VkFormatProperties -> Int -> VkFormatProperties -> IO () # peekByteOff :: Ptr b -> Int -> IO VkFormatProperties # pokeByteOff :: Ptr b -> Int -> VkFormatProperties -> IO () # peek :: Ptr VkFormatProperties -> IO VkFormatProperties # poke :: Ptr VkFormatProperties -> VkFormatProperties -> IO () #

VkImageFormatProperties
Fields vkMaxExtent :: VkExtent3D vkMaxMipLevels :: Word32 vkMaxArrayLayers :: Word32 vkSampleCounts :: VkSampleCountFlags vkMaxResourceSize :: VkDeviceSize

Eq VkImageFormatProperties Source #
Methods (==) :: VkImageFormatProperties -> VkImageFormatProperties -> Bool # (/=) :: VkImageFormatProperties -> VkImageFormatProperties -> Bool #
Show VkImageFormatProperties Source #
Methods showsPrec :: Int -> VkImageFormatProperties -> ShowS # show :: VkImageFormatProperties -> String # showList :: [VkImageFormatProperties] -> ShowS #
Storable VkImageFormatProperties Source #
Methods sizeOf :: VkImageFormatProperties -> Int # alignment :: VkImageFormatProperties -> Int # peekElemOff :: Ptr VkImageFormatProperties -> Int -> IO VkImageFormatProperties # pokeElemOff :: Ptr VkImageFormatProperties -> Int -> VkImageFormatProperties -> IO () # peekByteOff :: Ptr b -> Int -> IO VkImageFormatProperties # pokeByteOff :: Ptr b -> Int -> VkImageFormatProperties -> IO () # peek :: Ptr VkImageFormatProperties -> IO VkImageFormatProperties # poke :: Ptr VkImageFormatProperties -> VkImageFormatProperties -> IO () #

Eq VkPhysicalDeviceFeatures Source #
Methods (==) :: VkPhysicalDeviceFeatures -> VkPhysicalDeviceFeatures -> Bool # (/=) :: VkPhysicalDeviceFeatures -> VkPhysicalDeviceFeatures -> Bool #
Show VkPhysicalDeviceFeatures Source #
Methods showsPrec :: Int -> VkPhysicalDeviceFeatures -> ShowS # show :: VkPhysicalDeviceFeatures -> String # showList :: [VkPhysicalDeviceFeatures] -> ShowS #
Storable VkPhysicalDeviceFeatures Source #
Methods sizeOf :: VkPhysicalDeviceFeatures -> Int # alignment :: VkPhysicalDeviceFeatures -> Int # peekElemOff :: Ptr VkPhysicalDeviceFeatures -> Int -> IO VkPhysicalDeviceFeatures # pokeElemOff :: Ptr VkPhysicalDeviceFeatures -> Int -> VkPhysicalDeviceFeatures -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPhysicalDeviceFeatures # pokeByteOff :: Ptr b -> Int -> VkPhysicalDeviceFeatures -> IO () # peek :: Ptr VkPhysicalDeviceFeatures -> IO VkPhysicalDeviceFeatures # poke :: Ptr VkPhysicalDeviceFeatures -> VkPhysicalDeviceFeatures -> IO () #

Eq VkPhysicalDeviceSparseProperties Source #
Methods (==) :: VkPhysicalDeviceSparseProperties -> VkPhysicalDeviceSparseProperties -> Bool # (/=) :: VkPhysicalDeviceSparseProperties -> VkPhysicalDeviceSparseProperties -> Bool #
Show VkPhysicalDeviceSparseProperties Source #
Methods showsPrec :: Int -> VkPhysicalDeviceSparseProperties -> ShowS # show :: VkPhysicalDeviceSparseProperties -> String # showList :: [VkPhysicalDeviceSparseProperties] -> ShowS #
Storable VkPhysicalDeviceSparseProperties Source #
Methods sizeOf :: VkPhysicalDeviceSparseProperties -> Int # alignment :: VkPhysicalDeviceSparseProperties -> Int # peekElemOff :: Ptr VkPhysicalDeviceSparseProperties -> Int -> IO VkPhysicalDeviceSparseProperties # pokeElemOff :: Ptr VkPhysicalDeviceSparseProperties -> Int -> VkPhysicalDeviceSparseProperties -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPhysicalDeviceSparseProperties # pokeByteOff :: Ptr b -> Int -> VkPhysicalDeviceSparseProperties -> IO () # peek :: Ptr VkPhysicalDeviceSparseProperties -> IO VkPhysicalDeviceSparseProperties # poke :: Ptr VkPhysicalDeviceSparseProperties -> VkPhysicalDeviceSparseProperties -> IO () #

Eq VkPhysicalDeviceLimits Source #
Methods (==) :: VkPhysicalDeviceLimits -> VkPhysicalDeviceLimits -> Bool # (/=) :: VkPhysicalDeviceLimits -> VkPhysicalDeviceLimits -> Bool #
Show VkPhysicalDeviceLimits Source #
Methods showsPrec :: Int -> VkPhysicalDeviceLimits -> ShowS # show :: VkPhysicalDeviceLimits -> String # showList :: [VkPhysicalDeviceLimits] -> ShowS #
Storable VkPhysicalDeviceLimits Source #
Methods sizeOf :: VkPhysicalDeviceLimits -> Int # alignment :: VkPhysicalDeviceLimits -> Int # peekElemOff :: Ptr VkPhysicalDeviceLimits -> Int -> IO VkPhysicalDeviceLimits # pokeElemOff :: Ptr VkPhysicalDeviceLimits -> Int -> VkPhysicalDeviceLimits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPhysicalDeviceLimits # pokeByteOff :: Ptr b -> Int -> VkPhysicalDeviceLimits -> IO () # peek :: Ptr VkPhysicalDeviceLimits -> IO VkPhysicalDeviceLimits # poke :: Ptr VkPhysicalDeviceLimits -> VkPhysicalDeviceLimits -> IO () #