Vulkan.Core10.DeviceInitialization

Documentation

createInstance

Arguments

:: forall a io. (Extendss InstanceCreateInfo a, PokeChain a, MonadIO io)

=> InstanceCreateInfo a

pCreateInfo is a pointer to a InstanceCreateInfo structure controlling creation of the instance.

-> ("allocator" ::: Maybe AllocationCallbacks)

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

-> io Instance

vkCreateInstance - Create a new Vulkan instance

Description

createInstance verifies that the requested layers exist. If not, createInstance will return ERROR_LAYER_NOT_PRESENT. Next createInstance 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, createInstance must return ERROR_EXTENSION_NOT_PRESENT. After verifying and enabling the instance layers and extensions the Instance 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 createInstance time for the creation to succeed.

Valid Usage

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

Valid Usage (Implicit)

• pCreateInfo must be a valid pointer to a valid InstanceCreateInfo structure

• If pAllocator is not NULL, pAllocator must be a valid pointer to a valid AllocationCallbacks structure
• pInstance must be a valid pointer to a Instance handle

Return Codes

Success

• SUCCESS

Failure

• ERROR_OUT_OF_HOST_MEMORY
• ERROR_OUT_OF_DEVICE_MEMORY
• ERROR_INITIALIZATION_FAILED
• ERROR_LAYER_NOT_PRESENT
• ERROR_EXTENSION_NOT_PRESENT
• ERROR_INCOMPATIBLE_DRIVER

See Also

AllocationCallbacks, Instance, InstanceCreateInfo

withInstance :: forall a io r. (Extendss InstanceCreateInfo a, PokeChain a, MonadIO io) => InstanceCreateInfo a -> Maybe AllocationCallbacks -> (io Instance -> (Instance -> io ()) -> r) -> r

A convenience wrapper to make a compatible pair of calls to createInstance and destroyInstance

To ensure that destroyInstance is always called: pass bracket (or the allocate function from your favourite resource management library) as the first argument. To just extract the pair pass (,) as the first argument.

destroyInstance

Arguments

:: forall io. MonadIO io

=> Instance

instance is the handle of the instance to destroy.

-> ("allocator" ::: Maybe AllocationCallbacks)

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

-> io ()

vkDestroyInstance - Destroy an instance of Vulkan

Valid Usage

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

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

Valid Usage (Implicit)

• If instance is not NULL, instance must be a valid Instance handle

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

Host Synchronization

• Host access to instance must be externally synchronized

• Host access to all PhysicalDevice objects enumerated from instance must be externally synchronized

See Also

AllocationCallbacks, Instance

enumeratePhysicalDevices

Arguments

:: forall io. MonadIO io

=> Instance

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

-> io (Result, "physicalDevices" ::: Vector PhysicalDevice)

vkEnumeratePhysicalDevices - Enumerates the physical devices accessible to a Vulkan instance

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, INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available physical devices were returned.

Valid Usage (Implicit)

• instance must be a valid Instance 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 PhysicalDevice handles

Return Codes

Success

• SUCCESS
• INCOMPLETE

Failure

• ERROR_OUT_OF_HOST_MEMORY
• ERROR_OUT_OF_DEVICE_MEMORY
• ERROR_INITIALIZATION_FAILED

See Also

Instance, PhysicalDevice

getDeviceProcAddr

Arguments

:: forall io. MonadIO io

=> Device

device must be a valid Device handle

-> ("name" ::: ByteString)

pName must be a null-terminated UTF-8 string

-> io PFN_vkVoidFunction

vkGetDeviceProcAddr - Return a function pointer for a command

Parameters

The table below defines the various use cases for getDeviceProcAddr 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 before use. 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	*1	undefined
invalid device	*1	undefined
device	NULL	undefined
device	core device-level Vulkan command	fp2
device	enabled extension device-level commands	fp2
any other case, not covered above	NULL

getDeviceProcAddr behavior

1

"*" means any representable value for the parameter (including valid values, invalid values, and NULL).

2

The returned function pointer must only be called with a dispatchable object (the first parameter) that is device or a child of device e.g. Device, Queue, or CommandBuffer.

Valid Usage (Implicit)

See Also

PFN_vkVoidFunction, Device

getInstanceProcAddr

Arguments

:: forall io. MonadIO io

=> Instance

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

-> ("name" ::: ByteString)

pName is the name of the command to obtain.

-> io PFN_vkVoidFunction

vkGetInstanceProcAddr - Return a function pointer for a command

Description

getInstanceProcAddr 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 getInstanceProcAddr 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 before use.

instance	pName	return value
*1	NULL	undefined
invalid non-NULL instance	*1	undefined
NULL	getInstanceProcAddr	fp4
NULL	enumerateInstanceVersion	fp
NULL	enumerateInstanceExtensionProperties	fp
NULL	enumerateInstanceLayerProperties	fp
NULL	createInstance	fp
instance	core Vulkan command	fp2
instance	enabled instance extension commands for instance	fp2
instance	available device extension3 commands for instance	fp2
any other case, not covered above	NULL

getInstanceProcAddr behavior

1

"*" means any representable value for the parameter (including valid values, invalid values, and NULL).

2

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. Instance, PhysicalDevice, Device, Queue, or CommandBuffer.

3

An “available device extension” is a device extension supported by any physical device enumerated by instance.

4

Starting with Vulkan 1.2, getInstanceProcAddr can resolve itself with a NULL instance pointer.

Valid Usage (Implicit)

• If instance is not NULL, instance must be a valid Instance handle

• pName must be a null-terminated UTF-8 string

See Also

PFN_vkVoidFunction, Instance

getPhysicalDeviceProperties

Arguments

:: forall io. MonadIO io

=> PhysicalDevice

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

physicalDevice must be a valid PhysicalDevice handle

-> io PhysicalDeviceProperties

vkGetPhysicalDeviceProperties - Returns properties of a physical device

Valid Usage (Implicit)

See Also

PhysicalDevice, PhysicalDeviceProperties

getPhysicalDeviceQueueFamilyProperties

Arguments

:: forall io. MonadIO io

=> PhysicalDevice

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

-> io ("queueFamilyProperties" ::: Vector QueueFamilyProperties)

vkGetPhysicalDeviceQueueFamilyProperties - Reports properties of the queues of the specified physical device

Description

If pQueueFamilyProperties is NULL, then the number of queue families available is returned in pQueueFamilyPropertyCount. Implementations must support at least one queue family. 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 PhysicalDevice 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 QueueFamilyProperties structures

See Also

PhysicalDevice, QueueFamilyProperties

getPhysicalDeviceMemoryProperties

Arguments

:: forall io. MonadIO io

=> PhysicalDevice

physicalDevice is the handle to the device to query.

physicalDevice must be a valid PhysicalDevice handle

-> io PhysicalDeviceMemoryProperties

vkGetPhysicalDeviceMemoryProperties - Reports memory information for the specified physical device

Valid Usage (Implicit)

See Also

PhysicalDevice, PhysicalDeviceMemoryProperties

getPhysicalDeviceFeatures

Arguments

:: forall io. MonadIO io

=> PhysicalDevice

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

physicalDevice must be a valid PhysicalDevice handle

-> io PhysicalDeviceFeatures

vkGetPhysicalDeviceFeatures - Reports capabilities of a physical device

Valid Usage (Implicit)

See Also

PhysicalDevice, PhysicalDeviceFeatures

getPhysicalDeviceFormatProperties

Arguments

:: forall io. MonadIO io

=> PhysicalDevice

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

physicalDevice must be a valid PhysicalDevice handle

-> Format

format is the format whose properties are queried.

format must be a valid Format value

-> io FormatProperties

vkGetPhysicalDeviceFormatProperties - Lists physical device’s format capabilities

Valid Usage (Implicit)

See Also

Format, FormatProperties, PhysicalDevice

getPhysicalDeviceImageFormatProperties

Arguments

:: forall io. MonadIO io

=> PhysicalDevice

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

physicalDevice must be a valid PhysicalDevice handle

-> Format

format is a Format value specifying the image format, corresponding to ImageCreateInfo::format.

format must be a valid Format value

-> ImageType

type is a ImageType value specifying the image type, corresponding to ImageCreateInfo::imageType.

type must be a valid ImageType value

-> ImageTiling

tiling is a ImageTiling value specifying the image tiling, corresponding to ImageCreateInfo::tiling.

tiling must not be IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT. (Use getPhysicalDeviceImageFormatProperties2 instead)

tiling must be a valid ImageTiling value

-> ImageUsageFlags

usage is a bitmask of ImageUsageFlagBits specifying the intended usage of the image, corresponding to ImageCreateInfo::usage.

usage must be a valid combination of ImageUsageFlagBits values

usage must not be 0

-> ImageCreateFlags

flags is a bitmask of ImageCreateFlagBits specifying additional parameters of the image, corresponding to ImageCreateInfo::flags.

flags must be a valid combination of ImageCreateFlagBits values

-> io ImageFormatProperties

vkGetPhysicalDeviceImageFormatProperties - Lists physical device’s image format capabilities

Description

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

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 getPhysicalDeviceImageFormatProperties returns ERROR_FORMAT_NOT_SUPPORTED.

The limitations on an image format that are reported by getPhysicalDeviceImageFormatProperties have the following property: if usage1 and usage2 of type ImageUsageFlags are such that the bits set in usage1 are a subset of the bits set in usage2, and flags1 and flags2 of type ImageCreateFlags 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.

Return Codes

Success

• SUCCESS

Failure

• ERROR_OUT_OF_HOST_MEMORY
• ERROR_OUT_OF_DEVICE_MEMORY
• ERROR_FORMAT_NOT_SUPPORTED

See Also

Format, ImageCreateFlags, ImageFormatProperties, ImageTiling, ImageType, ImageUsageFlags, PhysicalDevice

data PhysicalDeviceProperties

VkPhysicalDeviceProperties - Structure specifying physical device properties

Description

Note

The value of apiVersion may be different than the version returned by enumerateInstanceVersion; either higher or lower. In such cases, the application must not use functionality that exceeds the version of Vulkan associated with a given object. The pApiVersion parameter returned by enumerateInstanceVersion is the version associated with a Instance and its children, except for a PhysicalDevice and its children. PhysicalDeviceProperties::apiVersion is the version associated with a PhysicalDevice and its children.

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 PhysicalDevice 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: Procedures and Conventions 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. Khronos vendor IDs are symbolically defined in the VendorId type.

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.

See Also

PhysicalDeviceLimits, PhysicalDeviceProperties2, PhysicalDeviceSparseProperties, PhysicalDeviceType, getPhysicalDeviceProperties

Constructors

PhysicalDeviceProperties

Fields

• apiVersion :: Word32

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

• driverVersion :: Word32

  driverVersion is the vendor-specified version of the driver.

• vendorID :: Word32

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

• deviceID :: Word32

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

• deviceType :: PhysicalDeviceType

  deviceType is a PhysicalDeviceType specifying the type of device.

• deviceName :: ByteString

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

• pipelineCacheUUID :: ByteString

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

• limits :: PhysicalDeviceLimits

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

• sparseProperties :: PhysicalDeviceSparseProperties

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

Instances

Show PhysicalDeviceProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> PhysicalDeviceProperties -> ShowS

show :: PhysicalDeviceProperties -> String

showList :: [PhysicalDeviceProperties] -> ShowS

FromCStruct PhysicalDeviceProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr PhysicalDeviceProperties -> IO PhysicalDeviceProperties

ToCStruct PhysicalDeviceProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: PhysicalDeviceProperties -> (Ptr PhysicalDeviceProperties -> IO b) -> IO b

pokeCStruct :: Ptr PhysicalDeviceProperties -> PhysicalDeviceProperties -> IO b -> IO b

withZeroCStruct :: (Ptr PhysicalDeviceProperties -> IO b) -> IO b

pokeZeroCStruct :: Ptr PhysicalDeviceProperties -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero PhysicalDeviceProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: PhysicalDeviceProperties

data ApplicationInfo

VkApplicationInfo - Structure specifying application info

Description

Vulkan 1.0 implementations were required to return ERROR_INCOMPATIBLE_DRIVER if apiVersion was larger than 1.0. Implementations that support Vulkan 1.1 or later must not return ERROR_INCOMPATIBLE_DRIVER for any value of apiVersion.

Note

Because Vulkan 1.0 implementations may fail with ERROR_INCOMPATIBLE_DRIVER, applications should determine the version of Vulkan available before calling createInstance. If the getInstanceProcAddr returns NULL for enumerateInstanceVersion, it is a Vulkan 1.0 implementation. Otherwise, the application can call enumerateInstanceVersion to determine the version of Vulkan.

As long as the instance supports at least Vulkan 1.1, an application can use different versions of Vulkan with an instance than it does with a device or physical device.

Note

The Khronos validation layers will treat apiVersion as the highest API version the application targets, and will validate API usage against the minimum of that version and the implementation version (instance or device, depending on context). If an application tries to use functionality from a greater version than this, a validation error will be triggered.

For example, if the instance supports Vulkan 1.1 and three physical devices support Vulkan 1.0, Vulkan 1.1, and Vulkan 1.2, respectively, and if the application sets apiVersion to 1.2, the application can use the following versions of Vulkan:

• Vulkan 1.0 can be used with the instance and with all physical devices.
• Vulkan 1.1 can be used with the instance and with the physical devices that support Vulkan 1.1 and Vulkan 1.2.
• Vulkan 1.2 can be used with the physical device that supports Vulkan 1.2.

If we modify the above example so that the application sets apiVersion to 1.1, then the application must not use Vulkan 1.2 functionality on the physical device that supports Vulkan 1.2.

Implicit layers must be disabled if they do not support a version at least as high as apiVersion. See the Vulkan Loader Specification and Architecture Overview document for additional information.

Note

Providing a NULL InstanceCreateInfo::pApplicationInfo or providing an apiVersion of 0 is equivalent to providing an apiVersion of VK_MAKE_VERSION(1,0,0).

Valid Usage

• If apiVersion is not 0, then it must be greater or equal to API_VERSION_1_0

Valid Usage (Implicit)

• sType must be 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

See Also

InstanceCreateInfo, StructureType

Constructors

ApplicationInfo

Fields

• applicationName :: Maybe ByteString

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

• applicationVersion :: Word32

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

• engineName :: Maybe ByteString

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

• engineVersion :: Word32

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

• apiVersion :: Word32

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

Instances

Show ApplicationInfo

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> ApplicationInfo -> ShowS

show :: ApplicationInfo -> String

showList :: [ApplicationInfo] -> ShowS

FromCStruct ApplicationInfo

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr ApplicationInfo -> IO ApplicationInfo

ToCStruct ApplicationInfo

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: ApplicationInfo -> (Ptr ApplicationInfo -> IO b) -> IO b

pokeCStruct :: Ptr ApplicationInfo -> ApplicationInfo -> IO b -> IO b

withZeroCStruct :: (Ptr ApplicationInfo -> IO b) -> IO b

pokeZeroCStruct :: Ptr ApplicationInfo -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero ApplicationInfo

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: ApplicationInfo

data InstanceCreateInfo (es :: [Type])

VkInstanceCreateInfo - Structure specifying parameters of a newly created instance

Valid Usage (Implicit)

• sType must be 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 DebugReportCallbackCreateInfoEXT, DebugUtilsMessengerCreateInfoEXT, ValidationFeaturesEXT, or ValidationFlagsEXT
• The sType value of each struct in the pNext chain must be unique, with the exception of structures of type DebugUtilsMessengerCreateInfoEXT
• flags must be 0
• If pApplicationInfo is not NULL, pApplicationInfo must be a valid pointer to a valid ApplicationInfo 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

See Also

ApplicationInfo, InstanceCreateFlags, StructureType, createInstance

Constructors

InstanceCreateInfo

Fields

• next :: Chain es

  pNext is NULL or a pointer to a structure extending this structure.

• flags :: InstanceCreateFlags

  flags is reserved for future use.

• applicationInfo :: Maybe ApplicationInfo

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

• enabledLayerNames :: Vector ByteString

  ppEnabledLayerNames is a pointer to an array of enabledLayerCount null-terminated UTF-8 strings containing the names of layers to enable for the created instance. The layers are loaded in the order they are listed in this array, with the first array element being the closest to the application, and the last array element being the closest to the driver. See the https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#extendingvulkan-layers section for further details.

• enabledExtensionNames :: Vector ByteString

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

Instances

Extensible InstanceCreateInfo

Defined in Vulkan.Core10.DeviceInitialization

Methods

extensibleType :: StructureType

getNext :: forall (es :: [Type]). InstanceCreateInfo es -> Chain es

setNext :: forall (ds :: [Type]) (es :: [Type]). InstanceCreateInfo ds -> Chain es -> InstanceCreateInfo es

extends :: forall e b proxy. Typeable e => proxy e -> (Extends InstanceCreateInfo e => b) -> Maybe b

Show (Chain es) => Show (InstanceCreateInfo es)

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> InstanceCreateInfo es -> ShowS

show :: InstanceCreateInfo es -> String

showList :: [InstanceCreateInfo es] -> ShowS

(Extendss InstanceCreateInfo es, PeekChain es) => FromCStruct (InstanceCreateInfo es)

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr (InstanceCreateInfo es) -> IO (InstanceCreateInfo es)

(Extendss InstanceCreateInfo es, PokeChain es) => ToCStruct (InstanceCreateInfo es)

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: InstanceCreateInfo es -> (Ptr (InstanceCreateInfo es) -> IO b) -> IO b

pokeCStruct :: Ptr (InstanceCreateInfo es) -> InstanceCreateInfo es -> IO b -> IO b

withZeroCStruct :: (Ptr (InstanceCreateInfo es) -> IO b) -> IO b

pokeZeroCStruct :: Ptr (InstanceCreateInfo es) -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

es ~ ('[] :: [Type]) => Zero (InstanceCreateInfo es)

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: InstanceCreateInfo es

data QueueFamilyProperties

VkQueueFamilyProperties - Structure providing information about a queue family

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 Offset3D parameter must always be zero.
  • The width, height, and depth members of a Extent3D 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 Offset3D parameter must be integer multiples of Ax, Ay, and Az, respectively.
  • width of a Extent3D 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 Extent3D 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 Extent3D 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.

See Also

Extent3D, QueueFamilyProperties2, QueueFlags, getPhysicalDeviceQueueFamilyProperties

Constructors

QueueFamilyProperties

Fields

• queueFlags :: QueueFlags

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

• queueCount :: Word32

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

• timestampValidBits :: Word32

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

• minImageTransferGranularity :: Extent3D

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

Instances

Show QueueFamilyProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> QueueFamilyProperties -> ShowS

show :: QueueFamilyProperties -> String

showList :: [QueueFamilyProperties] -> ShowS

FromCStruct QueueFamilyProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr QueueFamilyProperties -> IO QueueFamilyProperties

ToCStruct QueueFamilyProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: QueueFamilyProperties -> (Ptr QueueFamilyProperties -> IO b) -> IO b

pokeCStruct :: Ptr QueueFamilyProperties -> QueueFamilyProperties -> IO b -> IO b

withZeroCStruct :: (Ptr QueueFamilyProperties -> IO b) -> IO b

pokeZeroCStruct :: Ptr QueueFamilyProperties -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero QueueFamilyProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: QueueFamilyProperties

data PhysicalDeviceMemoryProperties

VkPhysicalDeviceMemoryProperties - Structure specifying physical device memory properties

Description

The PhysicalDeviceMemoryProperties 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 MAX_MEMORY_HEAPS. Each heap is described by an element of the memoryHeaps array as a MemoryHeap structure. The number of memory types available across all memory heaps is given by memoryTypeCount and is less than or equal to MAX_MEMORY_TYPES. Each memory type is described by an element of the memoryTypes array as a MemoryType structure.

At least one heap must include MEMORY_HEAP_DEVICE_LOCAL_BIT in MemoryHeap::flags. If there are multiple heaps that all have similar performance characteristics, they may all include 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 getPhysicalDeviceMemoryProperties must have its propertyFlags set to one of the following values:

• 0
• MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT
• MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_CACHED_BIT
• MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_CACHED_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_CACHED_BIT
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_CACHED_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
• MEMORY_PROPERTY_PROTECTED_BIT
• MEMORY_PROPERTY_PROTECTED_BIT | MEMORY_PROPERTY_DEVICE_LOCAL_BIT
• MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
• MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_CACHED_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_CACHED_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
• MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD | MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
• MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_CACHED_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD | MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD | MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD | MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
• MEMORY_PROPERTY_DEVICE_LOCAL_BIT | MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_CACHED_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT | MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD | MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD

There must be at least one memory type with both the MEMORY_PROPERTY_HOST_VISIBLE_BIT and MEMORY_PROPERTY_HOST_COHERENT_BIT bits set in its propertyFlags. There must be at least one memory type with the MEMORY_PROPERTY_DEVICE_LOCAL_BIT bit set in its propertyFlags. If the deviceCoherentMemory feature is enabled, there must be at least one memory type with the MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD 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:

• 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) ; or
• the propertyFlags members of Y includes MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD or MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD and X does not

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 a valid order. But if instead MEMORY_PROPERTY_DEVICE_LOCAL_BIT was before MEMORY_PROPERTY_HOST_VISIBLE_BIT | MEMORY_PROPERTY_HOST_COHERENT_BIT, the list would still be in a valid order.

There may be a performance penalty for using device coherent or uncached device memory types, and using these accidentally is undesirable. In order to avoid this, memory types with these properties always appear at the end of the list; but are subject to the same rules otherwise.

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);

See Also

MemoryHeap, MemoryType, PhysicalDeviceMemoryProperties2, getPhysicalDeviceMemoryProperties

Constructors

PhysicalDeviceMemoryProperties

Fields

• memoryTypeCount :: Word32

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

• memoryTypes :: Vector MemoryType

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

• memoryHeapCount :: Word32

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

• memoryHeaps :: Vector MemoryHeap

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

Instances

Show PhysicalDeviceMemoryProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> PhysicalDeviceMemoryProperties -> ShowS

show :: PhysicalDeviceMemoryProperties -> String

showList :: [PhysicalDeviceMemoryProperties] -> ShowS

FromCStruct PhysicalDeviceMemoryProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr PhysicalDeviceMemoryProperties -> IO PhysicalDeviceMemoryProperties

ToCStruct PhysicalDeviceMemoryProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: PhysicalDeviceMemoryProperties -> (Ptr PhysicalDeviceMemoryProperties -> IO b) -> IO b

pokeCStruct :: Ptr PhysicalDeviceMemoryProperties -> PhysicalDeviceMemoryProperties -> IO b -> IO b

withZeroCStruct :: (Ptr PhysicalDeviceMemoryProperties -> IO b) -> IO b

pokeZeroCStruct :: Ptr PhysicalDeviceMemoryProperties -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero PhysicalDeviceMemoryProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: PhysicalDeviceMemoryProperties

data MemoryType

VkMemoryType - Structure specifying memory type

See Also

MemoryPropertyFlags, PhysicalDeviceMemoryProperties

Constructors

MemoryType

Fields

• propertyFlags :: MemoryPropertyFlags

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

• heapIndex :: Word32

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

Instances

Eq MemoryType

Defined in Vulkan.Core10.DeviceInitialization

Methods

(==) :: MemoryType -> MemoryType -> Bool

(/=) :: MemoryType -> MemoryType -> Bool

Show MemoryType

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> MemoryType -> ShowS

show :: MemoryType -> String

showList :: [MemoryType] -> ShowS

Storable MemoryType

Defined in Vulkan.Core10.DeviceInitialization

Methods

sizeOf :: MemoryType -> Int

alignment :: MemoryType -> Int

peekElemOff :: Ptr MemoryType -> Int -> IO MemoryType

pokeElemOff :: Ptr MemoryType -> Int -> MemoryType -> IO ()

peekByteOff :: Ptr b -> Int -> IO MemoryType

pokeByteOff :: Ptr b -> Int -> MemoryType -> IO ()

peek :: Ptr MemoryType -> IO MemoryType

poke :: Ptr MemoryType -> MemoryType -> IO ()

FromCStruct MemoryType

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr MemoryType -> IO MemoryType

ToCStruct MemoryType

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: MemoryType -> (Ptr MemoryType -> IO b) -> IO b

pokeCStruct :: Ptr MemoryType -> MemoryType -> IO b -> IO b

withZeroCStruct :: (Ptr MemoryType -> IO b) -> IO b

pokeZeroCStruct :: Ptr MemoryType -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero MemoryType

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: MemoryType

data MemoryHeap

VkMemoryHeap - Structure specifying a memory heap

See Also

DeviceSize, MemoryHeapFlags, PhysicalDeviceMemoryProperties

Constructors

MemoryHeap

Fields

• size :: DeviceSize

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

• flags :: MemoryHeapFlags

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

Instances

Eq MemoryHeap

Defined in Vulkan.Core10.DeviceInitialization

Methods

(==) :: MemoryHeap -> MemoryHeap -> Bool

(/=) :: MemoryHeap -> MemoryHeap -> Bool

Show MemoryHeap

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> MemoryHeap -> ShowS

show :: MemoryHeap -> String

showList :: [MemoryHeap] -> ShowS

Storable MemoryHeap

Defined in Vulkan.Core10.DeviceInitialization

Methods

sizeOf :: MemoryHeap -> Int

alignment :: MemoryHeap -> Int

peekElemOff :: Ptr MemoryHeap -> Int -> IO MemoryHeap

pokeElemOff :: Ptr MemoryHeap -> Int -> MemoryHeap -> IO ()

peekByteOff :: Ptr b -> Int -> IO MemoryHeap

pokeByteOff :: Ptr b -> Int -> MemoryHeap -> IO ()

peek :: Ptr MemoryHeap -> IO MemoryHeap

poke :: Ptr MemoryHeap -> MemoryHeap -> IO ()

FromCStruct MemoryHeap

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr MemoryHeap -> IO MemoryHeap

ToCStruct MemoryHeap

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: MemoryHeap -> (Ptr MemoryHeap -> IO b) -> IO b

pokeCStruct :: Ptr MemoryHeap -> MemoryHeap -> IO b -> IO b

withZeroCStruct :: (Ptr MemoryHeap -> IO b) -> IO b

pokeZeroCStruct :: Ptr MemoryHeap -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero MemoryHeap

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: MemoryHeap

data FormatProperties

VkFormatProperties - Structure specifying image format properties

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-compressed format, then bufferFeatures must not support any features for the format.

If format is not a multi-plane format then linearTilingFeatures and optimalTilingFeatures must not contain FORMAT_FEATURE_DISJOINT_BIT.

See Also

FormatFeatureFlags, FormatProperties2, getPhysicalDeviceFormatProperties

Constructors

FormatProperties

Fields

• linearTilingFeatures :: FormatFeatureFlags

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

• optimalTilingFeatures :: FormatFeatureFlags

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

• bufferFeatures :: FormatFeatureFlags

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

Instances

Eq FormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

(==) :: FormatProperties -> FormatProperties -> Bool

(/=) :: FormatProperties -> FormatProperties -> Bool

Show FormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> FormatProperties -> ShowS

show :: FormatProperties -> String

showList :: [FormatProperties] -> ShowS

Storable FormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

sizeOf :: FormatProperties -> Int

alignment :: FormatProperties -> Int

peekElemOff :: Ptr FormatProperties -> Int -> IO FormatProperties

pokeElemOff :: Ptr FormatProperties -> Int -> FormatProperties -> IO ()

peekByteOff :: Ptr b -> Int -> IO FormatProperties

pokeByteOff :: Ptr b -> Int -> FormatProperties -> IO ()

peek :: Ptr FormatProperties -> IO FormatProperties

poke :: Ptr FormatProperties -> FormatProperties -> IO ()

FromCStruct FormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr FormatProperties -> IO FormatProperties

ToCStruct FormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: FormatProperties -> (Ptr FormatProperties -> IO b) -> IO b

pokeCStruct :: Ptr FormatProperties -> FormatProperties -> IO b -> IO b

withZeroCStruct :: (Ptr FormatProperties -> IO b) -> IO b

pokeZeroCStruct :: Ptr FormatProperties -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero FormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: FormatProperties

data ImageFormatProperties

VkImageFormatProperties - Structure specifying an image format properties

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 the number of levels in the complete mipmap chain based on the maxExtent.width, maxExtent.height, and maxExtent.depth, except when one of the following conditions is true, in which case it may instead be 1:

  • getPhysicalDeviceImageFormatProperties::tiling was IMAGE_TILING_LINEAR
  • PhysicalDeviceImageFormatInfo2::tiling was IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
  • the PhysicalDeviceImageFormatInfo2::pNext chain included a PhysicalDeviceExternalImageFormatInfo structure with a handle type included in the handleTypes member for which mipmap image support is not required
  • image format is one of those listed in https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#formats-requiring-sampler-ycbcr-conversion
  • flags contains IMAGE_CREATE_SUBSAMPLED_BIT_EXT

• maxArrayLayers is the maximum number of array layers. maxArrayLayers must be no less than PhysicalDeviceLimits::maxImageArrayLayers, except when one of the following conditions is true, in which case it may instead be 1:

  • tiling is IMAGE_TILING_LINEAR
  • tiling is IMAGE_TILING_OPTIMAL and type is IMAGE_TYPE_3D
  • format is one of those listed in https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#formats-requiring-sampler-ycbcr-conversion
• If tiling is IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then maxArrayLayers must not be 0.
• sampleCounts is a bitmask of SampleCountFlagBits 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 createImage will return 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 IMAGE_TYPE_1D.

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

Note

Filling ImageFormatProperties 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.

See Also

DeviceSize, Extent3D, ExternalImageFormatPropertiesNV, ImageFormatProperties2, SampleCountFlags, getPhysicalDeviceImageFormatProperties

Constructors

ImageFormatProperties

Fields

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

Instances

Show ImageFormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> ImageFormatProperties -> ShowS

show :: ImageFormatProperties -> String

showList :: [ImageFormatProperties] -> ShowS

FromCStruct ImageFormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr ImageFormatProperties -> IO ImageFormatProperties

ToCStruct ImageFormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: ImageFormatProperties -> (Ptr ImageFormatProperties -> IO b) -> IO b

pokeCStruct :: Ptr ImageFormatProperties -> ImageFormatProperties -> IO b -> IO b

withZeroCStruct :: (Ptr ImageFormatProperties -> IO b) -> IO b

pokeZeroCStruct :: Ptr ImageFormatProperties -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero ImageFormatProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: ImageFormatProperties

data PhysicalDeviceFeatures

VkPhysicalDeviceFeatures - Structure describing the fine-grained features that can be supported by an implementation

Members

The members of the PhysicalDeviceFeatures structure describe the following features:

See Also

Bool32, DeviceCreateInfo, PhysicalDeviceFeatures2, getPhysicalDeviceFeatures

Constructors

PhysicalDeviceFeatures

Fields

• robustBufferAccess :: Bool

  robustBufferAccess specifies that accesses to buffers are bounds-checked against the range of the buffer descriptor (as determined by DescriptorBufferInfo::range, BufferViewCreateInfo::range, or the size of the buffer). Out of bounds accesses must not cause application termination, and the effects of shader loads, stores, and atomics must conform to an implementation-dependent behavior as described below.

  • A buffer access is considered to be out of bounds if any of the following are true:

    • The pointer was formed by OpImageTexelPointer and the coordinate is less than zero or greater than or equal to the number of whole elements in the bound range.

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

      Note

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

    • If robustBufferAccess2 is not enabled and any buffer access is determined to be out of bounds, then any other access of the same type (load, store, or atomic) to the same buffer that accesses an address less than 16 bytes away from the out of bounds address may also be considered out of bounds.
    • If the access is a load that reads from the same memory locations as a prior store in the same shader invocation, with no other intervening accesses to the same memory locations in that shader invocation, then the result of the load may be the value stored by the store instruction, even if the access is out of bounds. If the load is Volatile, then an out of bounds load must return the appropriate out of bounds value.
  • Accesses to descriptors written with a NULL_HANDLE resource or view are not considered to be out of bounds. Instead, each type of descriptor access defines a specific behavior for accesses to a null descriptor.

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

    • If the access is to a uniform buffer and robustBufferAccess2 is enabled, loads of offsets between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of robustUniformBufferAccessSizeAlignment bytes must return either zero values or the contents of the memory at the offset being loaded. Loads of offsets past the descriptor range rounded up to a multiple of robustUniformBufferAccessSizeAlignment bytes must return zero values.
    • If the access is to a storage buffer and robustBufferAccess2 is enabled, loads of offsets between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of robustStorageBufferAccessSizeAlignment bytes must return either zero values or the contents of the memory at the offset being loaded. Loads of offsets past the descriptor range rounded up to a multiple of robustStorageBufferAccessSizeAlignment bytes must return zero values. Similarly, stores to addresses between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of robustStorageBufferAccessSizeAlignment bytes may be discarded.
    • Non-atomic accesses to storage buffers that are a multiple of 32 bits may be decomposed into 32-bit accesses that are individually bounds-checked.
    • If the access is to an index buffer and robustBufferAccess2 is enabled, zero values must be returned.
    • If the access is to a uniform texel buffer or storage texel buffer and robustBufferAccess2 is enabled, zero values must be returned, and then Conversion to RGBA is applied based on the buffer view’s format.
    • 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.

    • If robustBufferAccess2 is enabled, out of bounds writes must not modify any 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.

    • If robustBufferAccess2 is enabled, out of bounds atomics must not modify any memory, and return an undefined value.

  • If robustBufferAccess2 is disabled, 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 robustBufferAccess2 is enabled, vertex input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than the byte size of the memory range bound to the vertex buffer binding.

    • If a vertex input attribute is out of bounds, the raw data extracted are zero values, and missing G, B, or A components are filled with (0,0,1).
  • If robustBufferAccess is not enabled, applications must not perform out of bounds accesses.
• fullDrawIndexUint32 :: Bool

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

• imageCubeArray :: Bool

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

• independentBlend :: Bool

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

• geometryShader :: Bool

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

• tessellationShader :: Bool

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

• sampleRateShading :: Bool

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

• dualSrcBlend :: Bool

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

• logicOp :: Bool

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

• multiDrawIndirect :: Bool

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

• drawIndirectFirstInstance :: Bool

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

• depthClamp :: Bool

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

• depthBiasClamp :: Bool

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

• fillModeNonSolid :: Bool

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

• depthBounds :: Bool

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

• wideLines :: Bool

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

• largePoints :: Bool

  largePoints specifies whether points with size greater than 1.0 are supported. If this feature is not enabled, only a point size of 1.0 written by a shader is supported. The range and granularity of supported point sizes are indicated by the pointSizeRange and pointSizeGranularity members of the PhysicalDeviceLimits structure, respectively.

• alphaToOne :: Bool

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

• multiViewport :: Bool

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

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

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

• textureCompressionETC2 :: Bool

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

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

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

• textureCompressionASTC_LDR :: Bool

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

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

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

• textureCompressionBC :: Bool

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

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

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

• occlusionQueryPrecise :: Bool

  occlusionQueryPrecise specifies whether occlusion queries returning actual sample counts are supported. Occlusion queries are created in a QueryPool by specifying the queryType of QUERY_TYPE_OCCLUSION in the QueryPoolCreateInfo structure which is passed to createQueryPool. If this feature is enabled, queries of this type can enable QUERY_CONTROL_PRECISE_BIT in the flags parameter to cmdBeginQuery. If this feature is not supported, the implementation supports only boolean occlusion queries. When any samples are passed, boolean queries will return a non-zero result value, otherwise a result value of zero is returned. When this feature is enabled and QUERY_CONTROL_PRECISE_BIT is set, occlusion queries will report the actual number of samples passed.

• pipelineStatisticsQuery :: Bool

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

• vertexPipelineStoresAndAtomics :: Bool

  vertexPipelineStoresAndAtomics specifies whether storage buffers and images support stores and atomic operations in the vertex, tessellation, and geometry shader stages. If this feature is not enabled, all storage image, storage texel buffers, and storage buffer variables used by these stages in shader modules must be decorated with the NonWritable decoration (or the readonly memory qualifier in GLSL).

• fragmentStoresAndAtomics :: Bool

  fragmentStoresAndAtomics specifies whether storage buffers and images support stores and atomic operations in the fragment shader stage. If this feature is not enabled, all storage image, storage texel buffers, and storage buffer variables used by the fragment stage in shader modules must be decorated with the NonWritable decoration (or the readonly memory qualifier in GLSL).

• shaderTessellationAndGeometryPointSize :: Bool

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

• shaderImageGatherExtended :: Bool

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

• shaderStorageImageExtendedFormats :: Bool

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

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

  Note

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

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

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

• shaderStorageImageMultisample :: Bool

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

• shaderStorageImageReadWithoutFormat :: Bool

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

• shaderStorageImageWriteWithoutFormat :: Bool

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

• shaderUniformBufferArrayDynamicIndexing :: Bool

  shaderUniformBufferArrayDynamicIndexing specifies whether arrays of uniform buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the UniformBufferArrayDynamicIndexing capability.

• shaderSampledImageArrayDynamicIndexing :: Bool

  shaderSampledImageArrayDynamicIndexing specifies whether arrays of samplers or sampled images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of DESCRIPTOR_TYPE_SAMPLER, DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or DESCRIPTOR_TYPE_SAMPLED_IMAGE must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the SampledImageArrayDynamicIndexing capability.

• shaderStorageBufferArrayDynamicIndexing :: Bool

  shaderStorageBufferArrayDynamicIndexing specifies whether arrays of storage buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the StorageBufferArrayDynamicIndexing capability.

• shaderStorageImageArrayDynamicIndexing :: Bool

  shaderStorageImageArrayDynamicIndexing specifies whether arrays of storage images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of DESCRIPTOR_TYPE_STORAGE_IMAGE must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the StorageImageArrayDynamicIndexing capability.

• shaderClipDistance :: Bool

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

• shaderCullDistance :: Bool

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

• shaderFloat64 :: Bool

  shaderFloat64 specifies whether 64-bit floats (doubles) are supported in shader code. If this feature is not enabled, 64-bit floating-point types must not be used in shader code. This also specifies whether shader modules can declare the Float64 capability. Declaring and using 64-bit floats is enabled for all storage classes that SPIR-V allows with the Float64 capability.

• shaderInt64 :: Bool

  shaderInt64 specifies whether 64-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 64-bit integer types must not be used in shader code. This also specifies whether shader modules can declare the Int64 capability. Declaring and using 64-bit integers is enabled for all storage classes that SPIR-V allows with the Int64 capability.

• shaderInt16 :: Bool

  shaderInt16 specifies whether 16-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 16-bit integer types must not be used in shader code. This also specifies whether shader modules can declare the Int16 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the Int16 SPIR-V capability: Declaring and using 16-bit integers in the Private, Workgroup, and Function storage classes is enabled, while declaring them in the interface storage classes (e.g., UniformConstant, Uniform, StorageBuffer, Input, Output, and PushConstant) is not enabled.

• shaderResourceResidency :: Bool

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

• shaderResourceMinLod :: Bool

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

• sparseBinding :: Bool

  sparseBinding specifies whether resource memory can be managed at opaque sparse block level instead of at the object level. If this feature is not enabled, resource memory must be bound only on a per-object basis using the bindBufferMemory and bindImageMemory commands. In this case, buffers and images must not be created with BUFFER_CREATE_SPARSE_BINDING_BIT and IMAGE_CREATE_SPARSE_BINDING_BIT set in the flags member of the BufferCreateInfo and ImageCreateInfo structures, respectively. Otherwise resource memory can be managed as described in Sparse Resource Features.

• sparseResidencyBuffer :: Bool

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

• sparseResidencyImage2D :: Bool

  sparseResidencyImage2D specifies whether the device can access partially resident 2D images with 1 sample per pixel. If this feature is not enabled, images with an imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_1_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidencyImage3D :: Bool

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

• sparseResidency2Samples :: Bool

  sparseResidency2Samples specifies whether the physical device can access partially resident 2D images with 2 samples per pixel. If this feature is not enabled, images with an imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_2_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidency4Samples :: Bool

  sparseResidency4Samples specifies whether the physical device can access partially resident 2D images with 4 samples per pixel. If this feature is not enabled, images with an imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_4_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidency8Samples :: Bool

  sparseResidency8Samples specifies whether the physical device can access partially resident 2D images with 8 samples per pixel. If this feature is not enabled, images with an imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_8_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidency16Samples :: Bool

  sparseResidency16Samples specifies whether the physical device can access partially resident 2D images with 16 samples per pixel. If this feature is not enabled, images with an imageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_16_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the flags member of the ImageCreateInfo structure.

• sparseResidencyAliased :: Bool

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

• variableMultisampleRate :: Bool

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

• inheritedQueries :: Bool

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

Instances

Eq PhysicalDeviceFeatures

Defined in Vulkan.Core10.DeviceInitialization

Methods

(==) :: PhysicalDeviceFeatures -> PhysicalDeviceFeatures -> Bool

(/=) :: PhysicalDeviceFeatures -> PhysicalDeviceFeatures -> Bool

Show PhysicalDeviceFeatures

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> PhysicalDeviceFeatures -> ShowS

show :: PhysicalDeviceFeatures -> String

showList :: [PhysicalDeviceFeatures] -> ShowS

Storable PhysicalDeviceFeatures

Defined in Vulkan.Core10.DeviceInitialization

Methods

sizeOf :: PhysicalDeviceFeatures -> Int

alignment :: PhysicalDeviceFeatures -> Int

peekElemOff :: Ptr PhysicalDeviceFeatures -> Int -> IO PhysicalDeviceFeatures

pokeElemOff :: Ptr PhysicalDeviceFeatures -> Int -> PhysicalDeviceFeatures -> IO ()

peekByteOff :: Ptr b -> Int -> IO PhysicalDeviceFeatures

pokeByteOff :: Ptr b -> Int -> PhysicalDeviceFeatures -> IO ()

peek :: Ptr PhysicalDeviceFeatures -> IO PhysicalDeviceFeatures

poke :: Ptr PhysicalDeviceFeatures -> PhysicalDeviceFeatures -> IO ()

FromCStruct PhysicalDeviceFeatures

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr PhysicalDeviceFeatures -> IO PhysicalDeviceFeatures

ToCStruct PhysicalDeviceFeatures

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: PhysicalDeviceFeatures -> (Ptr PhysicalDeviceFeatures -> IO b) -> IO b

pokeCStruct :: Ptr PhysicalDeviceFeatures -> PhysicalDeviceFeatures -> IO b -> IO b

withZeroCStruct :: (Ptr PhysicalDeviceFeatures -> IO b) -> IO b

pokeZeroCStruct :: Ptr PhysicalDeviceFeatures -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero PhysicalDeviceFeatures

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: PhysicalDeviceFeatures

data PhysicalDeviceSparseProperties

VkPhysicalDeviceSparseProperties - Structure specifying physical device sparse memory properties

See Also

Bool32, PhysicalDeviceProperties

Constructors

PhysicalDeviceSparseProperties

Fields

• residencyStandard2DBlockShape :: Bool

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

• residencyStandard2DMultisampleBlockShape :: Bool

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

• residencyStandard3DBlockShape :: Bool

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

• residencyAlignedMipSize :: Bool

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

• residencyNonResidentStrict :: Bool

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

Instances

Eq PhysicalDeviceSparseProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

(==) :: PhysicalDeviceSparseProperties -> PhysicalDeviceSparseProperties -> Bool

(/=) :: PhysicalDeviceSparseProperties -> PhysicalDeviceSparseProperties -> Bool

Show PhysicalDeviceSparseProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> PhysicalDeviceSparseProperties -> ShowS

show :: PhysicalDeviceSparseProperties -> String

showList :: [PhysicalDeviceSparseProperties] -> ShowS

Storable PhysicalDeviceSparseProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

sizeOf :: PhysicalDeviceSparseProperties -> Int

alignment :: PhysicalDeviceSparseProperties -> Int

peekElemOff :: Ptr PhysicalDeviceSparseProperties -> Int -> IO PhysicalDeviceSparseProperties

pokeElemOff :: Ptr PhysicalDeviceSparseProperties -> Int -> PhysicalDeviceSparseProperties -> IO ()

peekByteOff :: Ptr b -> Int -> IO PhysicalDeviceSparseProperties

pokeByteOff :: Ptr b -> Int -> PhysicalDeviceSparseProperties -> IO ()

peek :: Ptr PhysicalDeviceSparseProperties -> IO PhysicalDeviceSparseProperties

poke :: Ptr PhysicalDeviceSparseProperties -> PhysicalDeviceSparseProperties -> IO ()

FromCStruct PhysicalDeviceSparseProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr PhysicalDeviceSparseProperties -> IO PhysicalDeviceSparseProperties

ToCStruct PhysicalDeviceSparseProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: PhysicalDeviceSparseProperties -> (Ptr PhysicalDeviceSparseProperties -> IO b) -> IO b

pokeCStruct :: Ptr PhysicalDeviceSparseProperties -> PhysicalDeviceSparseProperties -> IO b -> IO b

withZeroCStruct :: (Ptr PhysicalDeviceSparseProperties -> IO b) -> IO b

pokeZeroCStruct :: Ptr PhysicalDeviceSparseProperties -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero PhysicalDeviceSparseProperties

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: PhysicalDeviceSparseProperties

data PhysicalDeviceLimits

VkPhysicalDeviceLimits - Structure reporting implementation-dependent physical device limits

Members

The PhysicalDeviceLimits are properties of the physical device. These are available in the limits member of the PhysicalDeviceProperties structure which is returned from getPhysicalDeviceProperties.

Description

1

For all bitmasks of SampleCountFlagBits, 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 getPhysicalDeviceImageFormatProperties as described in Supported Sample Counts.

See Also

Bool32, DeviceSize, PhysicalDeviceProperties, SampleCountFlags

Constructors

PhysicalDeviceLimits

Fields

• maxImageDimension1D :: Word32

  maxImageDimension1D is the largest dimension (width) that is guaranteed to be supported for all images created with an imageType of IMAGE_TYPE_1D. Some combinations of image parameters (format, usage, etc.) may allow support for larger dimensions, which can be queried using getPhysicalDeviceImageFormatProperties.

• maxImageDimension2D :: Word32

  maxImageDimension2D is the largest dimension (width or height) that is guaranteed to be supported for all images created with an imageType of IMAGE_TYPE_2D and without IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in flags. Some combinations of image parameters (format, usage, etc.) may allow support for larger dimensions, which can be queried using getPhysicalDeviceImageFormatProperties.

• maxImageDimension3D :: Word32

  maxImageDimension3D is the largest dimension (width, height, or depth) that is guaranteed to be supported for all images created with an imageType of IMAGE_TYPE_3D. Some combinations of image parameters (format, usage, etc.) may allow support for larger dimensions, which can be queried using getPhysicalDeviceImageFormatProperties.

• maxImageDimensionCube :: Word32

  maxImageDimensionCube is the largest dimension (width or height) that is guaranteed to be supported for all images created with an imageType of IMAGE_TYPE_2D and with IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in flags. Some combinations of image parameters (format, usage, etc.) may allow support for larger dimensions, which can be queried using getPhysicalDeviceImageFormatProperties.

• maxImageArrayLayers :: Word32

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

• maxTexelBufferElements :: Word32

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

• maxUniformBufferRange :: Word32

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

• maxStorageBufferRange :: Word32

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

• maxPushConstantsSize :: Word32

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

• maxMemoryAllocationCount :: Word32

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

• maxSamplerAllocationCount :: Word32

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

• bufferImageGranularity :: DeviceSize

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

• sparseAddressSpaceSize :: DeviceSize

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

• maxBoundDescriptorSets :: Word32

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

• maxPerStageDescriptorSamplers :: Word32

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

• maxPerStageDescriptorUniformBuffers :: Word32

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

• maxPerStageDescriptorStorageBuffers :: Word32

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

• maxPerStageDescriptorSampledImages :: Word32

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

• maxPerStageDescriptorStorageImages :: Word32

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

• maxPerStageDescriptorInputAttachments :: Word32

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

• maxPerStageResources :: Word32

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

• maxDescriptorSetSamplers :: Word32

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

• maxDescriptorSetUniformBuffers :: Word32

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

• maxDescriptorSetUniformBuffersDynamic :: Word32

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

• maxDescriptorSetStorageBuffers :: Word32

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

• maxDescriptorSetStorageBuffersDynamic :: Word32

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

• maxDescriptorSetSampledImages :: Word32

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

• maxDescriptorSetStorageImages :: Word32

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

• maxDescriptorSetInputAttachments :: Word32

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

• maxVertexInputAttributes :: Word32

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

• maxVertexInputBindings :: Word32

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

• maxVertexInputAttributeOffset :: Word32

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

• maxVertexInputBindingStride :: Word32

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

• maxVertexOutputComponents :: Word32

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

• maxTessellationGenerationLevel :: Word32

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

• maxTessellationPatchSize :: Word32

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

• maxTessellationControlPerVertexInputComponents :: Word32

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

• maxTessellationControlPerVertexOutputComponents :: Word32

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

• maxTessellationControlPerPatchOutputComponents :: Word32

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

• maxTessellationControlTotalOutputComponents :: Word32

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

• maxTessellationEvaluationInputComponents :: Word32

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

• maxTessellationEvaluationOutputComponents :: Word32

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

• maxGeometryShaderInvocations :: Word32

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

• maxGeometryInputComponents :: Word32

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

• maxGeometryOutputComponents :: Word32

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

• maxGeometryOutputVertices :: Word32

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

• maxGeometryTotalOutputComponents :: Word32

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

• maxFragmentInputComponents :: Word32

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

• maxFragmentOutputAttachments :: Word32

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

• maxFragmentDualSrcAttachments :: Word32

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

• maxFragmentCombinedOutputResources :: Word32

  maxFragmentCombinedOutputResources is the total number of storage buffers, storage images, and output Location decorated color attachments (described in Fragment Output Interface) which can be used in the fragment shader stage.

• maxComputeSharedMemorySize :: Word32

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

• maxComputeWorkGroupCount :: (Word32, Word32, Word32)

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

• maxComputeWorkGroupInvocations :: Word32

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

• maxComputeWorkGroupSize :: (Word32, Word32, Word32)

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

• subPixelPrecisionBits :: Word32

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

• subTexelPrecisionBits :: Word32

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

• mipmapPrecisionBits :: Word32

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

• maxDrawIndexedIndexValue :: Word32

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

• maxDrawIndirectCount :: Word32

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

• maxSamplerLodBias :: Float

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

• maxSamplerAnisotropy :: Float

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

• maxViewports :: Word32

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

• maxViewportDimensions :: (Word32, Word32)

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

• viewportBoundsRange :: (Float, Float)

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

  Note

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

• viewportSubPixelBits :: Word32

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

• minMemoryMapAlignment :: Word64

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

• minTexelBufferOffsetAlignment :: DeviceSize

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

• minUniformBufferOffsetAlignment :: DeviceSize

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

• minStorageBufferOffsetAlignment :: DeviceSize

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

• minTexelOffset :: Int32

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

• maxTexelOffset :: Word32

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

• minTexelGatherOffset :: Int32

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

• maxTexelGatherOffset :: Word32

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

• minInterpolationOffset :: Float

  minInterpolationOffset is the base minimum (inclusive) negative offset value for the Offset operand of the InterpolateAtOffset extended instruction.

• maxInterpolationOffset :: Float

  maxInterpolationOffset is the base maximum (inclusive) positive offset value for the Offset operand of the InterpolateAtOffset extended instruction.

• subPixelInterpolationOffsetBits :: Word32

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

• maxFramebufferWidth :: Word32

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

• maxFramebufferHeight :: Word32

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

• maxFramebufferLayers :: Word32

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

• framebufferColorSampleCounts :: SampleCountFlags

  framebufferColorSampleCounts is a bitmask1 of SampleCountFlagBits indicating the color sample counts that are supported for all framebuffer color attachments with floating- or fixed-point formats. For color attachments with integer formats, see framebufferIntegerColorSampleCounts.

• framebufferDepthSampleCounts :: SampleCountFlags

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

• framebufferStencilSampleCounts :: SampleCountFlags

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

• framebufferNoAttachmentsSampleCounts :: SampleCountFlags

  framebufferNoAttachmentsSampleCounts is a bitmask1 of SampleCountFlagBits indicating the supported sample counts for a subpass which uses no attachments.

• maxColorAttachments :: Word32

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

• sampledImageColorSampleCounts :: SampleCountFlags

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

• sampledImageIntegerSampleCounts :: SampleCountFlags

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

• sampledImageDepthSampleCounts :: SampleCountFlags

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

• sampledImageStencilSampleCounts :: SampleCountFlags

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

• storageImageSampleCounts :: SampleCountFlags

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

• maxSampleMaskWords :: Word32

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

• timestampComputeAndGraphics :: Bool

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

• timestampPeriod :: Float

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

• maxClipDistances :: Word32

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

• maxCullDistances :: Word32

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

• maxCombinedClipAndCullDistances :: Word32

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

• discreteQueuePriorities :: Word32

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

• pointSizeRange :: (Float, Float)

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

• lineWidthRange :: (Float, Float)

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

• pointSizeGranularity :: Float

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

• lineWidthGranularity :: Float

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

• strictLines :: Bool

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

• standardSampleLocations :: Bool

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

• optimalBufferCopyOffsetAlignment :: DeviceSize

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

• optimalBufferCopyRowPitchAlignment :: DeviceSize

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

• nonCoherentAtomSize :: DeviceSize

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

Instances

Eq PhysicalDeviceLimits

Defined in Vulkan.Core10.DeviceInitialization

Methods

(==) :: PhysicalDeviceLimits -> PhysicalDeviceLimits -> Bool

(/=) :: PhysicalDeviceLimits -> PhysicalDeviceLimits -> Bool

Show PhysicalDeviceLimits

Defined in Vulkan.Core10.DeviceInitialization

Methods

showsPrec :: Int -> PhysicalDeviceLimits -> ShowS

show :: PhysicalDeviceLimits -> String

showList :: [PhysicalDeviceLimits] -> ShowS

Storable PhysicalDeviceLimits

Defined in Vulkan.Core10.DeviceInitialization

Methods

sizeOf :: PhysicalDeviceLimits -> Int

alignment :: PhysicalDeviceLimits -> Int

peekElemOff :: Ptr PhysicalDeviceLimits -> Int -> IO PhysicalDeviceLimits

pokeElemOff :: Ptr PhysicalDeviceLimits -> Int -> PhysicalDeviceLimits -> IO ()

peekByteOff :: Ptr b -> Int -> IO PhysicalDeviceLimits

pokeByteOff :: Ptr b -> Int -> PhysicalDeviceLimits -> IO ()

peek :: Ptr PhysicalDeviceLimits -> IO PhysicalDeviceLimits

poke :: Ptr PhysicalDeviceLimits -> PhysicalDeviceLimits -> IO ()

FromCStruct PhysicalDeviceLimits

Defined in Vulkan.Core10.DeviceInitialization

Methods

peekCStruct :: Ptr PhysicalDeviceLimits -> IO PhysicalDeviceLimits

ToCStruct PhysicalDeviceLimits

Defined in Vulkan.Core10.DeviceInitialization

Methods

withCStruct :: PhysicalDeviceLimits -> (Ptr PhysicalDeviceLimits -> IO b) -> IO b

pokeCStruct :: Ptr PhysicalDeviceLimits -> PhysicalDeviceLimits -> IO b -> IO b

withZeroCStruct :: (Ptr PhysicalDeviceLimits -> IO b) -> IO b

pokeZeroCStruct :: Ptr PhysicalDeviceLimits -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero PhysicalDeviceLimits

Defined in Vulkan.Core10.DeviceInitialization

Methods

zero :: PhysicalDeviceLimits

data Instance

VkInstance - Opaque handle to an instance object

See Also

createAndroidSurfaceKHR, createDebugReportCallbackEXT, createDebugUtilsMessengerEXT, createDirectFBSurfaceEXT, createDisplayPlaneSurfaceKHR, createHeadlessSurfaceEXT, createIOSSurfaceMVK, createImagePipeSurfaceFUCHSIA, createInstance, createMacOSSurfaceMVK, createMetalSurfaceEXT, createStreamDescriptorSurfaceGGP, createViSurfaceNN, createWaylandSurfaceKHR, createWin32SurfaceKHR, createXcbSurfaceKHR, createXlibSurfaceKHR, debugReportMessageEXT, destroyDebugReportCallbackEXT, destroyDebugUtilsMessengerEXT, destroyInstance, destroySurfaceKHR, enumeratePhysicalDeviceGroups, enumeratePhysicalDeviceGroupsKHR, enumeratePhysicalDevices, getInstanceProcAddr, submitDebugUtilsMessageEXT

Constructors

Instance

Fields

• instanceHandle :: Ptr Instance_T
• instanceCmds :: InstanceCmds

Instances

Eq Instance

Defined in Vulkan.Core10.Handles

Methods

(==) :: Instance -> Instance -> Bool

(/=) :: Instance -> Instance -> Bool

Show Instance

Defined in Vulkan.Core10.Handles

Methods

showsPrec :: Int -> Instance -> ShowS

show :: Instance -> String

showList :: [Instance] -> ShowS

Zero Instance

Defined in Vulkan.Core10.Handles

Methods

zero :: Instance

HasObjectType Instance

Defined in Vulkan.Core10.Handles

Methods

objectTypeAndHandle :: Instance -> (ObjectType, Word64)

IsHandle Instance

Defined in Vulkan.Core10.Handles

data PhysicalDevice

VkPhysicalDevice - Opaque handle to a physical device object

See Also

DeviceGroupDeviceCreateInfo, PhysicalDeviceGroupProperties, acquireXlibDisplayEXT, createDevice, createDisplayModeKHR, enumerateDeviceExtensionProperties, enumerateDeviceLayerProperties, enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, enumeratePhysicalDevices, getDisplayModeProperties2KHR, getDisplayModePropertiesKHR, getDisplayPlaneCapabilities2KHR, getDisplayPlaneCapabilitiesKHR, getDisplayPlaneSupportedDisplaysKHR, getPhysicalDeviceCalibrateableTimeDomainsEXT, getPhysicalDeviceCooperativeMatrixPropertiesNV, getPhysicalDeviceDirectFBPresentationSupportEXT, getPhysicalDeviceDisplayPlaneProperties2KHR, getPhysicalDeviceDisplayPlanePropertiesKHR, getPhysicalDeviceDisplayProperties2KHR, getPhysicalDeviceDisplayPropertiesKHR, getPhysicalDeviceExternalBufferProperties, getPhysicalDeviceExternalBufferPropertiesKHR, getPhysicalDeviceExternalFenceProperties, getPhysicalDeviceExternalFencePropertiesKHR, getPhysicalDeviceExternalImageFormatPropertiesNV, getPhysicalDeviceExternalSemaphoreProperties, getPhysicalDeviceExternalSemaphorePropertiesKHR, getPhysicalDeviceFeatures, getPhysicalDeviceFeatures2, getPhysicalDeviceFeatures2KHR, getPhysicalDeviceFormatProperties, getPhysicalDeviceFormatProperties2, getPhysicalDeviceFormatProperties2KHR, getPhysicalDeviceFragmentShadingRatesKHR, getPhysicalDeviceImageFormatProperties, getPhysicalDeviceImageFormatProperties2, getPhysicalDeviceImageFormatProperties2KHR, getPhysicalDeviceMemoryProperties, getPhysicalDeviceMemoryProperties2, getPhysicalDeviceMemoryProperties2KHR, getPhysicalDeviceMultisamplePropertiesEXT, getPhysicalDevicePresentRectanglesKHR, getPhysicalDeviceProperties, getPhysicalDeviceProperties2, getPhysicalDeviceProperties2KHR, getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, getPhysicalDeviceQueueFamilyProperties, getPhysicalDeviceQueueFamilyProperties2, getPhysicalDeviceQueueFamilyProperties2KHR, getPhysicalDeviceSparseImageFormatProperties, getPhysicalDeviceSparseImageFormatProperties2, getPhysicalDeviceSparseImageFormatProperties2KHR, getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, getPhysicalDeviceSurfaceCapabilities2EXT, getPhysicalDeviceSurfaceCapabilities2KHR, getPhysicalDeviceSurfaceCapabilitiesKHR, getPhysicalDeviceSurfaceFormats2KHR, getPhysicalDeviceSurfaceFormatsKHR, getPhysicalDeviceSurfacePresentModes2EXT, getPhysicalDeviceSurfacePresentModesKHR, getPhysicalDeviceSurfaceSupportKHR, getPhysicalDeviceToolPropertiesEXT, getPhysicalDeviceWaylandPresentationSupportKHR, getPhysicalDeviceWin32PresentationSupportKHR, getPhysicalDeviceXcbPresentationSupportKHR, getPhysicalDeviceXlibPresentationSupportKHR, getRandROutputDisplayEXT, releaseDisplayEXT

Constructors

PhysicalDevice

Fields

• physicalDeviceHandle :: Ptr PhysicalDevice_T
• instanceCmds :: InstanceCmds

Instances

Eq PhysicalDevice

Defined in Vulkan.Core10.Handles

Methods

(==) :: PhysicalDevice -> PhysicalDevice -> Bool

(/=) :: PhysicalDevice -> PhysicalDevice -> Bool

Show PhysicalDevice

Defined in Vulkan.Core10.Handles

Methods

showsPrec :: Int -> PhysicalDevice -> ShowS

show :: PhysicalDevice -> String

showList :: [PhysicalDevice] -> ShowS

Zero PhysicalDevice

Defined in Vulkan.Core10.Handles

Methods

zero :: PhysicalDevice

HasObjectType PhysicalDevice

Defined in Vulkan.Core10.Handles

Methods

objectTypeAndHandle :: PhysicalDevice -> (ObjectType, Word64)

IsHandle PhysicalDevice

Defined in Vulkan.Core10.Handles

data AllocationCallbacks

VkAllocationCallbacks - Structure containing callback function pointers for memory allocation

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

See Also

PFN_vkAllocationFunction, PFN_vkFreeFunction, PFN_vkInternalAllocationNotification, PFN_vkInternalFreeNotification, PFN_vkReallocationFunction, allocateMemory, createAccelerationStructureKHR, createAccelerationStructureNV, createAndroidSurfaceKHR, createBuffer, createBufferView, createCommandPool, createComputePipelines, createDebugReportCallbackEXT, createDebugUtilsMessengerEXT, createDeferredOperationKHR, createDescriptorPool, createDescriptorSetLayout, createDescriptorUpdateTemplate, createDescriptorUpdateTemplateKHR, createDevice, createDirectFBSurfaceEXT, createDisplayModeKHR, createDisplayPlaneSurfaceKHR, createEvent, createFence, createFramebuffer, createGraphicsPipelines, createHeadlessSurfaceEXT, createIOSSurfaceMVK, createImage, createImagePipeSurfaceFUCHSIA, createImageView, createIndirectCommandsLayoutNV, createInstance, createMacOSSurfaceMVK, createMetalSurfaceEXT, createPipelineCache, createPipelineLayout, createPrivateDataSlotEXT, createQueryPool, createRayTracingPipelinesKHR, createRayTracingPipelinesNV, createRenderPass, createRenderPass2, createRenderPass2KHR, createSampler, createSamplerYcbcrConversion, createSamplerYcbcrConversionKHR, createSemaphore, createShaderModule, createSharedSwapchainsKHR, createStreamDescriptorSurfaceGGP, createSwapchainKHR, createValidationCacheEXT, createViSurfaceNN, createWaylandSurfaceKHR, createWin32SurfaceKHR, createXcbSurfaceKHR, createXlibSurfaceKHR, destroyAccelerationStructureKHR, destroyAccelerationStructureNV, destroyBuffer, destroyBufferView, destroyCommandPool, destroyDebugReportCallbackEXT, destroyDebugUtilsMessengerEXT, destroyDeferredOperationKHR, destroyDescriptorPool, destroyDescriptorSetLayout, destroyDescriptorUpdateTemplate, destroyDescriptorUpdateTemplateKHR, destroyDevice, destroyEvent, destroyFence, destroyFramebuffer, destroyImage, destroyImageView, destroyIndirectCommandsLayoutNV, destroyInstance, destroyPipeline, destroyPipelineCache, destroyPipelineLayout, destroyPrivateDataSlotEXT, destroyQueryPool, destroyRenderPass, destroySampler, destroySamplerYcbcrConversion, destroySamplerYcbcrConversionKHR, destroySemaphore, destroyShaderModule, destroySurfaceKHR, destroySwapchainKHR, destroyValidationCacheEXT, freeMemory, registerDeviceEventEXT, registerDisplayEventEXT

Constructors

AllocationCallbacks

Fields

• userData :: Ptr ()

  pUserData is a value to be interpreted by the implementation of the callbacks. When any of the callbacks in AllocationCallbacks are called, the Vulkan implementation will pass this value as the first parameter to the callback. This value can vary each time an allocator is passed into a command, even when the same object takes an allocator in multiple commands.

• pfnAllocation :: PFN_vkAllocationFunction

  pfnAllocation is a PFN_vkAllocationFunction pointer to an application-defined memory allocation function.

• pfnReallocation :: PFN_vkReallocationFunction

  pfnReallocation is a PFN_vkReallocationFunction pointer to an application-defined memory reallocation function.

• pfnFree :: PFN_vkFreeFunction

  pfnFree is a PFN_vkFreeFunction pointer to an application-defined memory free function.

• pfnInternalAllocation :: PFN_vkInternalAllocationNotification

  pfnInternalAllocation is a PFN_vkInternalAllocationNotification pointer to an application-defined function that is called by the implementation when the implementation makes internal allocations.

• pfnInternalFree :: PFN_vkInternalFreeNotification

  pfnInternalFree is a PFN_vkInternalFreeNotification pointer to an application-defined function that is called by the implementation when the implementation frees internal allocations.

Instances

Show AllocationCallbacks

Defined in Vulkan.Core10.AllocationCallbacks

Methods

showsPrec :: Int -> AllocationCallbacks -> ShowS

show :: AllocationCallbacks -> String

showList :: [AllocationCallbacks] -> ShowS

Storable AllocationCallbacks

Defined in Vulkan.Core10.AllocationCallbacks

Methods

sizeOf :: AllocationCallbacks -> Int

alignment :: AllocationCallbacks -> Int

peekElemOff :: Ptr AllocationCallbacks -> Int -> IO AllocationCallbacks

pokeElemOff :: Ptr AllocationCallbacks -> Int -> AllocationCallbacks -> IO ()

peekByteOff :: Ptr b -> Int -> IO AllocationCallbacks

pokeByteOff :: Ptr b -> Int -> AllocationCallbacks -> IO ()

peek :: Ptr AllocationCallbacks -> IO AllocationCallbacks

poke :: Ptr AllocationCallbacks -> AllocationCallbacks -> IO ()

FromCStruct AllocationCallbacks

Defined in Vulkan.Core10.AllocationCallbacks

Methods

peekCStruct :: Ptr AllocationCallbacks -> IO AllocationCallbacks

ToCStruct AllocationCallbacks

Defined in Vulkan.Core10.AllocationCallbacks

Methods

withCStruct :: AllocationCallbacks -> (Ptr AllocationCallbacks -> IO b) -> IO b

pokeCStruct :: Ptr AllocationCallbacks -> AllocationCallbacks -> IO b -> IO b

withZeroCStruct :: (Ptr AllocationCallbacks -> IO b) -> IO b

pokeZeroCStruct :: Ptr AllocationCallbacks -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero AllocationCallbacks

Defined in Vulkan.Core10.AllocationCallbacks

Methods

zero :: AllocationCallbacks

newtype InstanceCreateFlags

VkInstanceCreateFlags - Reserved for future use

Description

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

See Also

InstanceCreateInfo

Constructors

InstanceCreateFlags Flags

Instances

Eq InstanceCreateFlags

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Methods

(==) :: InstanceCreateFlags -> InstanceCreateFlags -> Bool

(/=) :: InstanceCreateFlags -> InstanceCreateFlags -> Bool

Ord InstanceCreateFlags

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Methods

compare :: InstanceCreateFlags -> InstanceCreateFlags -> Ordering

(<) :: InstanceCreateFlags -> InstanceCreateFlags -> Bool

(<=) :: InstanceCreateFlags -> InstanceCreateFlags -> Bool

(>) :: InstanceCreateFlags -> InstanceCreateFlags -> Bool

(>=) :: InstanceCreateFlags -> InstanceCreateFlags -> Bool

max :: InstanceCreateFlags -> InstanceCreateFlags -> InstanceCreateFlags

min :: InstanceCreateFlags -> InstanceCreateFlags -> InstanceCreateFlags

Read InstanceCreateFlags

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Methods

readsPrec :: Int -> ReadS InstanceCreateFlags

readList :: ReadS [InstanceCreateFlags]

readPrec :: ReadPrec InstanceCreateFlags

readListPrec :: ReadPrec [InstanceCreateFlags]

Show InstanceCreateFlags

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Methods

showsPrec :: Int -> InstanceCreateFlags -> ShowS

show :: InstanceCreateFlags -> String

showList :: [InstanceCreateFlags] -> ShowS

Storable InstanceCreateFlags

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Methods

sizeOf :: InstanceCreateFlags -> Int

alignment :: InstanceCreateFlags -> Int

peekElemOff :: Ptr InstanceCreateFlags -> Int -> IO InstanceCreateFlags

pokeElemOff :: Ptr InstanceCreateFlags -> Int -> InstanceCreateFlags -> IO ()

peekByteOff :: Ptr b -> Int -> IO InstanceCreateFlags

pokeByteOff :: Ptr b -> Int -> InstanceCreateFlags -> IO ()

peek :: Ptr InstanceCreateFlags -> IO InstanceCreateFlags

poke :: Ptr InstanceCreateFlags -> InstanceCreateFlags -> IO ()

Bits InstanceCreateFlags

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Methods

(.&.) :: InstanceCreateFlags -> InstanceCreateFlags -> InstanceCreateFlags

(.|.) :: InstanceCreateFlags -> InstanceCreateFlags -> InstanceCreateFlags

xor :: InstanceCreateFlags -> InstanceCreateFlags -> InstanceCreateFlags

complement :: InstanceCreateFlags -> InstanceCreateFlags

shift :: InstanceCreateFlags -> Int -> InstanceCreateFlags

rotate :: InstanceCreateFlags -> Int -> InstanceCreateFlags

zeroBits :: InstanceCreateFlags

bit :: Int -> InstanceCreateFlags

setBit :: InstanceCreateFlags -> Int -> InstanceCreateFlags

clearBit :: InstanceCreateFlags -> Int -> InstanceCreateFlags

complementBit :: InstanceCreateFlags -> Int -> InstanceCreateFlags

testBit :: InstanceCreateFlags -> Int -> Bool

bitSizeMaybe :: InstanceCreateFlags -> Maybe Int

bitSize :: InstanceCreateFlags -> Int

isSigned :: InstanceCreateFlags -> Bool

shiftL :: InstanceCreateFlags -> Int -> InstanceCreateFlags

unsafeShiftL :: InstanceCreateFlags -> Int -> InstanceCreateFlags

shiftR :: InstanceCreateFlags -> Int -> InstanceCreateFlags

unsafeShiftR :: InstanceCreateFlags -> Int -> InstanceCreateFlags

rotateL :: InstanceCreateFlags -> Int -> InstanceCreateFlags

rotateR :: InstanceCreateFlags -> Int -> InstanceCreateFlags

popCount :: InstanceCreateFlags -> Int

Zero InstanceCreateFlags

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Methods

zero :: InstanceCreateFlags

newtype ImageType

VkImageType - Specifies the type of an image object

See Also

ImageCreateInfo, PhysicalDeviceImageFormatInfo2, PhysicalDeviceSparseImageFormatInfo2, getPhysicalDeviceExternalImageFormatPropertiesNV, getPhysicalDeviceImageFormatProperties, getPhysicalDeviceSparseImageFormatProperties

Constructors

ImageType Int32

Bundled Patterns

pattern IMAGE_TYPE_1D :: ImageType

IMAGE_TYPE_1D specifies a one-dimensional image.

pattern IMAGE_TYPE_2D :: ImageType

IMAGE_TYPE_2D specifies a two-dimensional image.

pattern IMAGE_TYPE_3D :: ImageType

IMAGE_TYPE_3D specifies a three-dimensional image.

Instances

Eq ImageType

Defined in Vulkan.Core10.Enums.ImageType

Methods

(==) :: ImageType -> ImageType -> Bool

(/=) :: ImageType -> ImageType -> Bool

Ord ImageType

Defined in Vulkan.Core10.Enums.ImageType

Methods

compare :: ImageType -> ImageType -> Ordering

(<) :: ImageType -> ImageType -> Bool

(<=) :: ImageType -> ImageType -> Bool

(>) :: ImageType -> ImageType -> Bool

(>=) :: ImageType -> ImageType -> Bool

max :: ImageType -> ImageType -> ImageType

min :: ImageType -> ImageType -> ImageType

Read ImageType

Defined in Vulkan.Core10.Enums.ImageType

Methods

readsPrec :: Int -> ReadS ImageType

readList :: ReadS [ImageType]

readPrec :: ReadPrec ImageType

readListPrec :: ReadPrec [ImageType]

Show ImageType

Defined in Vulkan.Core10.Enums.ImageType

Methods

showsPrec :: Int -> ImageType -> ShowS

show :: ImageType -> String

showList :: [ImageType] -> ShowS

Storable ImageType

Defined in Vulkan.Core10.Enums.ImageType

Methods

sizeOf :: ImageType -> Int

alignment :: ImageType -> Int

peekElemOff :: Ptr ImageType -> Int -> IO ImageType

pokeElemOff :: Ptr ImageType -> Int -> ImageType -> IO ()

peekByteOff :: Ptr b -> Int -> IO ImageType

pokeByteOff :: Ptr b -> Int -> ImageType -> IO ()

peek :: Ptr ImageType -> IO ImageType

poke :: Ptr ImageType -> ImageType -> IO ()

Zero ImageType

Defined in Vulkan.Core10.Enums.ImageType

Methods

zero :: ImageType

newtype ImageTiling

VkImageTiling - Specifies the tiling arrangement of data in an image

See Also

ImageCreateInfo, PhysicalDeviceImageFormatInfo2, PhysicalDeviceSparseImageFormatInfo2, getPhysicalDeviceExternalImageFormatPropertiesNV, getPhysicalDeviceImageFormatProperties, getPhysicalDeviceSparseImageFormatProperties

Constructors

ImageTiling Int32

Bundled Patterns

pattern IMAGE_TILING_OPTIMAL :: ImageTiling

IMAGE_TILING_OPTIMAL specifies optimal tiling (texels are laid out in an implementation-dependent arrangement, for more optimal memory access).

pattern IMAGE_TILING_LINEAR :: ImageTiling

IMAGE_TILING_LINEAR specifies linear tiling (texels are laid out in memory in row-major order, possibly with some padding on each row).

pattern IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT :: ImageTiling

IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT indicates that the image’s tiling is defined by a Linux DRM format modifier. The modifier is specified at image creation with ImageDrmFormatModifierListCreateInfoEXT or ImageDrmFormatModifierExplicitCreateInfoEXT, and can be queried with getImageDrmFormatModifierPropertiesEXT.

Instances

Eq ImageTiling

Defined in Vulkan.Core10.Enums.ImageTiling

Methods

(==) :: ImageTiling -> ImageTiling -> Bool

(/=) :: ImageTiling -> ImageTiling -> Bool

Ord ImageTiling

Defined in Vulkan.Core10.Enums.ImageTiling

Methods

compare :: ImageTiling -> ImageTiling -> Ordering

(<) :: ImageTiling -> ImageTiling -> Bool

(<=) :: ImageTiling -> ImageTiling -> Bool

(>) :: ImageTiling -> ImageTiling -> Bool

(>=) :: ImageTiling -> ImageTiling -> Bool

max :: ImageTiling -> ImageTiling -> ImageTiling

min :: ImageTiling -> ImageTiling -> ImageTiling

Read ImageTiling

Defined in Vulkan.Core10.Enums.ImageTiling

Methods

readsPrec :: Int -> ReadS ImageTiling

readList :: ReadS [ImageTiling]

readPrec :: ReadPrec ImageTiling

readListPrec :: ReadPrec [ImageTiling]

Show ImageTiling

Defined in Vulkan.Core10.Enums.ImageTiling

Methods

showsPrec :: Int -> ImageTiling -> ShowS

show :: ImageTiling -> String

showList :: [ImageTiling] -> ShowS

Storable ImageTiling

Defined in Vulkan.Core10.Enums.ImageTiling

Methods

sizeOf :: ImageTiling -> Int

alignment :: ImageTiling -> Int

peekElemOff :: Ptr ImageTiling -> Int -> IO ImageTiling

pokeElemOff :: Ptr ImageTiling -> Int -> ImageTiling -> IO ()

peekByteOff :: Ptr b -> Int -> IO ImageTiling

pokeByteOff :: Ptr b -> Int -> ImageTiling -> IO ()

peek :: Ptr ImageTiling -> IO ImageTiling

poke :: Ptr ImageTiling -> ImageTiling -> IO ()

Zero ImageTiling

Defined in Vulkan.Core10.Enums.ImageTiling

Methods

zero :: ImageTiling

newtype InternalAllocationType

VkInternalAllocationType - Allocation type

See Also

PFN_vkInternalAllocationNotification, PFN_vkInternalFreeNotification

Constructors

InternalAllocationType Int32

Bundled Patterns

pattern INTERNAL_ALLOCATION_TYPE_EXECUTABLE :: InternalAllocationType

INTERNAL_ALLOCATION_TYPE_EXECUTABLE specifies that the allocation is intended for execution by the host.

Instances

Eq InternalAllocationType

Defined in Vulkan.Core10.Enums.InternalAllocationType

Methods

(==) :: InternalAllocationType -> InternalAllocationType -> Bool

(/=) :: InternalAllocationType -> InternalAllocationType -> Bool

Ord InternalAllocationType

Defined in Vulkan.Core10.Enums.InternalAllocationType

Methods

compare :: InternalAllocationType -> InternalAllocationType -> Ordering

(<) :: InternalAllocationType -> InternalAllocationType -> Bool

(<=) :: InternalAllocationType -> InternalAllocationType -> Bool

(>) :: InternalAllocationType -> InternalAllocationType -> Bool

(>=) :: InternalAllocationType -> InternalAllocationType -> Bool

max :: InternalAllocationType -> InternalAllocationType -> InternalAllocationType

min :: InternalAllocationType -> InternalAllocationType -> InternalAllocationType

Read InternalAllocationType

Defined in Vulkan.Core10.Enums.InternalAllocationType

Methods

readsPrec :: Int -> ReadS InternalAllocationType

readList :: ReadS [InternalAllocationType]

readPrec :: ReadPrec InternalAllocationType

readListPrec :: ReadPrec [InternalAllocationType]

Show InternalAllocationType

Defined in Vulkan.Core10.Enums.InternalAllocationType

Methods

showsPrec :: Int -> InternalAllocationType -> ShowS

show :: InternalAllocationType -> String

showList :: [InternalAllocationType] -> ShowS

Storable InternalAllocationType

Defined in Vulkan.Core10.Enums.InternalAllocationType

Methods

sizeOf :: InternalAllocationType -> Int

alignment :: InternalAllocationType -> Int

peekElemOff :: Ptr InternalAllocationType -> Int -> IO InternalAllocationType

pokeElemOff :: Ptr InternalAllocationType -> Int -> InternalAllocationType -> IO ()

peekByteOff :: Ptr b -> Int -> IO InternalAllocationType

pokeByteOff :: Ptr b -> Int -> InternalAllocationType -> IO ()

peek :: Ptr InternalAllocationType -> IO InternalAllocationType

poke :: Ptr InternalAllocationType -> InternalAllocationType -> IO ()

Zero InternalAllocationType

Defined in Vulkan.Core10.Enums.InternalAllocationType

Methods

zero :: InternalAllocationType

newtype SystemAllocationScope

VkSystemAllocationScope - Allocation scope

Description

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

• SYSTEM_ALLOCATION_SCOPE_OBJECT specifies that the allocation is scoped to the lifetime of the Vulkan object that is being created or used.
• SYSTEM_ALLOCATION_SCOPE_CACHE specifies that the allocation is scoped to the lifetime of a PipelineCache or ValidationCacheEXT object.
• SYSTEM_ALLOCATION_SCOPE_DEVICE specifies that the allocation is scoped to the lifetime of the Vulkan device.
• 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 SYSTEM_ALLOCATION_SCOPE_OBJECT or 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 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 Device has an allocator it will be used, else if the parent Instance has an allocator it will be used. Else,
• If an allocation is associated with a ValidationCacheEXT or PipelineCache object, the allocator will use the 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 Device or Instance, the allocator will use an allocation scope of 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 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 SYSTEM_ALLOCATION_SCOPE_INSTANCE.
• Otherwise an implementation will allocate memory through an alternative mechanism that is unspecified.

See Also

AllocationCallbacks

Constructors

SystemAllocationScope Int32

Bundled Patterns

pattern SYSTEM_ALLOCATION_SCOPE_COMMAND :: SystemAllocationScope

pattern SYSTEM_ALLOCATION_SCOPE_OBJECT :: SystemAllocationScope

pattern SYSTEM_ALLOCATION_SCOPE_CACHE :: SystemAllocationScope

pattern SYSTEM_ALLOCATION_SCOPE_DEVICE :: SystemAllocationScope

pattern SYSTEM_ALLOCATION_SCOPE_INSTANCE :: SystemAllocationScope

Instances

Eq SystemAllocationScope

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Methods

(==) :: SystemAllocationScope -> SystemAllocationScope -> Bool

(/=) :: SystemAllocationScope -> SystemAllocationScope -> Bool

Ord SystemAllocationScope

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Methods

compare :: SystemAllocationScope -> SystemAllocationScope -> Ordering

(<) :: SystemAllocationScope -> SystemAllocationScope -> Bool

(<=) :: SystemAllocationScope -> SystemAllocationScope -> Bool

(>) :: SystemAllocationScope -> SystemAllocationScope -> Bool

(>=) :: SystemAllocationScope -> SystemAllocationScope -> Bool

max :: SystemAllocationScope -> SystemAllocationScope -> SystemAllocationScope

min :: SystemAllocationScope -> SystemAllocationScope -> SystemAllocationScope

Read SystemAllocationScope

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Methods

readsPrec :: Int -> ReadS SystemAllocationScope

readList :: ReadS [SystemAllocationScope]

readPrec :: ReadPrec SystemAllocationScope

readListPrec :: ReadPrec [SystemAllocationScope]

Show SystemAllocationScope

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Methods

showsPrec :: Int -> SystemAllocationScope -> ShowS

show :: SystemAllocationScope -> String

showList :: [SystemAllocationScope] -> ShowS

Storable SystemAllocationScope

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Methods

sizeOf :: SystemAllocationScope -> Int

alignment :: SystemAllocationScope -> Int

peekElemOff :: Ptr SystemAllocationScope -> Int -> IO SystemAllocationScope

pokeElemOff :: Ptr SystemAllocationScope -> Int -> SystemAllocationScope -> IO ()

peekByteOff :: Ptr b -> Int -> IO SystemAllocationScope

pokeByteOff :: Ptr b -> Int -> SystemAllocationScope -> IO ()

peek :: Ptr SystemAllocationScope -> IO SystemAllocationScope

poke :: Ptr SystemAllocationScope -> SystemAllocationScope -> IO ()

Zero SystemAllocationScope

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Methods

zero :: SystemAllocationScope

newtype PhysicalDeviceType

VkPhysicalDeviceType - Supported physical device types

Description

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.

See Also

PhysicalDeviceProperties

Constructors

PhysicalDeviceType Int32

Bundled Patterns

pattern PHYSICAL_DEVICE_TYPE_OTHER :: PhysicalDeviceType

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

pattern PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU :: PhysicalDeviceType

PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU - the device is typically one embedded in or tightly coupled with the host.

pattern PHYSICAL_DEVICE_TYPE_DISCRETE_GPU :: PhysicalDeviceType

PHYSICAL_DEVICE_TYPE_DISCRETE_GPU - the device is typically a separate processor connected to the host via an interlink.

pattern PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU :: PhysicalDeviceType

PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU - the device is typically a virtual node in a virtualization environment.

pattern PHYSICAL_DEVICE_TYPE_CPU :: PhysicalDeviceType

PHYSICAL_DEVICE_TYPE_CPU - the device is typically running on the same processors as the host.

Instances

Eq PhysicalDeviceType

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Methods

(==) :: PhysicalDeviceType -> PhysicalDeviceType -> Bool

(/=) :: PhysicalDeviceType -> PhysicalDeviceType -> Bool

Ord PhysicalDeviceType

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Methods

compare :: PhysicalDeviceType -> PhysicalDeviceType -> Ordering

(<) :: PhysicalDeviceType -> PhysicalDeviceType -> Bool

(<=) :: PhysicalDeviceType -> PhysicalDeviceType -> Bool

(>) :: PhysicalDeviceType -> PhysicalDeviceType -> Bool

(>=) :: PhysicalDeviceType -> PhysicalDeviceType -> Bool

max :: PhysicalDeviceType -> PhysicalDeviceType -> PhysicalDeviceType

min :: PhysicalDeviceType -> PhysicalDeviceType -> PhysicalDeviceType

Read PhysicalDeviceType

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Methods

readsPrec :: Int -> ReadS PhysicalDeviceType

readList :: ReadS [PhysicalDeviceType]

readPrec :: ReadPrec PhysicalDeviceType

readListPrec :: ReadPrec [PhysicalDeviceType]

Show PhysicalDeviceType

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Methods

showsPrec :: Int -> PhysicalDeviceType -> ShowS

show :: PhysicalDeviceType -> String

showList :: [PhysicalDeviceType] -> ShowS

Storable PhysicalDeviceType

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Methods

sizeOf :: PhysicalDeviceType -> Int

alignment :: PhysicalDeviceType -> Int

peekElemOff :: Ptr PhysicalDeviceType -> Int -> IO PhysicalDeviceType

pokeElemOff :: Ptr PhysicalDeviceType -> Int -> PhysicalDeviceType -> IO ()

peekByteOff :: Ptr b -> Int -> IO PhysicalDeviceType

pokeByteOff :: Ptr b -> Int -> PhysicalDeviceType -> IO ()

peek :: Ptr PhysicalDeviceType -> IO PhysicalDeviceType

poke :: Ptr PhysicalDeviceType -> PhysicalDeviceType -> IO ()

Zero PhysicalDeviceType

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Methods

zero :: PhysicalDeviceType

newtype Format

VkFormat - Available image formats

See Also

AccelerationStructureCreateGeometryTypeInfoKHR, AccelerationStructureGeometryTrianglesDataKHR, AndroidHardwareBufferFormatPropertiesANDROID, AttachmentDescription, AttachmentDescription2, BufferViewCreateInfo, FramebufferAttachmentImageInfo, GeometryTrianglesNV, ImageCreateInfo, ImageFormatListCreateInfo, ImageViewASTCDecodeModeEXT, ImageViewCreateInfo, PhysicalDeviceImageFormatInfo2, PhysicalDeviceSparseImageFormatInfo2, SamplerCustomBorderColorCreateInfoEXT, SamplerYcbcrConversionCreateInfo, SurfaceFormatKHR, SwapchainCreateInfoKHR, VertexInputAttributeDescription, getPhysicalDeviceExternalImageFormatPropertiesNV, getPhysicalDeviceFormatProperties, getPhysicalDeviceFormatProperties2, getPhysicalDeviceFormatProperties2KHR, getPhysicalDeviceImageFormatProperties, getPhysicalDeviceSparseImageFormatProperties

Constructors

Format Int32

Bundled Patterns

pattern FORMAT_UNDEFINED :: Format

FORMAT_UNDEFINED specifies that the format is not specified.

pattern FORMAT_R4G4_UNORM_PACK8 :: Format

FORMAT_R4G4_UNORM_PACK8 specifies a two-component, 8-bit packed unsigned normalized format that has a 4-bit R component in bits 4..7, and a 4-bit G component in bits 0..3.

pattern FORMAT_R4G4B4A4_UNORM_PACK16 :: Format

FORMAT_R4G4B4A4_UNORM_PACK16 specifies a four-component, 16-bit packed unsigned normalized format that has a 4-bit R component in bits 12..15, a 4-bit G component in bits 8..11, a 4-bit B component in bits 4..7, and a 4-bit A component in bits 0..3.

pattern FORMAT_B4G4R4A4_UNORM_PACK16 :: Format

FORMAT_B4G4R4A4_UNORM_PACK16 specifies a four-component, 16-bit packed unsigned normalized format that has a 4-bit B component in bits 12..15, a 4-bit G component in bits 8..11, a 4-bit R component in bits 4..7, and a 4-bit A component in bits 0..3.

pattern FORMAT_R5G6B5_UNORM_PACK16 :: Format

FORMAT_R5G6B5_UNORM_PACK16 specifies a three-component, 16-bit packed unsigned normalized format that has a 5-bit R component in bits 11..15, a 6-bit G component in bits 5..10, and a 5-bit B component in bits 0..4.

pattern FORMAT_B5G6R5_UNORM_PACK16 :: Format

FORMAT_B5G6R5_UNORM_PACK16 specifies a three-component, 16-bit packed unsigned normalized format that has a 5-bit B component in bits 11..15, a 6-bit G component in bits 5..10, and a 5-bit R component in bits 0..4.

pattern FORMAT_R5G5B5A1_UNORM_PACK16 :: Format

FORMAT_R5G5B5A1_UNORM_PACK16 specifies a four-component, 16-bit packed unsigned normalized format that has a 5-bit R component in bits 11..15, a 5-bit G component in bits 6..10, a 5-bit B component in bits 1..5, and a 1-bit A component in bit 0.

pattern FORMAT_B5G5R5A1_UNORM_PACK16 :: Format

FORMAT_B5G5R5A1_UNORM_PACK16 specifies a four-component, 16-bit packed unsigned normalized format that has a 5-bit B component in bits 11..15, a 5-bit G component in bits 6..10, a 5-bit R component in bits 1..5, and a 1-bit A component in bit 0.

pattern FORMAT_A1R5G5B5_UNORM_PACK16 :: Format

FORMAT_A1R5G5B5_UNORM_PACK16 specifies a four-component, 16-bit packed unsigned normalized format that has a 1-bit A component in bit 15, a 5-bit R component in bits 10..14, a 5-bit G component in bits 5..9, and a 5-bit B component in bits 0..4.

pattern FORMAT_R8_UNORM :: Format

FORMAT_R8_UNORM specifies a one-component, 8-bit unsigned normalized format that has a single 8-bit R component.

pattern FORMAT_R8_SNORM :: Format

FORMAT_R8_SNORM specifies a one-component, 8-bit signed normalized format that has a single 8-bit R component.

pattern FORMAT_R8_USCALED :: Format

FORMAT_R8_USCALED specifies a one-component, 8-bit unsigned scaled integer format that has a single 8-bit R component.

pattern FORMAT_R8_SSCALED :: Format

FORMAT_R8_SSCALED specifies a one-component, 8-bit signed scaled integer format that has a single 8-bit R component.

pattern FORMAT_R8_UINT :: Format

FORMAT_R8_UINT specifies a one-component, 8-bit unsigned integer format that has a single 8-bit R component.

pattern FORMAT_R8_SINT :: Format

FORMAT_R8_SINT specifies a one-component, 8-bit signed integer format that has a single 8-bit R component.

pattern FORMAT_R8_SRGB :: Format

FORMAT_R8_SRGB specifies a one-component, 8-bit unsigned normalized format that has a single 8-bit R component stored with sRGB nonlinear encoding.

pattern FORMAT_R8G8_UNORM :: Format

FORMAT_R8G8_UNORM specifies a two-component, 16-bit unsigned normalized format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

pattern FORMAT_R8G8_SNORM :: Format

FORMAT_R8G8_SNORM specifies a two-component, 16-bit signed normalized format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

pattern FORMAT_R8G8_USCALED :: Format

FORMAT_R8G8_USCALED specifies a two-component, 16-bit unsigned scaled integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

pattern FORMAT_R8G8_SSCALED :: Format

FORMAT_R8G8_SSCALED specifies a two-component, 16-bit signed scaled integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

pattern FORMAT_R8G8_UINT :: Format

FORMAT_R8G8_UINT specifies a two-component, 16-bit unsigned integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

pattern FORMAT_R8G8_SINT :: Format

FORMAT_R8G8_SINT specifies a two-component, 16-bit signed integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.

pattern FORMAT_R8G8_SRGB :: Format

FORMAT_R8G8_SRGB specifies a two-component, 16-bit unsigned normalized format that has an 8-bit R component stored with sRGB nonlinear encoding in byte 0, and an 8-bit G component stored with sRGB nonlinear encoding in byte 1.

pattern FORMAT_R8G8B8_UNORM :: Format

FORMAT_R8G8B8_UNORM specifies a three-component, 24-bit unsigned normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

pattern FORMAT_R8G8B8_SNORM :: Format

FORMAT_R8G8B8_SNORM specifies a three-component, 24-bit signed normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

pattern FORMAT_R8G8B8_USCALED :: Format

FORMAT_R8G8B8_USCALED specifies a three-component, 24-bit unsigned scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

pattern FORMAT_R8G8B8_SSCALED :: Format

FORMAT_R8G8B8_SSCALED specifies a three-component, 24-bit signed scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

pattern FORMAT_R8G8B8_UINT :: Format

FORMAT_R8G8B8_UINT specifies a three-component, 24-bit unsigned integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

pattern FORMAT_R8G8B8_SINT :: Format

FORMAT_R8G8B8_SINT specifies a three-component, 24-bit signed integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.

pattern FORMAT_R8G8B8_SRGB :: Format

FORMAT_R8G8B8_SRGB specifies a three-component, 24-bit unsigned normalized format that has an 8-bit R component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, and an 8-bit B component stored with sRGB nonlinear encoding in byte 2.

pattern FORMAT_B8G8R8_UNORM :: Format

FORMAT_B8G8R8_UNORM specifies a three-component, 24-bit unsigned normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

pattern FORMAT_B8G8R8_SNORM :: Format

FORMAT_B8G8R8_SNORM specifies a three-component, 24-bit signed normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

pattern FORMAT_B8G8R8_USCALED :: Format

FORMAT_B8G8R8_USCALED specifies a three-component, 24-bit unsigned scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

pattern FORMAT_B8G8R8_SSCALED :: Format

FORMAT_B8G8R8_SSCALED specifies a three-component, 24-bit signed scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

pattern FORMAT_B8G8R8_UINT :: Format

FORMAT_B8G8R8_UINT specifies a three-component, 24-bit unsigned integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

pattern FORMAT_B8G8R8_SINT :: Format

FORMAT_B8G8R8_SINT specifies a three-component, 24-bit signed integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.

pattern FORMAT_B8G8R8_SRGB :: Format

FORMAT_B8G8R8_SRGB specifies a three-component, 24-bit unsigned normalized format that has an 8-bit B component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, and an 8-bit R component stored with sRGB nonlinear encoding in byte 2.

pattern FORMAT_R8G8B8A8_UNORM :: Format

FORMAT_R8G8B8A8_UNORM specifies a four-component, 32-bit unsigned normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_R8G8B8A8_SNORM :: Format

FORMAT_R8G8B8A8_SNORM specifies a four-component, 32-bit signed normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_R8G8B8A8_USCALED :: Format

FORMAT_R8G8B8A8_USCALED specifies a four-component, 32-bit unsigned scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_R8G8B8A8_SSCALED :: Format

FORMAT_R8G8B8A8_SSCALED specifies a four-component, 32-bit signed scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_R8G8B8A8_UINT :: Format

FORMAT_R8G8B8A8_UINT specifies a four-component, 32-bit unsigned integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_R8G8B8A8_SINT :: Format

FORMAT_R8G8B8A8_SINT specifies a four-component, 32-bit signed integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_R8G8B8A8_SRGB :: Format

FORMAT_R8G8B8A8_SRGB specifies a four-component, 32-bit unsigned normalized format that has an 8-bit R component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, an 8-bit B component stored with sRGB nonlinear encoding in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_B8G8R8A8_UNORM :: Format

FORMAT_B8G8R8A8_UNORM specifies a four-component, 32-bit unsigned normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_B8G8R8A8_SNORM :: Format

FORMAT_B8G8R8A8_SNORM specifies a four-component, 32-bit signed normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_B8G8R8A8_USCALED :: Format

FORMAT_B8G8R8A8_USCALED specifies a four-component, 32-bit unsigned scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_B8G8R8A8_SSCALED :: Format

FORMAT_B8G8R8A8_SSCALED specifies a four-component, 32-bit signed scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_B8G8R8A8_UINT :: Format

FORMAT_B8G8R8A8_UINT specifies a four-component, 32-bit unsigned integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_B8G8R8A8_SINT :: Format

FORMAT_B8G8R8A8_SINT specifies a four-component, 32-bit signed integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_B8G8R8A8_SRGB :: Format

FORMAT_B8G8R8A8_SRGB specifies a four-component, 32-bit unsigned normalized format that has an 8-bit B component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, an 8-bit R component stored with sRGB nonlinear encoding in byte 2, and an 8-bit A component in byte 3.

pattern FORMAT_A8B8G8R8_UNORM_PACK32 :: Format

FORMAT_A8B8G8R8_UNORM_PACK32 specifies a four-component, 32-bit packed unsigned normalized format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

pattern FORMAT_A8B8G8R8_SNORM_PACK32 :: Format

FORMAT_A8B8G8R8_SNORM_PACK32 specifies a four-component, 32-bit packed signed normalized format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

pattern FORMAT_A8B8G8R8_USCALED_PACK32 :: Format

FORMAT_A8B8G8R8_USCALED_PACK32 specifies a four-component, 32-bit packed unsigned scaled integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

pattern FORMAT_A8B8G8R8_SSCALED_PACK32 :: Format

FORMAT_A8B8G8R8_SSCALED_PACK32 specifies a four-component, 32-bit packed signed scaled integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

pattern FORMAT_A8B8G8R8_UINT_PACK32 :: Format

FORMAT_A8B8G8R8_UINT_PACK32 specifies a four-component, 32-bit packed unsigned integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

pattern FORMAT_A8B8G8R8_SINT_PACK32 :: Format

FORMAT_A8B8G8R8_SINT_PACK32 specifies a four-component, 32-bit packed signed integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.

pattern FORMAT_A8B8G8R8_SRGB_PACK32 :: Format

FORMAT_A8B8G8R8_SRGB_PACK32 specifies a four-component, 32-bit packed unsigned normalized format that has an 8-bit A component in bits 24..31, an 8-bit B component stored with sRGB nonlinear encoding in bits 16..23, an 8-bit G component stored with sRGB nonlinear encoding in bits 8..15, and an 8-bit R component stored with sRGB nonlinear encoding in bits 0..7.

pattern FORMAT_A2R10G10B10_UNORM_PACK32 :: Format

FORMAT_A2R10G10B10_UNORM_PACK32 specifies a four-component, 32-bit packed unsigned normalized format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

pattern FORMAT_A2R10G10B10_SNORM_PACK32 :: Format

FORMAT_A2R10G10B10_SNORM_PACK32 specifies a four-component, 32-bit packed signed normalized format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

pattern FORMAT_A2R10G10B10_USCALED_PACK32 :: Format

FORMAT_A2R10G10B10_USCALED_PACK32 specifies a four-component, 32-bit packed unsigned scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

pattern FORMAT_A2R10G10B10_SSCALED_PACK32 :: Format

FORMAT_A2R10G10B10_SSCALED_PACK32 specifies a four-component, 32-bit packed signed scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

pattern FORMAT_A2R10G10B10_UINT_PACK32 :: Format

FORMAT_A2R10G10B10_UINT_PACK32 specifies a four-component, 32-bit packed unsigned integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

pattern FORMAT_A2R10G10B10_SINT_PACK32 :: Format

FORMAT_A2R10G10B10_SINT_PACK32 specifies a four-component, 32-bit packed signed integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.

pattern FORMAT_A2B10G10R10_UNORM_PACK32 :: Format

FORMAT_A2B10G10R10_UNORM_PACK32 specifies a four-component, 32-bit packed unsigned normalized format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

pattern FORMAT_A2B10G10R10_SNORM_PACK32 :: Format

FORMAT_A2B10G10R10_SNORM_PACK32 specifies a four-component, 32-bit packed signed normalized format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

pattern FORMAT_A2B10G10R10_USCALED_PACK32 :: Format

FORMAT_A2B10G10R10_USCALED_PACK32 specifies a four-component, 32-bit packed unsigned scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

pattern FORMAT_A2B10G10R10_SSCALED_PACK32 :: Format

FORMAT_A2B10G10R10_SSCALED_PACK32 specifies a four-component, 32-bit packed signed scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

pattern FORMAT_A2B10G10R10_UINT_PACK32 :: Format

FORMAT_A2B10G10R10_UINT_PACK32 specifies a four-component, 32-bit packed unsigned integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

pattern FORMAT_A2B10G10R10_SINT_PACK32 :: Format

FORMAT_A2B10G10R10_SINT_PACK32 specifies a four-component, 32-bit packed signed integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.

pattern FORMAT_R16_UNORM :: Format

FORMAT_R16_UNORM specifies a one-component, 16-bit unsigned normalized format that has a single 16-bit R component.

pattern FORMAT_R16_SNORM :: Format

FORMAT_R16_SNORM specifies a one-component, 16-bit signed normalized format that has a single 16-bit R component.

pattern FORMAT_R16_USCALED :: Format

FORMAT_R16_USCALED specifies a one-component, 16-bit unsigned scaled integer format that has a single 16-bit R component.

pattern FORMAT_R16_SSCALED :: Format

FORMAT_R16_SSCALED specifies a one-component, 16-bit signed scaled integer format that has a single 16-bit R component.

pattern FORMAT_R16_UINT :: Format

FORMAT_R16_UINT specifies a one-component, 16-bit unsigned integer format that has a single 16-bit R component.

pattern FORMAT_R16_SINT :: Format

FORMAT_R16_SINT specifies a one-component, 16-bit signed integer format that has a single 16-bit R component.

pattern FORMAT_R16_SFLOAT :: Format

FORMAT_R16_SFLOAT specifies a one-component, 16-bit signed floating-point format that has a single 16-bit R component.

pattern FORMAT_R16G16_UNORM :: Format

FORMAT_R16G16_UNORM specifies a two-component, 32-bit unsigned normalized format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

pattern FORMAT_R16G16_SNORM :: Format

FORMAT_R16G16_SNORM specifies a two-component, 32-bit signed normalized format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

pattern FORMAT_R16G16_USCALED :: Format

FORMAT_R16G16_USCALED specifies a two-component, 32-bit unsigned scaled integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

pattern FORMAT_R16G16_SSCALED :: Format

FORMAT_R16G16_SSCALED specifies a two-component, 32-bit signed scaled integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

pattern FORMAT_R16G16_UINT :: Format

FORMAT_R16G16_UINT specifies a two-component, 32-bit unsigned integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

pattern FORMAT_R16G16_SINT :: Format

FORMAT_R16G16_SINT specifies a two-component, 32-bit signed integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

pattern FORMAT_R16G16_SFLOAT :: Format

FORMAT_R16G16_SFLOAT specifies a two-component, 32-bit signed floating-point format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.

pattern FORMAT_R16G16B16_UNORM :: Format

FORMAT_R16G16B16_UNORM specifies a three-component, 48-bit unsigned normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

pattern FORMAT_R16G16B16_SNORM :: Format

FORMAT_R16G16B16_SNORM specifies a three-component, 48-bit signed normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

pattern FORMAT_R16G16B16_USCALED :: Format

FORMAT_R16G16B16_USCALED specifies a three-component, 48-bit unsigned scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

pattern FORMAT_R16G16B16_SSCALED :: Format

FORMAT_R16G16B16_SSCALED specifies a three-component, 48-bit signed scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

pattern FORMAT_R16G16B16_UINT :: Format

FORMAT_R16G16B16_UINT specifies a three-component, 48-bit unsigned integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

pattern FORMAT_R16G16B16_SINT :: Format

FORMAT_R16G16B16_SINT specifies a three-component, 48-bit signed integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

pattern FORMAT_R16G16B16_SFLOAT :: Format

FORMAT_R16G16B16_SFLOAT specifies a three-component, 48-bit signed floating-point format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.

pattern FORMAT_R16G16B16A16_UNORM :: Format

FORMAT_R16G16B16A16_UNORM specifies a four-component, 64-bit unsigned normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

pattern FORMAT_R16G16B16A16_SNORM :: Format

FORMAT_R16G16B16A16_SNORM specifies a four-component, 64-bit signed normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

pattern FORMAT_R16G16B16A16_USCALED :: Format

FORMAT_R16G16B16A16_USCALED specifies a four-component, 64-bit unsigned scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

pattern FORMAT_R16G16B16A16_SSCALED :: Format

FORMAT_R16G16B16A16_SSCALED specifies a four-component, 64-bit signed scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

pattern FORMAT_R16G16B16A16_UINT :: Format

FORMAT_R16G16B16A16_UINT specifies a four-component, 64-bit unsigned integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

pattern FORMAT_R16G16B16A16_SINT :: Format

FORMAT_R16G16B16A16_SINT specifies a four-component, 64-bit signed integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

pattern FORMAT_R16G16B16A16_SFLOAT :: Format

FORMAT_R16G16B16A16_SFLOAT specifies a four-component, 64-bit signed floating-point format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.

pattern FORMAT_R32_UINT :: Format

FORMAT_R32_UINT specifies a one-component, 32-bit unsigned integer format that has a single 32-bit R component.

pattern FORMAT_R32_SINT :: Format

FORMAT_R32_SINT specifies a one-component, 32-bit signed integer format that has a single 32-bit R component.

pattern FORMAT_R32_SFLOAT :: Format

FORMAT_R32_SFLOAT specifies a one-component, 32-bit signed floating-point format that has a single 32-bit R component.

pattern FORMAT_R32G32_UINT :: Format

FORMAT_R32G32_UINT specifies a two-component, 64-bit unsigned integer format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7.

pattern FORMAT_R32G32_SINT :: Format

FORMAT_R32G32_SINT specifies a two-component, 64-bit signed integer format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7.

pattern FORMAT_R32G32_SFLOAT :: Format

FORMAT_R32G32_SFLOAT specifies a two-component, 64-bit signed floating-point format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7.

pattern FORMAT_R32G32B32_UINT :: Format

FORMAT_R32G32B32_UINT specifies a three-component, 96-bit unsigned integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11.

pattern FORMAT_R32G32B32_SINT :: Format

FORMAT_R32G32B32_SINT specifies a three-component, 96-bit signed integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11.

pattern FORMAT_R32G32B32_SFLOAT :: Format

FORMAT_R32G32B32_SFLOAT specifies a three-component, 96-bit signed floating-point format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11.

pattern FORMAT_R32G32B32A32_UINT :: Format

FORMAT_R32G32B32A32_UINT specifies a four-component, 128-bit unsigned integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B component in bytes 8..11, and a 32-bit A component in bytes 12..15.

pattern FORMAT_R32G32B32A32_SINT :: Format

FORMAT_R32G32B32A32_SINT specifies a four-component, 128-bit signed integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B component in bytes 8..11, and a 32-bit A component in bytes 12..15.

pattern FORMAT_R32G32B32A32_SFLOAT :: Format

FORMAT_R32G32B32A32_SFLOAT specifies a four-component, 128-bit signed floating-point format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B component in bytes 8..11, and a 32-bit A component in bytes 12..15.

pattern FORMAT_R64_UINT :: Format

FORMAT_R64_UINT specifies a one-component, 64-bit unsigned integer format that has a single 64-bit R component.

pattern FORMAT_R64_SINT :: Format

FORMAT_R64_SINT specifies a one-component, 64-bit signed integer format that has a single 64-bit R component.

pattern FORMAT_R64_SFLOAT :: Format

FORMAT_R64_SFLOAT specifies a one-component, 64-bit signed floating-point format that has a single 64-bit R component.

pattern FORMAT_R64G64_UINT :: Format

FORMAT_R64G64_UINT specifies a two-component, 128-bit unsigned integer format that has a 64-bit R component in bytes 0..7, and a 64-bit G component in bytes 8..15.

pattern FORMAT_R64G64_SINT :: Format

FORMAT_R64G64_SINT specifies a two-component, 128-bit signed integer format that has a 64-bit R component in bytes 0..7, and a 64-bit G component in bytes 8..15.

pattern FORMAT_R64G64_SFLOAT :: Format

FORMAT_R64G64_SFLOAT specifies a two-component, 128-bit signed floating-point format that has a 64-bit R component in bytes 0..7, and a 64-bit G component in bytes 8..15.

pattern FORMAT_R64G64B64_UINT :: Format

FORMAT_R64G64B64_UINT specifies a three-component, 192-bit unsigned integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, and a 64-bit B component in bytes 16..23.

pattern FORMAT_R64G64B64_SINT :: Format

FORMAT_R64G64B64_SINT specifies a three-component, 192-bit signed integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, and a 64-bit B component in bytes 16..23.

pattern FORMAT_R64G64B64_SFLOAT :: Format

FORMAT_R64G64B64_SFLOAT specifies a three-component, 192-bit signed floating-point format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, and a 64-bit B component in bytes 16..23.

pattern FORMAT_R64G64B64A64_UINT :: Format

FORMAT_R64G64B64A64_UINT specifies a four-component, 256-bit unsigned integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B component in bytes 16..23, and a 64-bit A component in bytes 24..31.

pattern FORMAT_R64G64B64A64_SINT :: Format

FORMAT_R64G64B64A64_SINT specifies a four-component, 256-bit signed integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B component in bytes 16..23, and a 64-bit A component in bytes 24..31.

pattern FORMAT_R64G64B64A64_SFLOAT :: Format

FORMAT_R64G64B64A64_SFLOAT specifies a four-component, 256-bit signed floating-point format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B component in bytes 16..23, and a 64-bit A component in bytes 24..31.

pattern FORMAT_B10G11R11_UFLOAT_PACK32 :: Format

FORMAT_B10G11R11_UFLOAT_PACK32 specifies a three-component, 32-bit packed unsigned floating-point format that has a 10-bit B component in bits 22..31, an 11-bit G component in bits 11..21, an 11-bit R component in bits 0..10. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-fp10 and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-fp11.

pattern FORMAT_E5B9G9R9_UFLOAT_PACK32 :: Format

FORMAT_E5B9G9R9_UFLOAT_PACK32 specifies a three-component, 32-bit packed unsigned floating-point format that has a 5-bit shared exponent in bits 27..31, a 9-bit B component mantissa in bits 18..26, a 9-bit G component mantissa in bits 9..17, and a 9-bit R component mantissa in bits 0..8.

pattern FORMAT_D16_UNORM :: Format

FORMAT_D16_UNORM specifies a one-component, 16-bit unsigned normalized format that has a single 16-bit depth component.

pattern FORMAT_X8_D24_UNORM_PACK32 :: Format

FORMAT_X8_D24_UNORM_PACK32 specifies a two-component, 32-bit format that has 24 unsigned normalized bits in the depth component and, optionally:, 8 bits that are unused.

pattern FORMAT_D32_SFLOAT :: Format

FORMAT_D32_SFLOAT specifies a one-component, 32-bit signed floating-point format that has 32-bits in the depth component.

pattern FORMAT_S8_UINT :: Format

FORMAT_S8_UINT specifies a one-component, 8-bit unsigned integer format that has 8-bits in the stencil component.

pattern FORMAT_D16_UNORM_S8_UINT :: Format

FORMAT_D16_UNORM_S8_UINT specifies a two-component, 24-bit format that has 16 unsigned normalized bits in the depth component and 8 unsigned integer bits in the stencil component.

pattern FORMAT_D24_UNORM_S8_UINT :: Format

FORMAT_D24_UNORM_S8_UINT specifies a two-component, 32-bit packed format that has 8 unsigned integer bits in the stencil component, and 24 unsigned normalized bits in the depth component.

pattern FORMAT_D32_SFLOAT_S8_UINT :: Format

FORMAT_D32_SFLOAT_S8_UINT specifies a two-component format that has 32 signed float bits in the depth component and 8 unsigned integer bits in the stencil component. There are optionally: 24-bits that are unused.

pattern FORMAT_BC1_RGB_UNORM_BLOCK :: Format

FORMAT_BC1_RGB_UNORM_BLOCK specifies a three-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data. This format has no alpha and is considered opaque.

pattern FORMAT_BC1_RGB_SRGB_BLOCK :: Format

FORMAT_BC1_RGB_SRGB_BLOCK specifies a three-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding. This format has no alpha and is considered opaque.

pattern FORMAT_BC1_RGBA_UNORM_BLOCK :: Format

FORMAT_BC1_RGBA_UNORM_BLOCK specifies a four-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data, and provides 1 bit of alpha.

pattern FORMAT_BC1_RGBA_SRGB_BLOCK :: Format

FORMAT_BC1_RGBA_SRGB_BLOCK specifies a four-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding, and provides 1 bit of alpha.

pattern FORMAT_BC2_UNORM_BLOCK :: Format

FORMAT_BC2_UNORM_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values.

pattern FORMAT_BC2_SRGB_BLOCK :: Format

FORMAT_BC2_SRGB_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values with sRGB nonlinear encoding.

pattern FORMAT_BC3_UNORM_BLOCK :: Format

FORMAT_BC3_UNORM_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values.

pattern FORMAT_BC3_SRGB_BLOCK :: Format

FORMAT_BC3_SRGB_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values with sRGB nonlinear encoding.

pattern FORMAT_BC4_UNORM_BLOCK :: Format

FORMAT_BC4_UNORM_BLOCK specifies a one-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized red texel data.

pattern FORMAT_BC4_SNORM_BLOCK :: Format

FORMAT_BC4_SNORM_BLOCK specifies a one-component, block-compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of signed normalized red texel data.

pattern FORMAT_BC5_UNORM_BLOCK :: Format

FORMAT_BC5_UNORM_BLOCK specifies a two-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.

pattern FORMAT_BC5_SNORM_BLOCK :: Format

FORMAT_BC5_SNORM_BLOCK specifies a two-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of signed normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.

pattern FORMAT_BC6H_UFLOAT_BLOCK :: Format

FORMAT_BC6H_UFLOAT_BLOCK specifies a three-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned floating-point RGB texel data.

pattern FORMAT_BC6H_SFLOAT_BLOCK :: Format

FORMAT_BC6H_SFLOAT_BLOCK specifies a three-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of signed floating-point RGB texel data.

pattern FORMAT_BC7_UNORM_BLOCK :: Format

FORMAT_BC7_UNORM_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_BC7_SRGB_BLOCK :: Format

FORMAT_BC7_SRGB_BLOCK specifies a four-component, block-compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ETC2_R8G8B8_UNORM_BLOCK :: Format

FORMAT_ETC2_R8G8B8_UNORM_BLOCK specifies a three-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data. This format has no alpha and is considered opaque.

pattern FORMAT_ETC2_R8G8B8_SRGB_BLOCK :: Format

FORMAT_ETC2_R8G8B8_SRGB_BLOCK specifies a three-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding. This format has no alpha and is considered opaque.

pattern FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK :: Format

FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK specifies a four-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data, and provides 1 bit of alpha.

pattern FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK :: Format

FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK specifies a four-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGB texel data with sRGB nonlinear encoding, and provides 1 bit of alpha.

pattern FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK :: Format

FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK specifies a four-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values.

pattern FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK :: Format

FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK specifies a four-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with the first 64 bits encoding alpha values followed by 64 bits encoding RGB values with sRGB nonlinear encoding applied.

pattern FORMAT_EAC_R11_UNORM_BLOCK :: Format

FORMAT_EAC_R11_UNORM_BLOCK specifies a one-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized red texel data.

pattern FORMAT_EAC_R11_SNORM_BLOCK :: Format

FORMAT_EAC_R11_SNORM_BLOCK specifies a one-component, ETC2 compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of signed normalized red texel data.

pattern FORMAT_EAC_R11G11_UNORM_BLOCK :: Format

FORMAT_EAC_R11G11_UNORM_BLOCK specifies a two-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.

pattern FORMAT_EAC_R11G11_SNORM_BLOCK :: Format

FORMAT_EAC_R11G11_SNORM_BLOCK specifies a two-component, ETC2 compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of signed normalized RG texel data with the first 64 bits encoding red values followed by 64 bits encoding green values.

pattern FORMAT_ASTC_4x4_UNORM_BLOCK :: Format

FORMAT_ASTC_4x4_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_4x4_SRGB_BLOCK :: Format

FORMAT_ASTC_4x4_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_5x4_UNORM_BLOCK :: Format

FORMAT_ASTC_5x4_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×4 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_5x4_SRGB_BLOCK :: Format

FORMAT_ASTC_5x4_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_5x5_UNORM_BLOCK :: Format

FORMAT_ASTC_5x5_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×5 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_5x5_SRGB_BLOCK :: Format

FORMAT_ASTC_5x5_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_6x5_UNORM_BLOCK :: Format

FORMAT_ASTC_6x5_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×5 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_6x5_SRGB_BLOCK :: Format

FORMAT_ASTC_6x5_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_6x6_UNORM_BLOCK :: Format

FORMAT_ASTC_6x6_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×6 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_6x6_SRGB_BLOCK :: Format

FORMAT_ASTC_6x6_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×6 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_8x5_UNORM_BLOCK :: Format

FORMAT_ASTC_8x5_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×5 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_8x5_SRGB_BLOCK :: Format

FORMAT_ASTC_8x5_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_8x6_UNORM_BLOCK :: Format

FORMAT_ASTC_8x6_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×6 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_8x6_SRGB_BLOCK :: Format

FORMAT_ASTC_8x6_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×6 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_8x8_UNORM_BLOCK :: Format

FORMAT_ASTC_8x8_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×8 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_8x8_SRGB_BLOCK :: Format

FORMAT_ASTC_8x8_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes an 8×8 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_10x5_UNORM_BLOCK :: Format

FORMAT_ASTC_10x5_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×5 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_10x5_SRGB_BLOCK :: Format

FORMAT_ASTC_10x5_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×5 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_10x6_UNORM_BLOCK :: Format

FORMAT_ASTC_10x6_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×6 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_10x6_SRGB_BLOCK :: Format

FORMAT_ASTC_10x6_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×6 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_10x8_UNORM_BLOCK :: Format

FORMAT_ASTC_10x8_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×8 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_10x8_SRGB_BLOCK :: Format

FORMAT_ASTC_10x8_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×8 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_10x10_UNORM_BLOCK :: Format

FORMAT_ASTC_10x10_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×10 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_10x10_SRGB_BLOCK :: Format

FORMAT_ASTC_10x10_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×10 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_12x10_UNORM_BLOCK :: Format

FORMAT_ASTC_12x10_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×10 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_12x10_SRGB_BLOCK :: Format

FORMAT_ASTC_12x10_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×10 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_ASTC_12x12_UNORM_BLOCK :: Format

FORMAT_ASTC_12x12_UNORM_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×12 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_ASTC_12x12_SRGB_BLOCK :: Format

FORMAT_ASTC_12x12_SRGB_BLOCK specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×12 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_A4B4G4R4_UNORM_PACK16_EXT :: Format

FORMAT_A4B4G4R4_UNORM_PACK16_EXT specifies a four-component, 16-bit packed unsigned normalized format that has a 4-bit A component in bits 12..15, a 4-bit B component in bits 8..11, a 4-bit G component in bits 4..7, and a 4-bit R component in bits 0..3.

pattern FORMAT_A4R4G4B4_UNORM_PACK16_EXT :: Format

FORMAT_A4R4G4B4_UNORM_PACK16_EXT specifies a four-component, 16-bit packed unsigned normalized format that has a 4-bit A component in bits 12..15, a 4-bit R component in bits 8..11, a 4-bit G component in bits 4..7, and a 4-bit B component in bits 0..3.

pattern FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×12 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 12×10 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×10 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×8 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×6 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 10×5 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 8×8 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 8×6 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 8×5 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×6 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 6×5 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×5 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 5×4 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT :: Format

FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT specifies a four-component, ASTC compressed format where each 128-bit compressed texel block encodes a 4×4 rectangle of signed floating-point RGBA texel data.

pattern FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG :: Format

FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG :: Format

FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes an 8×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG :: Format

FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG :: Format

FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes an 8×4 rectangle of unsigned normalized RGBA texel data with sRGB nonlinear encoding applied to the RGB components.

pattern FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG :: Format

FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG :: Format

FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes an 8×4 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG :: Format

FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes a 4×4 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG :: Format

FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG specifies a four-component, PVRTC compressed format where each 64-bit compressed texel block encodes an 8×4 rectangle of unsigned normalized RGBA texel data.

pattern FORMAT_G16_B16_R16_3PLANE_444_UNORM :: Format

FORMAT_G16_B16_R16_3PLANE_444_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, a 16-bit B component in each 16-bit word of plane 1, and a 16-bit R component in each 16-bit word of plane 2. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane.

pattern FORMAT_G16_B16R16_2PLANE_422_UNORM :: Format

FORMAT_G16_B16R16_2PLANE_422_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 16-bit B component in the word in bytes 0..1, and a 16-bit R component in the word in bytes 2..3. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, and IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.

pattern FORMAT_G16_B16_R16_3PLANE_422_UNORM :: Format

FORMAT_G16_B16_R16_3PLANE_422_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, a 16-bit B component in each 16-bit word of plane 1, and a 16-bit R component in each 16-bit word of plane 2. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.

pattern FORMAT_G16_B16R16_2PLANE_420_UNORM :: Format

FORMAT_G16_B16R16_2PLANE_420_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 16-bit B component in the word in bytes 0..1, and a 16-bit R component in the word in bytes 2..3. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R) and (leftlfloor j_G times 0.5 rightrfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, and IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern FORMAT_G16_B16_R16_3PLANE_420_UNORM :: Format

FORMAT_G16_B16_R16_3PLANE_420_UNORM specifies an unsigned normalized multi-planar format that has a 16-bit G component in each 16-bit word of plane 0, a 16-bit B component in each 16-bit word of plane 1, and a 16-bit R component in each 16-bit word of plane 2. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R) and (leftlfloor j_G times 0.5 rightrfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern FORMAT_B16G16R16G16_422_UNORM :: Format

FORMAT_B16G16R16G16_422_UNORM specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 16-bit B component in the word in bytes 0..1, a 16-bit G component for the even i coordinate in the word in bytes 2..3, a 16-bit R component in the word in bytes 4..5, and a 16-bit G component for the odd i coordinate in the word in bytes 6..7. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern FORMAT_G16B16G16R16_422_UNORM :: Format

FORMAT_G16B16G16R16_422_UNORM specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 16-bit G component for the even i coordinate in the word in bytes 0..1, a 16-bit B component in the word in bytes 2..3, a 16-bit G component for the odd i coordinate in the word in bytes 4..5, and a 16-bit R component in the word in bytes 6..7. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 :: Format

FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, a 12-bit B component in the top 12 bits of each 16-bit word of plane 1, and a 12-bit R component in the top 12 bits of each 16-bit word of plane 2, with the bottom 4 bits of each word unused. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane.

pattern FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 :: Format

FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 12-bit B component in the top 12 bits of the word in bytes 0..1, and a 12-bit R component in the top 12 bits of the word in bytes 2..3, the bottom 4 bits of each word unused. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, and IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.

pattern FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 :: Format

FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, a 12-bit B component in the top 12 bits of each 16-bit word of plane 1, and a 12-bit R component in the top 12 bits of each 16-bit word of plane 2, with the bottom 4 bits of each word unused. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.

pattern FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 :: Format

FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 12-bit B component in the top 12 bits of the word in bytes 0..1, and a 12-bit R component in the top 12 bits of the word in bytes 2..3, the bottom 4 bits of each word unused. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R) and (leftlfloor j_G times 0.5 rightrfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, and IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 :: Format

FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 12-bit G component in the top 12 bits of each 16-bit word of plane 0, a 12-bit B component in the top 12 bits of each 16-bit word of plane 1, and a 12-bit R component in the top 12 bits of each 16-bit word of plane 2, with the bottom 4 bits of each word unused. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R) and (leftlfloor j_G times 0.5 rightrfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 :: Format

FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 12-bit B component in the top 12 bits of the word in bytes 0..1, a 12-bit G component for the even i coordinate in the top 12 bits of the word in bytes 2..3, a 12-bit R component in the top 12 bits of the word in bytes 4..5, and a 12-bit G component for the odd i coordinate in the top 12 bits of the word in bytes 6..7, with the bottom 4 bits of each word unused. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 :: Format

FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 12-bit G component for the even i coordinate in the top 12 bits of the word in bytes 0..1, a 12-bit B component in the top 12 bits of the word in bytes 2..3, a 12-bit G component for the odd i coordinate in the top 12 bits of the word in bytes 4..5, and a 12-bit R component in the top 12 bits of the word in bytes 6..7, with the bottom 4 bits of each word unused. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 :: Format

FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 specifies a four-component, 64-bit unsigned normalized format that has a 12-bit R component in the top 12 bits of the word in bytes 0..1, a 12-bit G component in the top 12 bits of the word in bytes 2..3, a 12-bit B component in the top 12 bits of the word in bytes 4..5, and a 12-bit A component in the top 12 bits of the word in bytes 6..7, with the bottom 4 bits of each word unused.

pattern FORMAT_R12X4G12X4_UNORM_2PACK16 :: Format

FORMAT_R12X4G12X4_UNORM_2PACK16 specifies a two-component, 32-bit unsigned normalized format that has a 12-bit R component in the top 12 bits of the word in bytes 0..1, and a 12-bit G component in the top 12 bits of the word in bytes 2..3, with the bottom 4 bits of each word unused.

pattern FORMAT_R12X4_UNORM_PACK16 :: Format

FORMAT_R12X4_UNORM_PACK16 specifies a one-component, 16-bit unsigned normalized format that has a single 12-bit R component in the top 12 bits of a 16-bit word, with the bottom 4 bits unused.

pattern FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 :: Format

FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, a 10-bit B component in the top 10 bits of each 16-bit word of plane 1, and a 10-bit R component in the top 10 bits of each 16-bit word of plane 2, with the bottom 6 bits of each word unused. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane.

pattern FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 :: Format

FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 10-bit B component in the top 10 bits of the word in bytes 0..1, and a 10-bit R component in the top 10 bits of the word in bytes 2..3, the bottom 6 bits of each word unused. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, and IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.

pattern FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 :: Format

FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, a 10-bit B component in the top 10 bits of each 16-bit word of plane 1, and a 10-bit R component in the top 10 bits of each 16-bit word of plane 2, with the bottom 6 bits of each word unused. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.

pattern FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 :: Format

FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, and a two-component, 32-bit BR plane 1 consisting of a 10-bit B component in the top 10 bits of the word in bytes 0..1, and a 10-bit R component in the top 10 bits of the word in bytes 2..3, the bottom 6 bits of each word unused. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R) and (leftlfloor j_G times 0.5 rightrfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, and IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 :: Format

FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 specifies an unsigned normalized multi-planar format that has a 10-bit G component in the top 10 bits of each 16-bit word of plane 0, a 10-bit B component in the top 10 bits of each 16-bit word of plane 1, and a 10-bit R component in the top 10 bits of each 16-bit word of plane 2, with the bottom 6 bits of each word unused. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R) and (leftlfloor j_G times 0.5 rightrfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 :: Format

FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 10-bit B component in the top 10 bits of the word in bytes 0..1, a 10-bit G component for the even i coordinate in the top 10 bits of the word in bytes 2..3, a 10-bit R component in the top 10 bits of the word in bytes 4..5, and a 10-bit G component for the odd i coordinate in the top 10 bits of the word in bytes 6..7, with the bottom 6 bits of each word unused. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 :: Format

FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 specifies a four-component, 64-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has a 10-bit G component for the even i coordinate in the top 10 bits of the word in bytes 0..1, a 10-bit B component in the top 10 bits of the word in bytes 2..3, a 10-bit G component for the odd i coordinate in the top 10 bits of the word in bytes 4..5, and a 10-bit R component in the top 10 bits of the word in bytes 6..7, with the bottom 6 bits of each word unused. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 :: Format

FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 specifies a four-component, 64-bit unsigned normalized format that has a 10-bit R component in the top 10 bits of the word in bytes 0..1, a 10-bit G component in the top 10 bits of the word in bytes 2..3, a 10-bit B component in the top 10 bits of the word in bytes 4..5, and a 10-bit A component in the top 10 bits of the word in bytes 6..7, with the bottom 6 bits of each word unused.

pattern FORMAT_R10X6G10X6_UNORM_2PACK16 :: Format

FORMAT_R10X6G10X6_UNORM_2PACK16 specifies a two-component, 32-bit unsigned normalized format that has a 10-bit R component in the top 10 bits of the word in bytes 0..1, and a 10-bit G component in the top 10 bits of the word in bytes 2..3, with the bottom 6 bits of each word unused.

pattern FORMAT_R10X6_UNORM_PACK16 :: Format

FORMAT_R10X6_UNORM_PACK16 specifies a one-component, 16-bit unsigned normalized format that has a single 10-bit R component in the top 10 bits of a 16-bit word, with the bottom 6 bits unused.

pattern FORMAT_G8_B8_R8_3PLANE_444_UNORM :: Format

FORMAT_G8_B8_R8_3PLANE_444_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, an 8-bit B component in plane 1, and an 8-bit R component in plane 2. Each plane has the same dimensions and each R, G and B component contributes to a single texel. The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane.

pattern FORMAT_G8_B8R8_2PLANE_422_UNORM :: Format

FORMAT_G8_B8R8_2PLANE_422_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, and a two-component, 16-bit BR plane 1 consisting of an 8-bit B component in byte 0 and an 8-bit R component in byte 1. The horizontal dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, and IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width that is a multiple of two.

pattern FORMAT_G8_B8_R8_3PLANE_422_UNORM :: Format

FORMAT_G8_B8_R8_3PLANE_422_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, an 8-bit B component in plane 1, and an 8-bit R component in plane 2. The horizontal dimension of the R and B plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width that is a multiple of two.

pattern FORMAT_G8_B8R8_2PLANE_420_UNORM :: Format

FORMAT_G8_B8R8_2PLANE_420_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, and a two-component, 16-bit BR plane 1 consisting of an 8-bit B component in byte 0 and an 8-bit R component in byte 1. The horizontal and vertical dimensions of the BR plane is halved relative to the image dimensions, and each R and B value is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R) and (leftlfloor j_G times 0.5 rightrfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, and IMAGE_ASPECT_PLANE_1_BIT for the BR plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern FORMAT_G8_B8_R8_3PLANE_420_UNORM :: Format

FORMAT_G8_B8_R8_3PLANE_420_UNORM specifies an unsigned normalized multi-planar format that has an 8-bit G component in plane 0, an 8-bit B component in plane 1, and an 8-bit R component in plane 2. The horizontal and vertical dimensions of the R and B planes are halved relative to the image dimensions, and each R and B component is shared with the G components for which (leftlfloor i_G times 0.5 rightrfloor = i_B = i_R) and (leftlfloor j_G times 0.5 rightrfloor = j_B = j_R). The location of each plane when this image is in linear layout can be determined via getImageSubresourceLayout, using IMAGE_ASPECT_PLANE_0_BIT for the G plane, IMAGE_ASPECT_PLANE_1_BIT for the B plane, and IMAGE_ASPECT_PLANE_2_BIT for the R plane. Images in this format must be defined with a width and height that is a multiple of two.

pattern FORMAT_B8G8R8G8_422_UNORM :: Format

FORMAT_B8G8R8G8_422_UNORM specifies a four-component, 32-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has an 8-bit B component in byte 0, an 8-bit G component for the even i coordinate in byte 1, an 8-bit R component in byte 2, and an 8-bit G component for the odd i coordinate in byte 3. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

pattern FORMAT_G8B8G8R8_422_UNORM :: Format

FORMAT_G8B8G8R8_422_UNORM specifies a four-component, 32-bit format containing a pair of G components, an R component, and a B component, collectively encoding a 2×1 rectangle of unsigned normalized RGB texel data. One G value is present at each i coordinate, with the B and R values shared across both G values and thus recorded at half the horizontal resolution of the image. This format has an 8-bit G component for the even i coordinate in byte 0, an 8-bit B component in byte 1, an 8-bit G component for the odd i coordinate in byte 2, and an 8-bit R component in byte 3. Images in this format must be defined with a width that is a multiple of two. For the purposes of the constraints on copy extents, this format is treated as a compressed format with a 2×1 compressed texel block.

Instances

Eq Format

Defined in Vulkan.Core10.Enums.Format

Methods

(==) :: Format -> Format -> Bool

(/=) :: Format -> Format -> Bool

Ord Format

Defined in Vulkan.Core10.Enums.Format

Methods

compare :: Format -> Format -> Ordering

(<) :: Format -> Format -> Bool

(<=) :: Format -> Format -> Bool

(>) :: Format -> Format -> Bool

(>=) :: Format -> Format -> Bool

max :: Format -> Format -> Format

min :: Format -> Format -> Format

Read Format

Defined in Vulkan.Core10.Enums.Format

Methods

readsPrec :: Int -> ReadS Format

readList :: ReadS [Format]

readPrec :: ReadPrec Format

readListPrec :: ReadPrec [Format]

Show Format

Defined in Vulkan.Core10.Enums.Format

Methods

showsPrec :: Int -> Format -> ShowS

show :: Format -> String

showList :: [Format] -> ShowS

Storable Format

Defined in Vulkan.Core10.Enums.Format

Methods

sizeOf :: Format -> Int

alignment :: Format -> Int

peekElemOff :: Ptr Format -> Int -> IO Format

pokeElemOff :: Ptr Format -> Int -> Format -> IO ()

peekByteOff :: Ptr b -> Int -> IO Format

pokeByteOff :: Ptr b -> Int -> Format -> IO ()

peek :: Ptr Format -> IO Format

poke :: Ptr Format -> Format -> IO ()

Zero Format

Defined in Vulkan.Core10.Enums.Format

Methods

zero :: Format

newtype StructureType

VkStructureType - Vulkan structure types (sType)

Description

Each value corresponds to a particular structure with a sType member with a matching name. As a general rule, the name of each StructureType value is obtained by taking the name of the structure, stripping the leading Vk, prefixing each capital letter with _, converting the entire resulting string to upper case, and prefixing it with VK_STRUCTURE_TYPE_. For example, structures of type ImageCreateInfo correspond to a StructureType of STRUCTURE_TYPE_IMAGE_CREATE_INFO, and thus its sType member must equal that when it is passed to the API.

The values STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO and STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO are reserved for internal use by the loader, and do not have corresponding Vulkan structures in this Specification.

See Also

AccelerationStructureBuildGeometryInfoKHR, AccelerationStructureCreateGeometryTypeInfoKHR, AccelerationStructureCreateInfoKHR, AccelerationStructureCreateInfoNV, AccelerationStructureDeviceAddressInfoKHR, AccelerationStructureGeometryAabbsDataKHR, AccelerationStructureGeometryInstancesDataKHR, AccelerationStructureGeometryKHR, AccelerationStructureGeometryTrianglesDataKHR, AccelerationStructureInfoNV, AccelerationStructureMemoryRequirementsInfoKHR, AccelerationStructureMemoryRequirementsInfoNV, AccelerationStructureVersionKHR, AcquireNextImageInfoKHR, AcquireProfilingLockInfoKHR, AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID, AndroidHardwareBufferUsageANDROID, AndroidSurfaceCreateInfoKHR, ApplicationInfo, AttachmentDescription2, AttachmentDescriptionStencilLayout, AttachmentReference2, AttachmentReferenceStencilLayout, BaseInStructure, BaseOutStructure, BindAccelerationStructureMemoryInfoKHR, BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo, BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo, BindImageMemorySwapchainInfoKHR, BindImagePlaneMemoryInfo, BindSparseInfo, BlitImageInfo2KHR, BufferCopy2KHR, BufferCreateInfo, BufferDeviceAddressCreateInfoEXT, BufferDeviceAddressInfo, BufferImageCopy2KHR, BufferMemoryBarrier, BufferMemoryRequirementsInfo2, BufferOpaqueCaptureAddressCreateInfo, BufferViewCreateInfo, CalibratedTimestampInfoEXT, CheckpointDataNV, CommandBufferAllocateInfo, CommandBufferBeginInfo, CommandBufferInheritanceConditionalRenderingInfoEXT, CommandBufferInheritanceInfo, CommandBufferInheritanceRenderPassTransformInfoQCOM, CommandPoolCreateInfo, ComputePipelineCreateInfo, ConditionalRenderingBeginInfoEXT, CooperativeMatrixPropertiesNV, CopyAccelerationStructureInfoKHR, CopyAccelerationStructureToMemoryInfoKHR, CopyBufferInfo2KHR, CopyBufferToImageInfo2KHR, CopyDescriptorSet, CopyImageInfo2KHR, CopyImageToBufferInfo2KHR, CopyMemoryToAccelerationStructureInfoKHR, D3D12FenceSubmitInfoKHR, DebugMarkerMarkerInfoEXT, DebugMarkerObjectNameInfoEXT, DebugMarkerObjectTagInfoEXT, DebugReportCallbackCreateInfoEXT, DebugUtilsLabelEXT, DebugUtilsMessengerCallbackDataEXT, DebugUtilsMessengerCreateInfoEXT, DebugUtilsObjectNameInfoEXT, DebugUtilsObjectTagInfoEXT, DedicatedAllocationBufferCreateInfoNV, DedicatedAllocationImageCreateInfoNV, DedicatedAllocationMemoryAllocateInfoNV, DeferredOperationInfoKHR, DescriptorPoolCreateInfo, DescriptorPoolInlineUniformBlockCreateInfoEXT, DescriptorSetAllocateInfo, DescriptorSetLayoutBindingFlagsCreateInfo, DescriptorSetLayoutCreateInfo, DescriptorSetLayoutSupport, DescriptorSetVariableDescriptorCountAllocateInfo, DescriptorSetVariableDescriptorCountLayoutSupport, DescriptorUpdateTemplateCreateInfo, DeviceCreateInfo, DeviceDeviceMemoryReportCreateInfoEXT, DeviceDiagnosticsConfigCreateInfoNV, DeviceEventInfoEXT, DeviceGroupBindSparseInfo, DeviceGroupCommandBufferBeginInfo, DeviceGroupDeviceCreateInfo, DeviceGroupPresentCapabilitiesKHR, DeviceGroupPresentInfoKHR, DeviceGroupRenderPassBeginInfo, DeviceGroupSubmitInfo, DeviceGroupSwapchainCreateInfoKHR, DeviceMemoryOpaqueCaptureAddressInfo, DeviceMemoryOverallocationCreateInfoAMD, DeviceMemoryReportCallbackDataEXT, DevicePrivateDataCreateInfoEXT, DeviceQueueCreateInfo, DeviceQueueGlobalPriorityCreateInfoEXT, DeviceQueueInfo2, DirectFBSurfaceCreateInfoEXT, DisplayEventInfoEXT, DisplayModeCreateInfoKHR, DisplayModeProperties2KHR, DisplayNativeHdrSurfaceCapabilitiesAMD, DisplayPlaneCapabilities2KHR, DisplayPlaneInfo2KHR, DisplayPlaneProperties2KHR, DisplayPowerInfoEXT, DisplayPresentInfoKHR, DisplayProperties2KHR, DisplaySurfaceCreateInfoKHR, DrmFormatModifierPropertiesListEXT, EventCreateInfo, ExportFenceCreateInfo, ExportFenceWin32HandleInfoKHR, ExportMemoryAllocateInfo, ExportMemoryAllocateInfoNV, ExportMemoryWin32HandleInfoKHR, ExportMemoryWin32HandleInfoNV, ExportSemaphoreCreateInfo, ExportSemaphoreWin32HandleInfoKHR, ExternalBufferProperties, ExternalFenceProperties, ExternalFormatANDROID, ExternalImageFormatProperties, ExternalMemoryBufferCreateInfo, ExternalMemoryImageCreateInfo, ExternalMemoryImageCreateInfoNV, ExternalSemaphoreProperties, FenceCreateInfo, FenceGetFdInfoKHR, FenceGetWin32HandleInfoKHR, FilterCubicImageViewImageFormatPropertiesEXT, FormatProperties2, FragmentShadingRateAttachmentInfoKHR, FramebufferAttachmentImageInfo, FramebufferAttachmentsCreateInfo, FramebufferCreateInfo, FramebufferMixedSamplesCombinationNV, GeneratedCommandsInfoNV, GeneratedCommandsMemoryRequirementsInfoNV, GeometryAABBNV, GeometryNV, GeometryTrianglesNV, GraphicsPipelineCreateInfo, GraphicsPipelineShaderGroupsCreateInfoNV, GraphicsShaderGroupCreateInfoNV, HdrMetadataEXT, HeadlessSurfaceCreateInfoEXT, IOSSurfaceCreateInfoMVK, ImageBlit2KHR, ImageCopy2KHR, ImageCreateInfo, ImageDrmFormatModifierExplicitCreateInfoEXT, ImageDrmFormatModifierListCreateInfoEXT, ImageDrmFormatModifierPropertiesEXT, ImageFormatListCreateInfo, ImageFormatProperties2, ImageMemoryBarrier, ImageMemoryRequirementsInfo2, ImagePipeSurfaceCreateInfoFUCHSIA, ImagePlaneMemoryRequirementsInfo, ImageResolve2KHR, ImageSparseMemoryRequirementsInfo2, ImageStencilUsageCreateInfo, ImageSwapchainCreateInfoKHR, ImageViewASTCDecodeModeEXT, ImageViewAddressPropertiesNVX, ImageViewCreateInfo, ImageViewHandleInfoNVX, ImageViewUsageCreateInfo, ImportAndroidHardwareBufferInfoANDROID, ImportFenceFdInfoKHR, ImportFenceWin32HandleInfoKHR, ImportMemoryFdInfoKHR, ImportMemoryHostPointerInfoEXT, ImportMemoryWin32HandleInfoKHR, ImportMemoryWin32HandleInfoNV, ImportSemaphoreFdInfoKHR, ImportSemaphoreWin32HandleInfoKHR, IndirectCommandsLayoutCreateInfoNV, IndirectCommandsLayoutTokenNV, InitializePerformanceApiInfoINTEL, InstanceCreateInfo, MacOSSurfaceCreateInfoMVK, MappedMemoryRange, MemoryAllocateFlagsInfo, MemoryAllocateInfo, MemoryBarrier, MemoryDedicatedAllocateInfo, MemoryDedicatedRequirements, MemoryFdPropertiesKHR, MemoryGetAndroidHardwareBufferInfoANDROID, MemoryGetFdInfoKHR, MemoryGetWin32HandleInfoKHR, MemoryHostPointerPropertiesEXT, MemoryOpaqueCaptureAddressAllocateInfo, MemoryPriorityAllocateInfoEXT, MemoryRequirements2, MemoryWin32HandlePropertiesKHR, MetalSurfaceCreateInfoEXT, MultisamplePropertiesEXT, PerformanceConfigurationAcquireInfoINTEL, PerformanceCounterDescriptionKHR, PerformanceCounterKHR, PerformanceMarkerInfoINTEL, PerformanceOverrideInfoINTEL, PerformanceQuerySubmitInfoKHR, PerformanceStreamMarkerInfoINTEL, PhysicalDevice16BitStorageFeatures, PhysicalDevice4444FormatsFeaturesEXT, PhysicalDevice8BitStorageFeatures, PhysicalDeviceASTCDecodeFeaturesEXT, PhysicalDeviceBlendOperationAdvancedFeaturesEXT, PhysicalDeviceBlendOperationAdvancedPropertiesEXT, PhysicalDeviceBufferDeviceAddressFeatures, PhysicalDeviceBufferDeviceAddressFeaturesEXT, PhysicalDeviceCoherentMemoryFeaturesAMD, PhysicalDeviceComputeShaderDerivativesFeaturesNV, PhysicalDeviceConditionalRenderingFeaturesEXT, PhysicalDeviceConservativeRasterizationPropertiesEXT, PhysicalDeviceCooperativeMatrixFeaturesNV, PhysicalDeviceCooperativeMatrixPropertiesNV, PhysicalDeviceCornerSampledImageFeaturesNV, PhysicalDeviceCoverageReductionModeFeaturesNV, PhysicalDeviceCustomBorderColorFeaturesEXT, PhysicalDeviceCustomBorderColorPropertiesEXT, PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, PhysicalDeviceDepthClipEnableFeaturesEXT, PhysicalDeviceDepthStencilResolveProperties, PhysicalDeviceDescriptorIndexingFeatures, PhysicalDeviceDescriptorIndexingProperties, PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, PhysicalDeviceDeviceMemoryReportFeaturesEXT, PhysicalDeviceDiagnosticsConfigFeaturesNV, PhysicalDeviceDiscardRectanglePropertiesEXT, PhysicalDeviceDriverProperties, PhysicalDeviceExclusiveScissorFeaturesNV, PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceExternalBufferInfo, PhysicalDeviceExternalFenceInfo, PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceExternalMemoryHostPropertiesEXT, PhysicalDeviceExternalSemaphoreInfo, PhysicalDeviceFeatures2, PhysicalDeviceFloatControlsProperties, PhysicalDeviceFragmentDensityMap2FeaturesEXT, PhysicalDeviceFragmentDensityMap2PropertiesEXT, PhysicalDeviceFragmentDensityMapFeaturesEXT, PhysicalDeviceFragmentDensityMapPropertiesEXT, PhysicalDeviceFragmentShaderBarycentricFeaturesNV, PhysicalDeviceFragmentShaderInterlockFeaturesEXT, PhysicalDeviceFragmentShadingRateFeaturesKHR, PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRatePropertiesKHR, PhysicalDeviceGroupProperties, PhysicalDeviceHostQueryResetFeatures, PhysicalDeviceIDProperties, PhysicalDeviceImageDrmFormatModifierInfoEXT, PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageRobustnessFeaturesEXT, PhysicalDeviceImageViewImageFormatInfoEXT, PhysicalDeviceImagelessFramebufferFeatures, PhysicalDeviceIndexTypeUint8FeaturesEXT, PhysicalDeviceInlineUniformBlockFeaturesEXT, PhysicalDeviceInlineUniformBlockPropertiesEXT, PhysicalDeviceLineRasterizationFeaturesEXT, PhysicalDeviceLineRasterizationPropertiesEXT, PhysicalDeviceMaintenance3Properties, PhysicalDeviceMemoryBudgetPropertiesEXT, PhysicalDeviceMemoryPriorityFeaturesEXT, PhysicalDeviceMemoryProperties2, PhysicalDeviceMeshShaderFeaturesNV, PhysicalDeviceMeshShaderPropertiesNV, PhysicalDeviceMultiviewFeatures, PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, PhysicalDeviceMultiviewProperties, PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDevicePerformanceQueryPropertiesKHR, PhysicalDevicePipelineCreationCacheControlFeaturesEXT, PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, PhysicalDevicePointClippingProperties, PhysicalDevicePortabilitySubsetFeaturesKHR, PhysicalDevicePortabilitySubsetPropertiesKHR, PhysicalDevicePrivateDataFeaturesEXT, PhysicalDeviceProperties2, PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceProtectedMemoryProperties, PhysicalDevicePushDescriptorPropertiesKHR, PhysicalDeviceRayTracingFeaturesKHR, PhysicalDeviceRayTracingPropertiesKHR, PhysicalDeviceRayTracingPropertiesNV, PhysicalDeviceRepresentativeFragmentTestFeaturesNV, PhysicalDeviceRobustness2FeaturesEXT, PhysicalDeviceRobustness2PropertiesEXT, PhysicalDeviceSampleLocationsPropertiesEXT, PhysicalDeviceSamplerFilterMinmaxProperties, PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceScalarBlockLayoutFeatures, PhysicalDeviceSeparateDepthStencilLayoutsFeatures, PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceShaderClockFeaturesKHR, PhysicalDeviceShaderCoreProperties2AMD, PhysicalDeviceShaderCorePropertiesAMD, PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceShaderFloat16Int8Features, PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceShaderImageFootprintFeaturesNV, PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, PhysicalDeviceShaderSMBuiltinsFeaturesNV, PhysicalDeviceShaderSMBuiltinsPropertiesNV, PhysicalDeviceShaderSubgroupExtendedTypesFeatures, PhysicalDeviceShaderTerminateInvocationFeaturesKHR, PhysicalDeviceShadingRateImageFeaturesNV, PhysicalDeviceShadingRateImagePropertiesNV, PhysicalDeviceSparseImageFormatInfo2, PhysicalDeviceSubgroupProperties, PhysicalDeviceSubgroupSizeControlFeaturesEXT, PhysicalDeviceSubgroupSizeControlPropertiesEXT, PhysicalDeviceSurfaceInfo2KHR, PhysicalDeviceTexelBufferAlignmentFeaturesEXT, PhysicalDeviceTexelBufferAlignmentPropertiesEXT, PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, PhysicalDeviceTimelineSemaphoreFeatures, PhysicalDeviceTimelineSemaphoreProperties, PhysicalDeviceToolPropertiesEXT, PhysicalDeviceTransformFeedbackFeaturesEXT, PhysicalDeviceTransformFeedbackPropertiesEXT, PhysicalDeviceUniformBufferStandardLayoutFeatures, PhysicalDeviceVariablePointersFeatures, PhysicalDeviceVertexAttributeDivisorFeaturesEXT, PhysicalDeviceVertexAttributeDivisorPropertiesEXT, PhysicalDeviceVulkan11Features, PhysicalDeviceVulkan11Properties, PhysicalDeviceVulkan12Features, PhysicalDeviceVulkan12Properties, PhysicalDeviceVulkanMemoryModelFeatures, PhysicalDeviceYcbcrImageArraysFeaturesEXT, PipelineCacheCreateInfo, PipelineColorBlendAdvancedStateCreateInfoEXT, PipelineColorBlendStateCreateInfo, PipelineCompilerControlCreateInfoAMD, PipelineCoverageModulationStateCreateInfoNV, PipelineCoverageReductionStateCreateInfoNV, PipelineCoverageToColorStateCreateInfoNV, PipelineCreationFeedbackCreateInfoEXT, PipelineDepthStencilStateCreateInfo, PipelineDiscardRectangleStateCreateInfoEXT, PipelineDynamicStateCreateInfo, PipelineExecutableInfoKHR, PipelineExecutableInternalRepresentationKHR, PipelineExecutablePropertiesKHR, PipelineExecutableStatisticKHR, PipelineFragmentShadingRateStateCreateInfoKHR, PipelineInfoKHR, PipelineInputAssemblyStateCreateInfo, PipelineLayoutCreateInfo, PipelineLibraryCreateInfoKHR, PipelineMultisampleStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT, PipelineRasterizationDepthClipStateCreateInfoEXT, PipelineRasterizationLineStateCreateInfoEXT, PipelineRasterizationStateCreateInfo, PipelineRasterizationStateRasterizationOrderAMD, PipelineRasterizationStateStreamCreateInfoEXT, PipelineRepresentativeFragmentTestStateCreateInfoNV, PipelineSampleLocationsStateCreateInfoEXT, PipelineShaderStageCreateInfo, PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT, PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo, PipelineVertexInputDivisorStateCreateInfoEXT, PipelineVertexInputStateCreateInfo, PipelineViewportCoarseSampleOrderStateCreateInfoNV, PipelineViewportExclusiveScissorStateCreateInfoNV, PipelineViewportShadingRateImageStateCreateInfoNV, PipelineViewportStateCreateInfo, PipelineViewportSwizzleStateCreateInfoNV, PipelineViewportWScalingStateCreateInfoNV, PresentFrameTokenGGP, PresentInfoKHR, PresentRegionsKHR, PresentTimesInfoGOOGLE, PrivateDataSlotCreateInfoEXT, ProtectedSubmitInfo, QueryPoolCreateInfo, QueryPoolPerformanceCreateInfoKHR, QueryPoolPerformanceQueryCreateInfoINTEL, QueueFamilyCheckpointPropertiesNV, QueueFamilyProperties2, RayTracingPipelineCreateInfoKHR, RayTracingPipelineCreateInfoNV, RayTracingPipelineInterfaceCreateInfoKHR, RayTracingShaderGroupCreateInfoKHR, RayTracingShaderGroupCreateInfoNV, RenderPassAttachmentBeginInfo, RenderPassBeginInfo, RenderPassCreateInfo, RenderPassCreateInfo2, RenderPassFragmentDensityMapCreateInfoEXT, RenderPassInputAttachmentAspectCreateInfo, RenderPassMultiviewCreateInfo, RenderPassSampleLocationsBeginInfoEXT, RenderPassTransformBeginInfoQCOM, ResolveImageInfo2KHR, SampleLocationsInfoEXT, SamplerCreateInfo, SamplerCustomBorderColorCreateInfoEXT, SamplerReductionModeCreateInfo, SamplerYcbcrConversionCreateInfo, SamplerYcbcrConversionImageFormatProperties, SamplerYcbcrConversionInfo, SemaphoreCreateInfo, SemaphoreGetFdInfoKHR, SemaphoreGetWin32HandleInfoKHR, SemaphoreSignalInfo, SemaphoreTypeCreateInfo, SemaphoreWaitInfo, ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT, SharedPresentSurfaceCapabilitiesKHR, SparseImageFormatProperties2, SparseImageMemoryRequirements2, StreamDescriptorSurfaceCreateInfoGGP, SubmitInfo, SubpassBeginInfo, SubpassDependency2, SubpassDescription2, SubpassDescriptionDepthStencilResolve, SubpassEndInfo, SurfaceCapabilities2EXT, SurfaceCapabilities2KHR, SurfaceCapabilitiesFullScreenExclusiveEXT, SurfaceFormat2KHR, SurfaceFullScreenExclusiveInfoEXT, SurfaceFullScreenExclusiveWin32InfoEXT, SurfaceProtectedCapabilitiesKHR, SwapchainCounterCreateInfoEXT, SwapchainCreateInfoKHR, SwapchainDisplayNativeHdrCreateInfoAMD, TextureLODGatherFormatPropertiesAMD, TimelineSemaphoreSubmitInfo, ValidationCacheCreateInfoEXT, ValidationFeaturesEXT, ValidationFlagsEXT, ViSurfaceCreateInfoNN, WaylandSurfaceCreateInfoKHR, Win32KeyedMutexAcquireReleaseInfoKHR, Win32KeyedMutexAcquireReleaseInfoNV, Win32SurfaceCreateInfoKHR, WriteDescriptorSet, WriteDescriptorSetAccelerationStructureKHR, WriteDescriptorSetInlineUniformBlockEXT, XcbSurfaceCreateInfoKHR, XlibSurfaceCreateInfoKHR

Constructors

StructureType Int32

Bundled Patterns

pattern STRUCTURE_TYPE_BUFFER_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO :: StructureType

pattern STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO :: StructureType

pattern STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO :: StructureType

pattern STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO :: StructureType

pattern STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_COPY_DESCRIPTOR_SET :: StructureType

pattern STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO :: StructureType

pattern STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET :: StructureType

pattern STRUCTURE_TYPE_DEVICE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_APPLICATION_INFO :: StructureType

pattern STRUCTURE_TYPE_INSTANCE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_SUBMIT_INFO :: StructureType

pattern STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO :: StructureType

pattern STRUCTURE_TYPE_MAPPED_MEMORY_RANGE :: StructureType

pattern STRUCTURE_TYPE_BIND_SPARSE_INFO :: StructureType

pattern STRUCTURE_TYPE_FENCE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_EVENT_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_IMAGE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_SAMPLER_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER :: StructureType

pattern STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER :: StructureType

pattern STRUCTURE_TYPE_MEMORY_BARRIER :: StructureType

pattern STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR :: StructureType

pattern STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR :: StructureType

pattern STRUCTURE_TYPE_IMAGE_BLIT_2_KHR :: StructureType

pattern STRUCTURE_TYPE_IMAGE_COPY_2_KHR :: StructureType

pattern STRUCTURE_TYPE_BUFFER_COPY_2_KHR :: StructureType

pattern STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR :: StructureType

pattern STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR :: StructureType

pattern STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR :: StructureType

pattern STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR :: StructureType

pattern STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR :: StructureType

pattern STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT :: StructureType

pattern STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM :: StructureType

pattern STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV :: StructureType

pattern STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR :: StructureType

pattern STRUCTURE_TYPE_DEFERRED_OPERATION_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT :: StructureType

pattern STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV :: StructureType

pattern STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_VALIDATION_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR :: StructureType

pattern STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR :: StructureType

pattern STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA :: StructureType

pattern STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL :: StructureType

pattern STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL :: StructureType

pattern STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL :: StructureType

pattern STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL :: StructureType

pattern STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL :: StructureType

pattern STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL :: StructureType

pattern STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV :: StructureType

pattern STRUCTURE_TYPE_CHECKPOINT_DATA_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD :: StructureType

pattern STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_GEOMETRY_AABB_NV :: StructureType

pattern STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV :: StructureType

pattern STRUCTURE_TYPE_GEOMETRY_NV :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR :: StructureType

pattern STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR :: StructureType

pattern STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_GEOMETRY_TYPE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR :: StructureType

pattern STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID :: StructureType

pattern STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID :: StructureType

pattern STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID :: StructureType

pattern STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID :: StructureType

pattern STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID :: StructureType

pattern STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID :: StructureType

pattern STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT :: StructureType

pattern STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT :: StructureType

pattern STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK :: StructureType

pattern STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR :: StructureType

pattern STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR :: StructureType

pattern STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR :: StructureType

pattern STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR :: StructureType

pattern STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR :: StructureType

pattern STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR :: StructureType

pattern STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR :: StructureType

pattern STRUCTURE_TYPE_HDR_METADATA_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX :: StructureType

pattern STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE :: StructureType

pattern STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PRESENT_REGIONS_KHR :: StructureType

pattern STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR :: StructureType

pattern STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR :: StructureType

pattern STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR :: StructureType

pattern STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN :: StructureType

pattern STRUCTURE_TYPE_VALIDATION_FLAGS_EXT :: StructureType

pattern STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR :: StructureType

pattern STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV :: StructureType

pattern STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP :: StructureType

pattern STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD :: StructureType

pattern STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX :: StructureType

pattern STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT :: StructureType

pattern STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV :: StructureType

pattern STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD :: StructureType

pattern STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT :: StructureType

pattern STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_PRESENT_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR :: StructureType

pattern STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO :: StructureType

pattern STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO :: StructureType

pattern STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES :: StructureType

pattern STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO :: StructureType

pattern STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO :: StructureType

pattern STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO :: StructureType

pattern STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES :: StructureType

pattern STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT :: StructureType

pattern STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES :: StructureType

pattern STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO :: StructureType

pattern STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO :: StructureType

pattern STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES :: StructureType

pattern STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES :: StructureType

pattern STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT :: StructureType

pattern STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES :: StructureType

pattern STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES :: StructureType

pattern STRUCTURE_TYPE_SUBPASS_END_INFO :: StructureType

pattern STRUCTURE_TYPE_SUBPASS_BEGIN_INFO :: StructureType

pattern STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 :: StructureType

pattern STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 :: StructureType

pattern STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 :: StructureType

pattern STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 :: StructureType

pattern STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 :: StructureType

pattern STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES :: StructureType

pattern STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO :: StructureType

pattern STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO :: StructureType

pattern STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO :: StructureType

pattern STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO :: StructureType

pattern STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO :: StructureType

pattern STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES :: StructureType

pattern STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO :: StructureType

pattern STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO :: StructureType

pattern STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO :: StructureType

pattern STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES :: StructureType

pattern STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 :: StructureType

pattern STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 :: StructureType

pattern STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 :: StructureType

pattern STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 :: StructureType

pattern STRUCTURE_TYPE_FORMAT_PROPERTIES_2 :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 :: StructureType

pattern STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 :: StructureType

pattern STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 :: StructureType

pattern STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 :: StructureType

pattern STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 :: StructureType

pattern STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 :: StructureType

pattern STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES :: StructureType

pattern STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO :: StructureType

pattern STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO :: StructureType

pattern STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO :: StructureType

pattern STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO :: StructureType

pattern STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO :: StructureType

pattern STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO :: StructureType

pattern STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO :: StructureType

pattern STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO :: StructureType

pattern STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES :: StructureType

pattern STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO :: StructureType

pattern STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO :: StructureType

pattern STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES :: StructureType

Instances

Eq StructureType

Defined in Vulkan.Core10.Enums.StructureType

Methods

(==) :: StructureType -> StructureType -> Bool

(/=) :: StructureType -> StructureType -> Bool

Ord StructureType

Defined in Vulkan.Core10.Enums.StructureType

Methods

compare :: StructureType -> StructureType -> Ordering

(<) :: StructureType -> StructureType -> Bool

(<=) :: StructureType -> StructureType -> Bool

(>) :: StructureType -> StructureType -> Bool

(>=) :: StructureType -> StructureType -> Bool

max :: StructureType -> StructureType -> StructureType

min :: StructureType -> StructureType -> StructureType

Read StructureType

Defined in Vulkan.Core10.Enums.StructureType

Methods

readsPrec :: Int -> ReadS StructureType

readList :: ReadS [StructureType]

readPrec :: ReadPrec StructureType

readListPrec :: ReadPrec [StructureType]

Show StructureType

Defined in Vulkan.Core10.Enums.StructureType

Methods

showsPrec :: Int -> StructureType -> ShowS

show :: StructureType -> String

showList :: [StructureType] -> ShowS

Storable StructureType

Defined in Vulkan.Core10.Enums.StructureType

Methods

sizeOf :: StructureType -> Int

alignment :: StructureType -> Int

peekElemOff :: Ptr StructureType -> Int -> IO StructureType

pokeElemOff :: Ptr StructureType -> Int -> StructureType -> IO ()

peekByteOff :: Ptr b -> Int -> IO StructureType

pokeByteOff :: Ptr b -> Int -> StructureType -> IO ()

peek :: Ptr StructureType -> IO StructureType

poke :: Ptr StructureType -> StructureType -> IO ()

Zero StructureType

Defined in Vulkan.Core10.Enums.StructureType

Methods

zero :: StructureType

newtype QueueFlagBits

VkQueueFlagBits - Bitmask specifying capabilities of queues in a queue family

Description

• QUEUE_GRAPHICS_BIT specifies that queues in this queue family support graphics operations.

• QUEUE_COMPUTE_BIT specifies that queues in this queue family support compute operations.
• QUEUE_TRANSFER_BIT specifies that queues in this queue family support transfer operations.
• 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 QUEUE_PROTECTED_BIT is set, then the queues in this queue family support the DEVICE_QUEUE_CREATE_PROTECTED_BIT bit. (see Protected Memory). If the physical device supports the protectedMemory feature, at least one of its queue families 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.

Furthermore, if the protected memory physical device feature is supported, then at least one queue family of at least one physical device exposed by the implementation must support graphics operations, compute operations, and protected memory 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 QUEUE_GRAPHICS_BIT or QUEUE_COMPUTE_BIT, then reporting the QUEUE_TRANSFER_BIT capability separately for that queue family is optional.

For further details see Queues.

See Also

QueueFlags

Constructors

QueueFlagBits Flags

Bundled Patterns

pattern QUEUE_GRAPHICS_BIT :: QueueFlagBits

pattern QUEUE_COMPUTE_BIT :: QueueFlagBits

pattern QUEUE_TRANSFER_BIT :: QueueFlagBits

pattern QUEUE_SPARSE_BINDING_BIT :: QueueFlagBits

pattern QUEUE_PROTECTED_BIT :: QueueFlagBits

Instances

Eq QueueFlagBits

Defined in Vulkan.Core10.Enums.QueueFlagBits

Methods

(==) :: QueueFlagBits -> QueueFlagBits -> Bool

(/=) :: QueueFlagBits -> QueueFlagBits -> Bool

Ord QueueFlagBits

Defined in Vulkan.Core10.Enums.QueueFlagBits

Methods

compare :: QueueFlagBits -> QueueFlagBits -> Ordering

(<) :: QueueFlagBits -> QueueFlagBits -> Bool

(<=) :: QueueFlagBits -> QueueFlagBits -> Bool

(>) :: QueueFlagBits -> QueueFlagBits -> Bool

(>=) :: QueueFlagBits -> QueueFlagBits -> Bool

max :: QueueFlagBits -> QueueFlagBits -> QueueFlagBits

min :: QueueFlagBits -> QueueFlagBits -> QueueFlagBits

Read QueueFlagBits

Defined in Vulkan.Core10.Enums.QueueFlagBits

Methods

readsPrec :: Int -> ReadS QueueFlagBits

readList :: ReadS [QueueFlagBits]

readPrec :: ReadPrec QueueFlagBits

readListPrec :: ReadPrec [QueueFlagBits]

Show QueueFlagBits

Defined in Vulkan.Core10.Enums.QueueFlagBits

Methods

showsPrec :: Int -> QueueFlagBits -> ShowS

show :: QueueFlagBits -> String

showList :: [QueueFlagBits] -> ShowS

Storable QueueFlagBits

Defined in Vulkan.Core10.Enums.QueueFlagBits

Methods

sizeOf :: QueueFlagBits -> Int

alignment :: QueueFlagBits -> Int

peekElemOff :: Ptr QueueFlagBits -> Int -> IO QueueFlagBits

pokeElemOff :: Ptr QueueFlagBits -> Int -> QueueFlagBits -> IO ()

peekByteOff :: Ptr b -> Int -> IO QueueFlagBits

pokeByteOff :: Ptr b -> Int -> QueueFlagBits -> IO ()

peek :: Ptr QueueFlagBits -> IO QueueFlagBits

poke :: Ptr QueueFlagBits -> QueueFlagBits -> IO ()

Bits QueueFlagBits

Defined in Vulkan.Core10.Enums.QueueFlagBits

Methods

(.&.) :: QueueFlagBits -> QueueFlagBits -> QueueFlagBits

(.|.) :: QueueFlagBits -> QueueFlagBits -> QueueFlagBits

xor :: QueueFlagBits -> QueueFlagBits -> QueueFlagBits

complement :: QueueFlagBits -> QueueFlagBits

shift :: QueueFlagBits -> Int -> QueueFlagBits

rotate :: QueueFlagBits -> Int -> QueueFlagBits

zeroBits :: QueueFlagBits

bit :: Int -> QueueFlagBits

setBit :: QueueFlagBits -> Int -> QueueFlagBits

clearBit :: QueueFlagBits -> Int -> QueueFlagBits

complementBit :: QueueFlagBits -> Int -> QueueFlagBits

testBit :: QueueFlagBits -> Int -> Bool

bitSizeMaybe :: QueueFlagBits -> Maybe Int

bitSize :: QueueFlagBits -> Int

isSigned :: QueueFlagBits -> Bool

shiftL :: QueueFlagBits -> Int -> QueueFlagBits

unsafeShiftL :: QueueFlagBits -> Int -> QueueFlagBits

shiftR :: QueueFlagBits -> Int -> QueueFlagBits

unsafeShiftR :: QueueFlagBits -> Int -> QueueFlagBits

rotateL :: QueueFlagBits -> Int -> QueueFlagBits

rotateR :: QueueFlagBits -> Int -> QueueFlagBits

popCount :: QueueFlagBits -> Int

Zero QueueFlagBits

Defined in Vulkan.Core10.Enums.QueueFlagBits

Methods

zero :: QueueFlagBits

type QueueFlags = QueueFlagBits

newtype MemoryPropertyFlagBits

VkMemoryPropertyFlagBits - Bitmask specifying properties for a memory type

Description

For any memory allocated with both the MEMORY_PROPERTY_HOST_COHERENT_BIT and the MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD, host or device accesses also perform automatic memory domain transfer operations, such that writes are always automatically available and visible to both host and device memory domains.

Note

Device coherence is a useful property for certain debugging use cases (e.g. crash analysis, where performing separate coherence actions could mean values are not reported correctly). However, device coherent accesses may be slower than equivalent accesses without device coherence, particularly if they are also device uncached. For device uncached memory in particular, repeated accesses to the same or neighbouring memory locations over a short time period (e.g. within a frame) may be slower than it would be for the equivalent cached memory type. As such, it is generally inadvisable to use device coherent or device uncached memory except when really needed.

See Also

MemoryPropertyFlags

Constructors

MemoryPropertyFlagBits Flags

Bundled Patterns

pattern MEMORY_PROPERTY_DEVICE_LOCAL_BIT :: MemoryPropertyFlagBits

MEMORY_PROPERTY_DEVICE_LOCAL_BIT bit specifies that memory allocated with this type is the most efficient for device access. This property will be set if and only if the memory type belongs to a heap with the MEMORY_HEAP_DEVICE_LOCAL_BIT set.

pattern MEMORY_PROPERTY_HOST_VISIBLE_BIT :: MemoryPropertyFlagBits

MEMORY_PROPERTY_HOST_VISIBLE_BIT bit specifies that memory allocated with this type can be mapped for host access using mapMemory.

pattern MEMORY_PROPERTY_HOST_COHERENT_BIT :: MemoryPropertyFlagBits

MEMORY_PROPERTY_HOST_COHERENT_BIT bit specifies that the host cache management commands flushMappedMemoryRanges and invalidateMappedMemoryRanges are not needed to flush host writes to the device or make device writes visible to the host, respectively.

pattern MEMORY_PROPERTY_HOST_CACHED_BIT :: MemoryPropertyFlagBits

MEMORY_PROPERTY_HOST_CACHED_BIT bit specifies that memory allocated with this type is cached on the host. Host memory accesses to uncached memory are slower than to cached memory, however uncached memory is always host coherent.

pattern MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT :: MemoryPropertyFlagBits

MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit specifies that the memory type only allows device access to the memory. Memory types must not have both MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT and MEMORY_PROPERTY_HOST_VISIBLE_BIT set. Additionally, the object’s backing memory may be provided by the implementation lazily as specified in Lazily Allocated Memory.

pattern MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD :: MemoryPropertyFlagBits

MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD bit specifies that memory allocated with this type is not cached on the device. Uncached device memory is always device coherent.

pattern MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD :: MemoryPropertyFlagBits

MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD bit specifies that device accesses to allocations of this memory type are automatically made available and visible.

pattern MEMORY_PROPERTY_PROTECTED_BIT :: MemoryPropertyFlagBits

MEMORY_PROPERTY_PROTECTED_BIT bit specifies that the memory type only allows device access to the memory, and allows protected queue operations to access the memory. Memory types must not have MEMORY_PROPERTY_PROTECTED_BIT set and any of MEMORY_PROPERTY_HOST_VISIBLE_BIT set, or MEMORY_PROPERTY_HOST_COHERENT_BIT set, or MEMORY_PROPERTY_HOST_CACHED_BIT set.

Instances

Eq MemoryPropertyFlagBits

Defined in Vulkan.Core10.Enums.MemoryPropertyFlagBits

Methods

(==) :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> Bool

(/=) :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> Bool

Ord MemoryPropertyFlagBits

Defined in Vulkan.Core10.Enums.MemoryPropertyFlagBits

Methods

compare :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> Ordering

(<) :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> Bool

(<=) :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> Bool

(>) :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> Bool

(>=) :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> Bool

max :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> MemoryPropertyFlagBits

min :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> MemoryPropertyFlagBits

Read MemoryPropertyFlagBits

Defined in Vulkan.Core10.Enums.MemoryPropertyFlagBits

Methods

readsPrec :: Int -> ReadS MemoryPropertyFlagBits

readList :: ReadS [MemoryPropertyFlagBits]

readPrec :: ReadPrec MemoryPropertyFlagBits

readListPrec :: ReadPrec [MemoryPropertyFlagBits]

Show MemoryPropertyFlagBits

Defined in Vulkan.Core10.Enums.MemoryPropertyFlagBits

Methods

showsPrec :: Int -> MemoryPropertyFlagBits -> ShowS

show :: MemoryPropertyFlagBits -> String

showList :: [MemoryPropertyFlagBits] -> ShowS

Storable MemoryPropertyFlagBits

Defined in Vulkan.Core10.Enums.MemoryPropertyFlagBits

Methods

sizeOf :: MemoryPropertyFlagBits -> Int

alignment :: MemoryPropertyFlagBits -> Int

peekElemOff :: Ptr MemoryPropertyFlagBits -> Int -> IO MemoryPropertyFlagBits

pokeElemOff :: Ptr MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits -> IO ()

peekByteOff :: Ptr b -> Int -> IO MemoryPropertyFlagBits

pokeByteOff :: Ptr b -> Int -> MemoryPropertyFlagBits -> IO ()

peek :: Ptr MemoryPropertyFlagBits -> IO MemoryPropertyFlagBits

poke :: Ptr MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> IO ()

Bits MemoryPropertyFlagBits

Defined in Vulkan.Core10.Enums.MemoryPropertyFlagBits

Methods

(.&.) :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> MemoryPropertyFlagBits

(.|.) :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> MemoryPropertyFlagBits

xor :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits -> MemoryPropertyFlagBits

complement :: MemoryPropertyFlagBits -> MemoryPropertyFlagBits

shift :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

rotate :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

zeroBits :: MemoryPropertyFlagBits

bit :: Int -> MemoryPropertyFlagBits

setBit :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

clearBit :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

complementBit :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

testBit :: MemoryPropertyFlagBits -> Int -> Bool

bitSizeMaybe :: MemoryPropertyFlagBits -> Maybe Int

bitSize :: MemoryPropertyFlagBits -> Int

isSigned :: MemoryPropertyFlagBits -> Bool

shiftL :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

unsafeShiftL :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

shiftR :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

unsafeShiftR :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

rotateL :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

rotateR :: MemoryPropertyFlagBits -> Int -> MemoryPropertyFlagBits

popCount :: MemoryPropertyFlagBits -> Int

Zero MemoryPropertyFlagBits

Defined in Vulkan.Core10.Enums.MemoryPropertyFlagBits

Methods

zero :: MemoryPropertyFlagBits

type MemoryPropertyFlags = MemoryPropertyFlagBits

newtype MemoryHeapFlagBits

VkMemoryHeapFlagBits - Bitmask specifying attribute flags for a heap

See Also

MemoryHeapFlags

Constructors

MemoryHeapFlagBits Flags

Bundled Patterns

pattern MEMORY_HEAP_DEVICE_LOCAL_BIT :: MemoryHeapFlagBits

MEMORY_HEAP_DEVICE_LOCAL_BIT specifies that the heap corresponds to device local memory. Device local memory may have different performance characteristics than host local memory, and may support different memory property flags.

pattern MEMORY_HEAP_MULTI_INSTANCE_BIT :: MemoryHeapFlagBits

MEMORY_HEAP_MULTI_INSTANCE_BIT specifies that in a logical device representing more than one physical device, there is a per-physical device instance of the heap memory. By default, an allocation from such a heap will be replicated to each physical device’s instance of the heap.

Instances

Eq MemoryHeapFlagBits

Defined in Vulkan.Core10.Enums.MemoryHeapFlagBits

Methods

(==) :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> Bool

(/=) :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> Bool

Ord MemoryHeapFlagBits

Defined in Vulkan.Core10.Enums.MemoryHeapFlagBits

Methods

compare :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> Ordering

(<) :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> Bool

(<=) :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> Bool

(>) :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> Bool

(>=) :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> Bool

max :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> MemoryHeapFlagBits

min :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> MemoryHeapFlagBits

Read MemoryHeapFlagBits

Defined in Vulkan.Core10.Enums.MemoryHeapFlagBits

Methods

readsPrec :: Int -> ReadS MemoryHeapFlagBits

readList :: ReadS [MemoryHeapFlagBits]

readPrec :: ReadPrec MemoryHeapFlagBits

readListPrec :: ReadPrec [MemoryHeapFlagBits]

Show MemoryHeapFlagBits

Defined in Vulkan.Core10.Enums.MemoryHeapFlagBits

Methods

showsPrec :: Int -> MemoryHeapFlagBits -> ShowS

show :: MemoryHeapFlagBits -> String

showList :: [MemoryHeapFlagBits] -> ShowS

Storable MemoryHeapFlagBits

Defined in Vulkan.Core10.Enums.MemoryHeapFlagBits

Methods

sizeOf :: MemoryHeapFlagBits -> Int

alignment :: MemoryHeapFlagBits -> Int

peekElemOff :: Ptr MemoryHeapFlagBits -> Int -> IO MemoryHeapFlagBits

pokeElemOff :: Ptr MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits -> IO ()

peekByteOff :: Ptr b -> Int -> IO MemoryHeapFlagBits

pokeByteOff :: Ptr b -> Int -> MemoryHeapFlagBits -> IO ()

peek :: Ptr MemoryHeapFlagBits -> IO MemoryHeapFlagBits

poke :: Ptr MemoryHeapFlagBits -> MemoryHeapFlagBits -> IO ()

Bits MemoryHeapFlagBits

Defined in Vulkan.Core10.Enums.MemoryHeapFlagBits

Methods

(.&.) :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> MemoryHeapFlagBits

(.|.) :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> MemoryHeapFlagBits

xor :: MemoryHeapFlagBits -> MemoryHeapFlagBits -> MemoryHeapFlagBits

complement :: MemoryHeapFlagBits -> MemoryHeapFlagBits

shift :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

rotate :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

zeroBits :: MemoryHeapFlagBits

bit :: Int -> MemoryHeapFlagBits

setBit :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

clearBit :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

complementBit :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

testBit :: MemoryHeapFlagBits -> Int -> Bool

bitSizeMaybe :: MemoryHeapFlagBits -> Maybe Int

bitSize :: MemoryHeapFlagBits -> Int

isSigned :: MemoryHeapFlagBits -> Bool

shiftL :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

unsafeShiftL :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

shiftR :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

unsafeShiftR :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

rotateL :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

rotateR :: MemoryHeapFlagBits -> Int -> MemoryHeapFlagBits

popCount :: MemoryHeapFlagBits -> Int

Zero MemoryHeapFlagBits

Defined in Vulkan.Core10.Enums.MemoryHeapFlagBits

Methods

zero :: MemoryHeapFlagBits

type MemoryHeapFlags = MemoryHeapFlagBits

newtype ImageUsageFlagBits

VkImageUsageFlagBits - Bitmask specifying intended usage of an image

See Also

ImageUsageFlags

Constructors

ImageUsageFlagBits Flags

Bundled Patterns

pattern IMAGE_USAGE_TRANSFER_SRC_BIT :: ImageUsageFlagBits

IMAGE_USAGE_TRANSFER_SRC_BIT specifies that the image can be used as the source of a transfer command.

pattern IMAGE_USAGE_TRANSFER_DST_BIT :: ImageUsageFlagBits

IMAGE_USAGE_TRANSFER_DST_BIT specifies that the image can be used as the destination of a transfer command.

pattern IMAGE_USAGE_SAMPLED_BIT :: ImageUsageFlagBits

IMAGE_USAGE_SAMPLED_BIT specifies that the image can be used to create a ImageView suitable for occupying a DescriptorSet slot either of type DESCRIPTOR_TYPE_SAMPLED_IMAGE or DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and be sampled by a shader.

pattern IMAGE_USAGE_STORAGE_BIT :: ImageUsageFlagBits

IMAGE_USAGE_STORAGE_BIT specifies that the image can be used to create a ImageView suitable for occupying a DescriptorSet slot of type DESCRIPTOR_TYPE_STORAGE_IMAGE.

pattern IMAGE_USAGE_COLOR_ATTACHMENT_BIT :: ImageUsageFlagBits

IMAGE_USAGE_COLOR_ATTACHMENT_BIT specifies that the image can be used to create a ImageView suitable for use as a color or resolve attachment in a Framebuffer.

pattern IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT :: ImageUsageFlagBits

IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT specifies that the image can be used to create a ImageView suitable for use as a depth/stencil or depth/stencil resolve attachment in a Framebuffer.

pattern IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT :: ImageUsageFlagBits

IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT specifies that the memory bound to this image will have been allocated with the MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT (see https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#memory for more detail). This bit can be set for any image that can be used to create a ImageView suitable for use as a color, resolve, depth/stencil, or input attachment.

pattern IMAGE_USAGE_INPUT_ATTACHMENT_BIT :: ImageUsageFlagBits

IMAGE_USAGE_INPUT_ATTACHMENT_BIT specifies that the image can be used to create a ImageView suitable for occupying DescriptorSet slot of type DESCRIPTOR_TYPE_INPUT_ATTACHMENT; be read from a shader as an input attachment; and be used as an input attachment in a framebuffer.

pattern IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT :: ImageUsageFlagBits

IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT specifies that the image can be used to create a ImageView suitable for use as a fragment density map image.

pattern IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV :: ImageUsageFlagBits

Instances

Eq ImageUsageFlagBits

Defined in Vulkan.Core10.Enums.ImageUsageFlagBits

Methods

(==) :: ImageUsageFlagBits -> ImageUsageFlagBits -> Bool

(/=) :: ImageUsageFlagBits -> ImageUsageFlagBits -> Bool

Ord ImageUsageFlagBits

Defined in Vulkan.Core10.Enums.ImageUsageFlagBits

Methods

compare :: ImageUsageFlagBits -> ImageUsageFlagBits -> Ordering

(<) :: ImageUsageFlagBits -> ImageUsageFlagBits -> Bool

(<=) :: ImageUsageFlagBits -> ImageUsageFlagBits -> Bool

(>) :: ImageUsageFlagBits -> ImageUsageFlagBits -> Bool

(>=) :: ImageUsageFlagBits -> ImageUsageFlagBits -> Bool

max :: ImageUsageFlagBits -> ImageUsageFlagBits -> ImageUsageFlagBits

min :: ImageUsageFlagBits -> ImageUsageFlagBits -> ImageUsageFlagBits

Read ImageUsageFlagBits

Defined in Vulkan.Core10.Enums.ImageUsageFlagBits

Methods

readsPrec :: Int -> ReadS ImageUsageFlagBits

readList :: ReadS [ImageUsageFlagBits]

readPrec :: ReadPrec ImageUsageFlagBits

readListPrec :: ReadPrec [ImageUsageFlagBits]

Show ImageUsageFlagBits

Defined in Vulkan.Core10.Enums.ImageUsageFlagBits

Methods

showsPrec :: Int -> ImageUsageFlagBits -> ShowS

show :: ImageUsageFlagBits -> String

showList :: [ImageUsageFlagBits] -> ShowS

Storable ImageUsageFlagBits

Defined in Vulkan.Core10.Enums.ImageUsageFlagBits

Methods

sizeOf :: ImageUsageFlagBits -> Int

alignment :: ImageUsageFlagBits -> Int

peekElemOff :: Ptr ImageUsageFlagBits -> Int -> IO ImageUsageFlagBits

pokeElemOff :: Ptr ImageUsageFlagBits -> Int -> ImageUsageFlagBits -> IO ()

peekByteOff :: Ptr b -> Int -> IO ImageUsageFlagBits

pokeByteOff :: Ptr b -> Int -> ImageUsageFlagBits -> IO ()

peek :: Ptr ImageUsageFlagBits -> IO ImageUsageFlagBits

poke :: Ptr ImageUsageFlagBits -> ImageUsageFlagBits -> IO ()

Bits ImageUsageFlagBits

Defined in Vulkan.Core10.Enums.ImageUsageFlagBits

Methods

(.&.) :: ImageUsageFlagBits -> ImageUsageFlagBits -> ImageUsageFlagBits

(.|.) :: ImageUsageFlagBits -> ImageUsageFlagBits -> ImageUsageFlagBits

xor :: ImageUsageFlagBits -> ImageUsageFlagBits -> ImageUsageFlagBits

complement :: ImageUsageFlagBits -> ImageUsageFlagBits

shift :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

rotate :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

zeroBits :: ImageUsageFlagBits

bit :: Int -> ImageUsageFlagBits

setBit :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

clearBit :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

complementBit :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

testBit :: ImageUsageFlagBits -> Int -> Bool

bitSizeMaybe :: ImageUsageFlagBits -> Maybe Int

bitSize :: ImageUsageFlagBits -> Int

isSigned :: ImageUsageFlagBits -> Bool

shiftL :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

unsafeShiftL :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

shiftR :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

unsafeShiftR :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

rotateL :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

rotateR :: ImageUsageFlagBits -> Int -> ImageUsageFlagBits

popCount :: ImageUsageFlagBits -> Int

Zero ImageUsageFlagBits

Defined in Vulkan.Core10.Enums.ImageUsageFlagBits

Methods

zero :: ImageUsageFlagBits

type ImageUsageFlags = ImageUsageFlagBits

newtype ImageCreateFlagBits

VkImageCreateFlagBits - Bitmask specifying additional parameters of an image

Description

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

See Also

ImageCreateFlags

Constructors

ImageCreateFlagBits Flags

Bundled Patterns

pattern IMAGE_CREATE_SPARSE_BINDING_BIT :: ImageCreateFlagBits

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

pattern IMAGE_CREATE_SPARSE_RESIDENCY_BIT :: ImageCreateFlagBits

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 IMAGE_CREATE_SPARSE_BINDING_BIT flag.

pattern IMAGE_CREATE_SPARSE_ALIASED_BIT :: ImageCreateFlagBits

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 IMAGE_CREATE_SPARSE_BINDING_BIT flag

pattern IMAGE_CREATE_MUTABLE_FORMAT_BIT :: ImageCreateFlagBits

IMAGE_CREATE_MUTABLE_FORMAT_BIT specifies that the image can be used to create a ImageView with a different format from the image. For multi-planar formats, IMAGE_CREATE_MUTABLE_FORMAT_BIT specifies that a ImageView can be created of a plane of the image.

pattern IMAGE_CREATE_CUBE_COMPATIBLE_BIT :: ImageCreateFlagBits

IMAGE_CREATE_CUBE_COMPATIBLE_BIT specifies that the image can be used to create a ImageView of type IMAGE_VIEW_TYPE_CUBE or IMAGE_VIEW_TYPE_CUBE_ARRAY.

pattern IMAGE_CREATE_SUBSAMPLED_BIT_EXT :: ImageCreateFlagBits

IMAGE_CREATE_SUBSAMPLED_BIT_EXT specifies that an image can be in a subsampled format which may be more optimal when written as an attachment by a render pass that has a fragment density map attachment. Accessing a subsampled image has additional considerations:

• Image data read as an image sampler will have undefined values if the sampler was not created with flags containing SAMPLER_CREATE_SUBSAMPLED_BIT_EXT or was not sampled through the use of a combined image sampler with an immutable sampler in DescriptorSetLayoutBinding.
• Image data read with an input attachment will have undefined values if the contents were not written as an attachment in an earlier subpass of the same render pass.
• Image data read as an image sampler in the fragment shader will be additionally be read by the device during PIPELINE_STAGE_VERTEX_SHADER_BIT if ::subsampledCoarseReconstructionEarlyAccess is TRUE and the sampler was created with flags containing SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT.
• Image data read with load operations are resampled to the fragment density of the render pass if ::subsampledLoads is TRUE. Otherwise, values of image data are undefined.
• Image contents outside of the render area take on undefined values if the image is stored as a render pass attachment.

pattern IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT :: ImageCreateFlagBits

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.

pattern IMAGE_CREATE_CORNER_SAMPLED_BIT_NV :: ImageCreateFlagBits

IMAGE_CREATE_CORNER_SAMPLED_BIT_NV specifies that the image is a corner-sampled image.

pattern IMAGE_CREATE_DISJOINT_BIT :: ImageCreateFlagBits

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.

pattern IMAGE_CREATE_PROTECTED_BIT :: ImageCreateFlagBits

IMAGE_CREATE_PROTECTED_BIT specifies that the image is a protected image.

pattern IMAGE_CREATE_EXTENDED_USAGE_BIT :: ImageCreateFlagBits

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 ImageView created from the image can have.

pattern IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT :: ImageCreateFlagBits

IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT specifies that the image having a compressed format can be used to create a ImageView with an uncompressed format where each texel in the image view corresponds to a compressed texel block of the image.

pattern IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT :: ImageCreateFlagBits

IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT specifies that the image can be used to create a ImageView of type IMAGE_VIEW_TYPE_2D or IMAGE_VIEW_TYPE_2D_ARRAY.

pattern IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT :: ImageCreateFlagBits

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 BindImageMemoryDeviceGroupInfo structure passed into bindImageMemory2. This flag also has the effect of making the image use the standard sparse image block dimensions.

pattern IMAGE_CREATE_ALIAS_BIT :: ImageCreateFlagBits

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 https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#formats-compatible-planes. If the pNext chain includes a ExternalMemoryImageCreateInfo or ExternalMemoryImageCreateInfoNV structure whose handleTypes member is not 0, it is as if IMAGE_CREATE_ALIAS_BIT is set.

Instances

Eq ImageCreateFlagBits

Defined in Vulkan.Core10.Enums.ImageCreateFlagBits

Methods

(==) :: ImageCreateFlagBits -> ImageCreateFlagBits -> Bool

(/=) :: ImageCreateFlagBits -> ImageCreateFlagBits -> Bool

Ord ImageCreateFlagBits

Defined in Vulkan.Core10.Enums.ImageCreateFlagBits

Methods

compare :: ImageCreateFlagBits -> ImageCreateFlagBits -> Ordering

(<) :: ImageCreateFlagBits -> ImageCreateFlagBits -> Bool

(<=) :: ImageCreateFlagBits -> ImageCreateFlagBits -> Bool

(>) :: ImageCreateFlagBits -> ImageCreateFlagBits -> Bool

(>=) :: ImageCreateFlagBits -> ImageCreateFlagBits -> Bool

max :: ImageCreateFlagBits -> ImageCreateFlagBits -> ImageCreateFlagBits

min :: ImageCreateFlagBits -> ImageCreateFlagBits -> ImageCreateFlagBits

Read ImageCreateFlagBits

Defined in Vulkan.Core10.Enums.ImageCreateFlagBits

Methods

readsPrec :: Int -> ReadS ImageCreateFlagBits

readList :: ReadS [ImageCreateFlagBits]

readPrec :: ReadPrec ImageCreateFlagBits

readListPrec :: ReadPrec [ImageCreateFlagBits]

Show ImageCreateFlagBits

Defined in Vulkan.Core10.Enums.ImageCreateFlagBits

Methods

showsPrec :: Int -> ImageCreateFlagBits -> ShowS

show :: ImageCreateFlagBits -> String

showList :: [ImageCreateFlagBits] -> ShowS

Storable ImageCreateFlagBits

Defined in Vulkan.Core10.Enums.ImageCreateFlagBits

Methods

sizeOf :: ImageCreateFlagBits -> Int

alignment :: ImageCreateFlagBits -> Int

peekElemOff :: Ptr ImageCreateFlagBits -> Int -> IO ImageCreateFlagBits

pokeElemOff :: Ptr ImageCreateFlagBits -> Int -> ImageCreateFlagBits -> IO ()

peekByteOff :: Ptr b -> Int -> IO ImageCreateFlagBits

pokeByteOff :: Ptr b -> Int -> ImageCreateFlagBits -> IO ()

peek :: Ptr ImageCreateFlagBits -> IO ImageCreateFlagBits

poke :: Ptr ImageCreateFlagBits -> ImageCreateFlagBits -> IO ()

Bits ImageCreateFlagBits

Defined in Vulkan.Core10.Enums.ImageCreateFlagBits

Methods

(.&.) :: ImageCreateFlagBits -> ImageCreateFlagBits -> ImageCreateFlagBits

(.|.) :: ImageCreateFlagBits -> ImageCreateFlagBits -> ImageCreateFlagBits

xor :: ImageCreateFlagBits -> ImageCreateFlagBits -> ImageCreateFlagBits

complement :: ImageCreateFlagBits -> ImageCreateFlagBits

shift :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

rotate :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

zeroBits :: ImageCreateFlagBits

bit :: Int -> ImageCreateFlagBits

setBit :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

clearBit :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

complementBit :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

testBit :: ImageCreateFlagBits -> Int -> Bool

bitSizeMaybe :: ImageCreateFlagBits -> Maybe Int

bitSize :: ImageCreateFlagBits -> Int

isSigned :: ImageCreateFlagBits -> Bool

shiftL :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

unsafeShiftL :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

shiftR :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

unsafeShiftR :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

rotateL :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

rotateR :: ImageCreateFlagBits -> Int -> ImageCreateFlagBits

popCount :: ImageCreateFlagBits -> Int

Zero ImageCreateFlagBits

Defined in Vulkan.Core10.Enums.ImageCreateFlagBits

Methods

zero :: ImageCreateFlagBits

type ImageCreateFlags = ImageCreateFlagBits

newtype FormatFeatureFlagBits

VkFormatFeatureFlagBits - Bitmask specifying features supported by a buffer

Description

The following bits may be set in linearTilingFeatures, optimalTilingFeatures, and DrmFormatModifierPropertiesEXT::drmFormatModifierTilingFeatures, specifying that the features are supported by images or image views or sampler Y′CBCR conversion objects created with the queried getPhysicalDeviceFormatProperties::format:

• FORMAT_FEATURE_SAMPLED_IMAGE_BIT specifies that an image view can be sampled from.
• FORMAT_FEATURE_STORAGE_IMAGE_BIT specifies that an image view can be used as a storage images.
• FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT specifies that an image view can be used as storage image that supports atomic operations.
• FORMAT_FEATURE_COLOR_ATTACHMENT_BIT specifies that an image view can be used as a framebuffer color attachment and as an input attachment.
• 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.
• 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.
• FORMAT_FEATURE_BLIT_SRC_BIT specifies that an image can be used as srcImage for the cmdBlitImage2KHR and cmdBlitImage commands.
• FORMAT_FEATURE_BLIT_DST_BIT specifies that an image can be used as dstImage for the cmdBlitImage2KHR and cmdBlitImage commands.

• FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT specifies that if 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 FILTER_LINEAR, or mipmapMode set to SAMPLER_MIPMAP_MODE_LINEAR. If FORMAT_FEATURE_BLIT_SRC_BIT is also set, an image can be used as the srcImage to cmdBlitImage2KHR and cmdBlitImage with a filter of FILTER_LINEAR. This bit must only be exposed for formats that also support the FORMAT_FEATURE_SAMPLED_IMAGE_BIT or 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.

• FORMAT_FEATURE_TRANSFER_SRC_BIT specifies that an image can be used as a source image for copy commands.
• FORMAT_FEATURE_TRANSFER_DST_BIT specifies that an image can be used as a destination image for copy commands and clear commands.
• FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT specifies Image can be used as a sampled image with a min or max SamplerReductionMode. This bit must only be exposed for formats that also support the FORMAT_FEATURE_SAMPLED_IMAGE_BIT.
• FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT specifies that Image can be used with a sampler that has either of magFilter or minFilter set to FILTER_CUBIC_EXT, or be the source image for a blit with filter set to FILTER_CUBIC_EXT. This bit must only be exposed for formats that also support the 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.
• 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 SamplerYcbcrConversionCreateInfo xChromaOffset and/or yChromaOffset of CHROMA_LOCATION_MIDPOINT. Otherwise both xChromaOffset and yChromaOffset must be 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 FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT.
• 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 SamplerYcbcrConversionCreateInfo xChromaOffset and/or yChromaOffset of CHROMA_LOCATION_COSITED_EVEN. Otherwise both xChromaOffset and yChromaOffset must be CHROMA_LOCATION_MIDPOINT. If neither FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT nor FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT is set, the application must not define a sampler Y′CBCR conversion using this format as a source.
• 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.
• FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT specifies that the format can have different chroma, min, and mag filters.
• FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT specifies that reconstruction is explicit, as described in https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#textures-chroma-reconstruction. If this bit is not present, reconstruction is implicit by default.
• FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT specifies that reconstruction can be forcibly made explicit by setting SamplerYcbcrConversionCreateInfo::forceExplicitReconstruction to TRUE. If the format being queried supports FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT it must also support FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT.
• FORMAT_FEATURE_DISJOINT_BIT specifies that a multi-planar image can have the IMAGE_CREATE_DISJOINT_BIT set during image creation. An implementation must not set FORMAT_FEATURE_DISJOINT_BIT for single-plane formats.
• FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT specifies that an image view can be used as a fragment density map attachment.
• FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR specifies that an image view can be used as a fragment shading rate attachment. An implementation must not set this feature for formats that with numeric type other than *UINT, or set it as a buffer feature.

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

• FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT specifies that the format can be used to create a buffer view that can be bound to a DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER descriptor.
• FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT specifies that the format can be used to create a buffer view that can be bound to a DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER descriptor.
• FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT specifies that atomic operations are supported on DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER with this format.
• FORMAT_FEATURE_VERTEX_BUFFER_BIT specifies that the format can be used as a vertex attribute format (VertexInputAttributeDescription::format).

See Also

FormatFeatureFlags

Constructors

FormatFeatureFlagBits Flags

Bundled Patterns

pattern FORMAT_FEATURE_SAMPLED_IMAGE_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_SAMPLED_IMAGE_BIT specifies that an image view can be sampled from.

pattern FORMAT_FEATURE_STORAGE_IMAGE_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_STORAGE_IMAGE_BIT specifies that an image view can be used as a storage images.

pattern FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT specifies that an image view can be used as storage image that supports atomic operations.

pattern FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT specifies that the format can be used to create a buffer view that can be bound to a DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER descriptor.

pattern FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT specifies that the format can be used to create a buffer view that can be bound to a DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER descriptor.

pattern FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT specifies that atomic operations are supported on DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER with this format.

pattern FORMAT_FEATURE_VERTEX_BUFFER_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_VERTEX_BUFFER_BIT specifies that the format can be used as a vertex attribute format (VertexInputAttributeDescription::format).

pattern FORMAT_FEATURE_COLOR_ATTACHMENT_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_COLOR_ATTACHMENT_BIT specifies that an image view can be used as a framebuffer color attachment and as an input attachment.

pattern FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT :: FormatFeatureFlagBits

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.

pattern FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT :: FormatFeatureFlagBits

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.

pattern FORMAT_FEATURE_BLIT_SRC_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_BLIT_SRC_BIT specifies that an image can be used as srcImage for the cmdBlitImage2KHR and cmdBlitImage commands.

pattern FORMAT_FEATURE_BLIT_DST_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_BLIT_DST_BIT specifies that an image can be used as dstImage for the cmdBlitImage2KHR and cmdBlitImage commands.

pattern FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT specifies that if 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 FILTER_LINEAR, or mipmapMode set to SAMPLER_MIPMAP_MODE_LINEAR. If FORMAT_FEATURE_BLIT_SRC_BIT is also set, an image can be used as the srcImage to cmdBlitImage2KHR and cmdBlitImage with a filter of FILTER_LINEAR. This bit must only be exposed for formats that also support the FORMAT_FEATURE_SAMPLED_IMAGE_BIT or 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.

pattern FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR :: FormatFeatureFlagBits

FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR specifies that an image view can be used as a fragment shading rate attachment. An implementation must not set this feature for formats that with numeric type other than *UINT, or set it as a buffer feature.

pattern FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT :: FormatFeatureFlagBits

FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT specifies that an image view can be used as a fragment density map attachment.

pattern FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR :: FormatFeatureFlagBits

pattern FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG :: FormatFeatureFlagBits

pattern FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT specifies Image can be used as a sampled image with a min or max SamplerReductionMode. This bit must only be exposed for formats that also support the FORMAT_FEATURE_SAMPLED_IMAGE_BIT.

pattern FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT :: FormatFeatureFlagBits

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 SamplerYcbcrConversionCreateInfo xChromaOffset and/or yChromaOffset of CHROMA_LOCATION_COSITED_EVEN. Otherwise both xChromaOffset and yChromaOffset must be CHROMA_LOCATION_MIDPOINT. If neither FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT nor FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT is set, the application must not define a sampler Y′CBCR conversion using this format as a source.

pattern FORMAT_FEATURE_DISJOINT_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_DISJOINT_BIT specifies that a multi-planar image can have the IMAGE_CREATE_DISJOINT_BIT set during image creation. An implementation must not set FORMAT_FEATURE_DISJOINT_BIT for single-plane formats.

pattern FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT specifies that reconstruction can be forcibly made explicit by setting SamplerYcbcrConversionCreateInfo::forceExplicitReconstruction to TRUE. If the format being queried supports FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT it must also support FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT.

pattern FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT specifies that reconstruction is explicit, as described in https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#textures-chroma-reconstruction. If this bit is not present, reconstruction is implicit by default.

pattern FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT specifies that the format can have different chroma, min, and mag filters.

pattern FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT :: FormatFeatureFlagBits

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.

pattern FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT :: FormatFeatureFlagBits

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 SamplerYcbcrConversionCreateInfo xChromaOffset and/or yChromaOffset of CHROMA_LOCATION_MIDPOINT. Otherwise both xChromaOffset and yChromaOffset must be 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 FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT.

pattern FORMAT_FEATURE_TRANSFER_DST_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_TRANSFER_DST_BIT specifies that an image can be used as a destination image for copy commands and clear commands.

pattern FORMAT_FEATURE_TRANSFER_SRC_BIT :: FormatFeatureFlagBits

FORMAT_FEATURE_TRANSFER_SRC_BIT specifies that an image can be used as a source image for copy commands.

Instances

Eq FormatFeatureFlagBits

Defined in Vulkan.Core10.Enums.FormatFeatureFlagBits

Methods

(==) :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> Bool

(/=) :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> Bool

Ord FormatFeatureFlagBits

Defined in Vulkan.Core10.Enums.FormatFeatureFlagBits

Methods

compare :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> Ordering

(<) :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> Bool

(<=) :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> Bool

(>) :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> Bool

(>=) :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> Bool

max :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> FormatFeatureFlagBits

min :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> FormatFeatureFlagBits

Read FormatFeatureFlagBits

Defined in Vulkan.Core10.Enums.FormatFeatureFlagBits

Methods

readsPrec :: Int -> ReadS FormatFeatureFlagBits

readList :: ReadS [FormatFeatureFlagBits]

readPrec :: ReadPrec FormatFeatureFlagBits

readListPrec :: ReadPrec [FormatFeatureFlagBits]

Show FormatFeatureFlagBits

Defined in Vulkan.Core10.Enums.FormatFeatureFlagBits

Methods

showsPrec :: Int -> FormatFeatureFlagBits -> ShowS

show :: FormatFeatureFlagBits -> String

showList :: [FormatFeatureFlagBits] -> ShowS

Storable FormatFeatureFlagBits

Defined in Vulkan.Core10.Enums.FormatFeatureFlagBits

Methods

sizeOf :: FormatFeatureFlagBits -> Int

alignment :: FormatFeatureFlagBits -> Int

peekElemOff :: Ptr FormatFeatureFlagBits -> Int -> IO FormatFeatureFlagBits

pokeElemOff :: Ptr FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits -> IO ()

peekByteOff :: Ptr b -> Int -> IO FormatFeatureFlagBits

pokeByteOff :: Ptr b -> Int -> FormatFeatureFlagBits -> IO ()

peek :: Ptr FormatFeatureFlagBits -> IO FormatFeatureFlagBits

poke :: Ptr FormatFeatureFlagBits -> FormatFeatureFlagBits -> IO ()

Bits FormatFeatureFlagBits

Defined in Vulkan.Core10.Enums.FormatFeatureFlagBits

Methods

(.&.) :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> FormatFeatureFlagBits

(.|.) :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> FormatFeatureFlagBits

xor :: FormatFeatureFlagBits -> FormatFeatureFlagBits -> FormatFeatureFlagBits

complement :: FormatFeatureFlagBits -> FormatFeatureFlagBits

shift :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

rotate :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

zeroBits :: FormatFeatureFlagBits

bit :: Int -> FormatFeatureFlagBits

setBit :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

clearBit :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

complementBit :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

testBit :: FormatFeatureFlagBits -> Int -> Bool

bitSizeMaybe :: FormatFeatureFlagBits -> Maybe Int

bitSize :: FormatFeatureFlagBits -> Int

isSigned :: FormatFeatureFlagBits -> Bool

shiftL :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

unsafeShiftL :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

shiftR :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

unsafeShiftR :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

rotateL :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

rotateR :: FormatFeatureFlagBits -> Int -> FormatFeatureFlagBits

popCount :: FormatFeatureFlagBits -> Int

Zero FormatFeatureFlagBits

Defined in Vulkan.Core10.Enums.FormatFeatureFlagBits

Methods

zero :: FormatFeatureFlagBits

type FormatFeatureFlags = FormatFeatureFlagBits

newtype SampleCountFlagBits

VkSampleCountFlagBits - Bitmask specifying sample counts supported for an image used for storage operations

See Also

AttachmentDescription, AttachmentDescription2, FramebufferMixedSamplesCombinationNV, ImageCreateInfo, PhysicalDeviceFragmentShadingRatePropertiesKHR, PhysicalDeviceSparseImageFormatInfo2, PipelineMultisampleStateCreateInfo, SampleCountFlags, SampleLocationsInfoEXT, getPhysicalDeviceMultisamplePropertiesEXT, getPhysicalDeviceSparseImageFormatProperties

Constructors

SampleCountFlagBits Flags

Bundled Patterns

pattern SAMPLE_COUNT_1_BIT :: SampleCountFlagBits

SAMPLE_COUNT_1_BIT specifies an image with one sample per pixel.

pattern SAMPLE_COUNT_2_BIT :: SampleCountFlagBits

SAMPLE_COUNT_2_BIT specifies an image with 2 samples per pixel.

pattern SAMPLE_COUNT_4_BIT :: SampleCountFlagBits

SAMPLE_COUNT_4_BIT specifies an image with 4 samples per pixel.

pattern SAMPLE_COUNT_8_BIT :: SampleCountFlagBits

SAMPLE_COUNT_8_BIT specifies an image with 8 samples per pixel.

pattern SAMPLE_COUNT_16_BIT :: SampleCountFlagBits

SAMPLE_COUNT_16_BIT specifies an image with 16 samples per pixel.

pattern SAMPLE_COUNT_32_BIT :: SampleCountFlagBits

SAMPLE_COUNT_32_BIT specifies an image with 32 samples per pixel.

pattern SAMPLE_COUNT_64_BIT :: SampleCountFlagBits

SAMPLE_COUNT_64_BIT specifies an image with 64 samples per pixel.

Instances

Eq SampleCountFlagBits

Defined in Vulkan.Core10.Enums.SampleCountFlagBits

Methods

(==) :: SampleCountFlagBits -> SampleCountFlagBits -> Bool

(/=) :: SampleCountFlagBits -> SampleCountFlagBits -> Bool

Ord SampleCountFlagBits

Defined in Vulkan.Core10.Enums.SampleCountFlagBits

Methods

compare :: SampleCountFlagBits -> SampleCountFlagBits -> Ordering

(<) :: SampleCountFlagBits -> SampleCountFlagBits -> Bool

(<=) :: SampleCountFlagBits -> SampleCountFlagBits -> Bool

(>) :: SampleCountFlagBits -> SampleCountFlagBits -> Bool

(>=) :: SampleCountFlagBits -> SampleCountFlagBits -> Bool

max :: SampleCountFlagBits -> SampleCountFlagBits -> SampleCountFlagBits

min :: SampleCountFlagBits -> SampleCountFlagBits -> SampleCountFlagBits

Read SampleCountFlagBits

Defined in Vulkan.Core10.Enums.SampleCountFlagBits

Methods

readsPrec :: Int -> ReadS SampleCountFlagBits

readList :: ReadS [SampleCountFlagBits]

readPrec :: ReadPrec SampleCountFlagBits

readListPrec :: ReadPrec [SampleCountFlagBits]

Show SampleCountFlagBits

Defined in Vulkan.Core10.Enums.SampleCountFlagBits

Methods

showsPrec :: Int -> SampleCountFlagBits -> ShowS

show :: SampleCountFlagBits -> String

showList :: [SampleCountFlagBits] -> ShowS

Storable SampleCountFlagBits

Defined in Vulkan.Core10.Enums.SampleCountFlagBits

Methods

sizeOf :: SampleCountFlagBits -> Int

alignment :: SampleCountFlagBits -> Int

peekElemOff :: Ptr SampleCountFlagBits -> Int -> IO SampleCountFlagBits

pokeElemOff :: Ptr SampleCountFlagBits -> Int -> SampleCountFlagBits -> IO ()

peekByteOff :: Ptr b -> Int -> IO SampleCountFlagBits

pokeByteOff :: Ptr b -> Int -> SampleCountFlagBits -> IO ()

peek :: Ptr SampleCountFlagBits -> IO SampleCountFlagBits

poke :: Ptr SampleCountFlagBits -> SampleCountFlagBits -> IO ()

Bits SampleCountFlagBits

Defined in Vulkan.Core10.Enums.SampleCountFlagBits

Methods

(.&.) :: SampleCountFlagBits -> SampleCountFlagBits -> SampleCountFlagBits

(.|.) :: SampleCountFlagBits -> SampleCountFlagBits -> SampleCountFlagBits

xor :: SampleCountFlagBits -> SampleCountFlagBits -> SampleCountFlagBits

complement :: SampleCountFlagBits -> SampleCountFlagBits

shift :: SampleCountFlagBits -> Int -> SampleCountFlagBits

rotate :: SampleCountFlagBits -> Int -> SampleCountFlagBits

zeroBits :: SampleCountFlagBits

bit :: Int -> SampleCountFlagBits

setBit :: SampleCountFlagBits -> Int -> SampleCountFlagBits

clearBit :: SampleCountFlagBits -> Int -> SampleCountFlagBits

complementBit :: SampleCountFlagBits -> Int -> SampleCountFlagBits

testBit :: SampleCountFlagBits -> Int -> Bool

bitSizeMaybe :: SampleCountFlagBits -> Maybe Int

bitSize :: SampleCountFlagBits -> Int

isSigned :: SampleCountFlagBits -> Bool

shiftL :: SampleCountFlagBits -> Int -> SampleCountFlagBits

unsafeShiftL :: SampleCountFlagBits -> Int -> SampleCountFlagBits

shiftR :: SampleCountFlagBits -> Int -> SampleCountFlagBits

unsafeShiftR :: SampleCountFlagBits -> Int -> SampleCountFlagBits

rotateL :: SampleCountFlagBits -> Int -> SampleCountFlagBits

rotateR :: SampleCountFlagBits -> Int -> SampleCountFlagBits

popCount :: SampleCountFlagBits -> Int

Zero SampleCountFlagBits

Defined in Vulkan.Core10.Enums.SampleCountFlagBits

Methods

zero :: SampleCountFlagBits

type SampleCountFlags = SampleCountFlagBits

type FN_vkInternalAllocationNotification = ("pUserData" ::: Ptr ()) -> CSize -> InternalAllocationType -> SystemAllocationScope -> IO ()

type PFN_vkInternalAllocationNotification = FunPtr FN_vkInternalAllocationNotification

PFN_vkInternalAllocationNotification - Application-defined memory allocation notification function

Description

This is a purely informational callback.

See Also

AllocationCallbacks

type FN_vkInternalFreeNotification = ("pUserData" ::: Ptr ()) -> CSize -> InternalAllocationType -> SystemAllocationScope -> IO ()

type PFN_vkInternalFreeNotification = FunPtr FN_vkInternalFreeNotification

PFN_vkInternalFreeNotification - Application-defined memory free notification function

See Also

AllocationCallbacks

type FN_vkReallocationFunction = ("pUserData" ::: Ptr ()) -> ("pOriginal" ::: Ptr ()) -> CSize -> ("alignment" ::: CSize) -> SystemAllocationScope -> IO (Ptr ())

type PFN_vkReallocationFunction = FunPtr FN_vkReallocationFunction

PFN_vkReallocationFunction - Application-defined memory reallocation function

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.

See Also

AllocationCallbacks

type FN_vkAllocationFunction = ("pUserData" ::: Ptr ()) -> CSize -> ("alignment" ::: CSize) -> SystemAllocationScope -> IO (Ptr ())

type PFN_vkAllocationFunction = FunPtr FN_vkAllocationFunction

PFN_vkAllocationFunction - Application-defined memory allocation function

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 Instance objects are going to operate correctly (even destroyInstance), 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 runtime error, and generate 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 ERROR_OUT_OF_HOST_MEMORY as a result of this failed allocation.

See Also

AllocationCallbacks

type FN_vkFreeFunction = ("pUserData" ::: Ptr ()) -> ("pMemory" ::: Ptr ()) -> IO ()

type PFN_vkFreeFunction = FunPtr FN_vkFreeFunction

PFN_vkFreeFunction - Application-defined memory free function

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.

See Also

AllocationCallbacks

type FN_vkVoidFunction = () -> IO ()

type PFN_vkVoidFunction = FunPtr FN_vkVoidFunction

PFN_vkVoidFunction - Placeholder function pointer type returned by queries

See Also

getDeviceProcAddr, getInstanceProcAddr