vulkan-3.6.11.1: Bindings to the Vulkan graphics API.
Safe HaskellNone
LanguageHaskell2010

Vulkan.Core10.DeviceInitialization

Synopsis

Documentation

createInstance Source #

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

Valid Usage (Implicit)

  • 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
Failure

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 Source #

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 Source #

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 Source #

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
Failure

See Also

Instance, PhysicalDevice

getDeviceProcAddr Source #

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 Source #

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 Source #

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 Source #

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)

  • 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 Source #

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 Source #

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 Source #

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 Source #

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
Failure

See Also

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

data PhysicalDeviceProperties Source #

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

data ApplicationInfo Source #

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)

  • 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

data InstanceCreateInfo (es :: [Type]) Source #

VkInstanceCreateInfo - Structure specifying parameters of a newly created instance

Valid Usage (Implicit)

  • 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

Instances

Instances details
Extensible InstanceCreateInfo Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Methods

extensibleType :: StructureType Source #

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

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

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

Show (Chain es) => Show (InstanceCreateInfo es) Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

(Extendss InstanceCreateInfo es, PeekChain es) => FromCStruct (InstanceCreateInfo es) Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

(Extendss InstanceCreateInfo es, PokeChain es) => ToCStruct (InstanceCreateInfo es) Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

es ~ ('[] :: [Type]) => Zero (InstanceCreateInfo es) Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

data QueueFamilyProperties Source #

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.

data PhysicalDeviceMemoryProperties Source #

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:

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

data MemoryType Source #

VkMemoryType - Structure specifying memory type

See Also

MemoryPropertyFlags, PhysicalDeviceMemoryProperties

Constructors

MemoryType 

Fields

Instances

Instances details
Eq MemoryType Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Show MemoryType Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Storable MemoryType Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

FromCStruct MemoryType Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

ToCStruct MemoryType Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Zero MemoryType Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

data MemoryHeap Source #

VkMemoryHeap - Structure specifying a memory heap

See Also

DeviceSize, MemoryHeapFlags, PhysicalDeviceMemoryProperties

Constructors

MemoryHeap 

Fields

Instances

Instances details
Eq MemoryHeap Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Show MemoryHeap Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Storable MemoryHeap Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

FromCStruct MemoryHeap Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

ToCStruct MemoryHeap Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Zero MemoryHeap Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

data FormatProperties Source #

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

Instances

Instances details
Eq FormatProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Show FormatProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Storable FormatProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

FromCStruct FormatProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

ToCStruct FormatProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Zero FormatProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

data ImageFormatProperties Source #

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.

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

data PhysicalDeviceFeatures Source #

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

Instances

Instances details
Eq PhysicalDeviceFeatures Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Show PhysicalDeviceFeatures Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Storable PhysicalDeviceFeatures Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

FromCStruct PhysicalDeviceFeatures Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

ToCStruct PhysicalDeviceFeatures Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Zero PhysicalDeviceFeatures Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

data PhysicalDeviceSparseProperties Source #

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

Instances details
Eq PhysicalDeviceSparseProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Show PhysicalDeviceSparseProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Storable PhysicalDeviceSparseProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

FromCStruct PhysicalDeviceSparseProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

ToCStruct PhysicalDeviceSparseProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Zero PhysicalDeviceSparseProperties Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

data PhysicalDeviceLimits Source #

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

Instances

Instances details
Eq PhysicalDeviceLimits Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Show PhysicalDeviceLimits Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Storable PhysicalDeviceLimits Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

FromCStruct PhysicalDeviceLimits Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

ToCStruct PhysicalDeviceLimits Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

Zero PhysicalDeviceLimits Source # 
Instance details

Defined in Vulkan.Core10.DeviceInitialization

data Instance Source #

Instances

Instances details
Eq Instance Source # 
Instance details

Defined in Vulkan.Core10.Handles

Show Instance Source # 
Instance details

Defined in Vulkan.Core10.Handles

Zero Instance Source # 
Instance details

Defined in Vulkan.Core10.Handles

Methods

zero :: Instance Source #

HasObjectType Instance Source # 
Instance details

Defined in Vulkan.Core10.Handles

IsHandle Instance Source # 
Instance details

Defined in Vulkan.Core10.Handles

data PhysicalDevice Source #

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

data AllocationCallbacks Source #

VkAllocationCallbacks - Structure containing callback function pointers for memory allocation

Valid Usage

  • 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

Instances

Instances details
Show AllocationCallbacks Source # 
Instance details

Defined in Vulkan.Core10.AllocationCallbacks

Storable AllocationCallbacks Source # 
Instance details

Defined in Vulkan.Core10.AllocationCallbacks

FromCStruct AllocationCallbacks Source # 
Instance details

Defined in Vulkan.Core10.AllocationCallbacks

ToCStruct AllocationCallbacks Source # 
Instance details

Defined in Vulkan.Core10.AllocationCallbacks

Zero AllocationCallbacks Source # 
Instance details

Defined in Vulkan.Core10.AllocationCallbacks

newtype InstanceCreateFlags Source #

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

Instances

Instances details
Eq InstanceCreateFlags Source # 
Instance details

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Ord InstanceCreateFlags Source # 
Instance details

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Read InstanceCreateFlags Source # 
Instance details

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Show InstanceCreateFlags Source # 
Instance details

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Storable InstanceCreateFlags Source # 
Instance details

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Bits InstanceCreateFlags Source # 
Instance details

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

Zero InstanceCreateFlags Source # 
Instance details

Defined in Vulkan.Core10.Enums.InstanceCreateFlags

newtype ImageType Source #

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

Instances details
Eq ImageType Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageType

Ord ImageType Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageType

Read ImageType Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageType

Show ImageType Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageType

Storable ImageType Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageType

Zero ImageType Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageType

newtype ImageTiling Source #

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

Instances details
Eq ImageTiling Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageTiling

Ord ImageTiling Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageTiling

Read ImageTiling Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageTiling

Show ImageTiling Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageTiling

Storable ImageTiling Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageTiling

Zero ImageTiling Source # 
Instance details

Defined in Vulkan.Core10.Enums.ImageTiling

newtype InternalAllocationType Source #

VkInternalAllocationType - Allocation type

See Also

PFN_vkInternalAllocationNotification, PFN_vkInternalFreeNotification

Bundled Patterns

pattern INTERNAL_ALLOCATION_TYPE_EXECUTABLE :: InternalAllocationType

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

Instances

Instances details
Eq InternalAllocationType Source # 
Instance details

Defined in Vulkan.Core10.Enums.InternalAllocationType

Ord InternalAllocationType Source # 
Instance details

Defined in Vulkan.Core10.Enums.InternalAllocationType

Read InternalAllocationType Source # 
Instance details

Defined in Vulkan.Core10.Enums.InternalAllocationType

Show InternalAllocationType Source # 
Instance details

Defined in Vulkan.Core10.Enums.InternalAllocationType

Storable InternalAllocationType Source # 
Instance details

Defined in Vulkan.Core10.Enums.InternalAllocationType

Zero InternalAllocationType Source # 
Instance details

Defined in Vulkan.Core10.Enums.InternalAllocationType

newtype SystemAllocationScope Source #

VkSystemAllocationScope - Allocation scope

Description

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

Instances

Instances details
Eq SystemAllocationScope Source # 
Instance details

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Ord SystemAllocationScope Source # 
Instance details

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Read SystemAllocationScope Source # 
Instance details

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Show SystemAllocationScope Source # 
Instance details

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Storable SystemAllocationScope Source # 
Instance details

Defined in Vulkan.Core10.Enums.SystemAllocationScope

Zero SystemAllocationScope Source # 
Instance details

Defined in Vulkan.Core10.Enums.SystemAllocationScope

newtype PhysicalDeviceType Source #

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

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

Instances details
Eq PhysicalDeviceType Source # 
Instance details

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Ord PhysicalDeviceType Source # 
Instance details

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Read PhysicalDeviceType Source # 
Instance details

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Show PhysicalDeviceType Source # 
Instance details

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Storable PhysicalDeviceType Source # 
Instance details

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

Zero PhysicalDeviceType Source # 
Instance details

Defined in Vulkan.Core10.Enums.PhysicalDeviceType

newtype Format Source #

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 speci