Safe Haskell	None
Language	Haskell2010

Graphics.Vulkan.Core10.DeviceInitialization

Synopsis

createInstance :: PokeChain a => InstanceCreateInfo a -> ("allocator" ::: Maybe AllocationCallbacks) -> IO Instance
withInstance :: PokeChain a => InstanceCreateInfo a -> Maybe AllocationCallbacks -> (Instance -> IO r) -> IO r
destroyInstance :: Instance -> ("allocator" ::: Maybe AllocationCallbacks) -> IO ()
enumeratePhysicalDevices :: Instance -> IO (Result, "physicalDevices" ::: Vector PhysicalDevice)
getDeviceProcAddr :: Device -> ("name" ::: ByteString) -> IO PFN_vkVoidFunction
getInstanceProcAddr :: Instance -> ("name" ::: ByteString) -> IO PFN_vkVoidFunction
getPhysicalDeviceProperties :: PhysicalDevice -> IO PhysicalDeviceProperties
getPhysicalDeviceQueueFamilyProperties :: PhysicalDevice -> IO ("queueFamilyProperties" ::: Vector QueueFamilyProperties)
getPhysicalDeviceMemoryProperties :: PhysicalDevice -> IO PhysicalDeviceMemoryProperties
getPhysicalDeviceFeatures :: PhysicalDevice -> IO PhysicalDeviceFeatures
getPhysicalDeviceFormatProperties :: PhysicalDevice -> Format -> IO FormatProperties
getPhysicalDeviceImageFormatProperties :: PhysicalDevice -> Format -> ImageType -> ImageTiling -> ImageUsageFlags -> ImageCreateFlags -> IO ImageFormatProperties
data PhysicalDeviceProperties = PhysicalDeviceProperties {
- apiVersion :: Word32
- driverVersion :: Word32
- vendorID :: Word32
- deviceID :: Word32
- deviceType :: PhysicalDeviceType
- deviceName :: ByteString
- pipelineCacheUUID :: ByteString
- limits :: PhysicalDeviceLimits
- sparseProperties :: PhysicalDeviceSparseProperties
}
data ApplicationInfo = ApplicationInfo {
- applicationName :: Maybe ByteString
- applicationVersion :: Word32
- engineName :: Maybe ByteString
- engineVersion :: Word32
- apiVersion :: Word32
}
data InstanceCreateInfo (es :: [Type]) = InstanceCreateInfo {
- next :: Chain es
- flags :: InstanceCreateFlags
- applicationInfo :: Maybe ApplicationInfo
- enabledLayerNames :: Vector ByteString
- enabledExtensionNames :: Vector ByteString
}
data QueueFamilyProperties = QueueFamilyProperties {
- queueFlags :: QueueFlags
- queueCount :: Word32
- timestampValidBits :: Word32
- minImageTransferGranularity :: Extent3D
}
data PhysicalDeviceMemoryProperties = PhysicalDeviceMemoryProperties {
- memoryTypeCount :: Word32
- memoryTypes :: Vector MemoryType
- memoryHeapCount :: Word32
- memoryHeaps :: Vector MemoryHeap
}
data MemoryType = MemoryType {
- propertyFlags :: MemoryPropertyFlags
- heapIndex :: Word32
}
data MemoryHeap = MemoryHeap {
- size :: DeviceSize
- flags :: MemoryHeapFlags
}
data FormatProperties = FormatProperties {
- linearTilingFeatures :: FormatFeatureFlags
- optimalTilingFeatures :: FormatFeatureFlags
- bufferFeatures :: FormatFeatureFlags
}
data ImageFormatProperties = ImageFormatProperties {
- maxExtent :: Extent3D
- maxMipLevels :: Word32
- maxArrayLayers :: Word32
- sampleCounts :: SampleCountFlags
- maxResourceSize :: DeviceSize
}
data PhysicalDeviceFeatures = PhysicalDeviceFeatures {
- robustBufferAccess :: Bool
- fullDrawIndexUint32 :: Bool
- imageCubeArray :: Bool
- independentBlend :: Bool
- geometryShader :: Bool
- tessellationShader :: Bool
- sampleRateShading :: Bool
- dualSrcBlend :: Bool
- logicOp :: Bool
- multiDrawIndirect :: Bool
- drawIndirectFirstInstance :: Bool
- depthClamp :: Bool
- depthBiasClamp :: Bool
- fillModeNonSolid :: Bool
- depthBounds :: Bool
- wideLines :: Bool
- largePoints :: Bool
- alphaToOne :: Bool
- multiViewport :: Bool
- samplerAnisotropy :: Bool
- textureCompressionETC2 :: Bool
- textureCompressionASTC_LDR :: Bool
- textureCompressionBC :: Bool
- occlusionQueryPrecise :: Bool
- pipelineStatisticsQuery :: Bool
- vertexPipelineStoresAndAtomics :: Bool
- fragmentStoresAndAtomics :: Bool
- shaderTessellationAndGeometryPointSize :: Bool
- shaderImageGatherExtended :: Bool
- shaderStorageImageExtendedFormats :: Bool
- shaderStorageImageMultisample :: Bool
- shaderStorageImageReadWithoutFormat :: Bool
- shaderStorageImageWriteWithoutFormat :: Bool
- shaderUniformBufferArrayDynamicIndexing :: Bool
- shaderSampledImageArrayDynamicIndexing :: Bool
- shaderStorageBufferArrayDynamicIndexing :: Bool
- shaderStorageImageArrayDynamicIndexing :: Bool
- shaderClipDistance :: Bool
- shaderCullDistance :: Bool
- shaderFloat64 :: Bool
- shaderInt64 :: Bool
- shaderInt16 :: Bool
- shaderResourceResidency :: Bool
- shaderResourceMinLod :: Bool
- sparseBinding :: Bool
- sparseResidencyBuffer :: Bool
- sparseResidencyImage2D :: Bool
- sparseResidencyImage3D :: Bool
- sparseResidency2Samples :: Bool
- sparseResidency4Samples :: Bool
- sparseResidency8Samples :: Bool
- sparseResidency16Samples :: Bool
- sparseResidencyAliased :: Bool
- variableMultisampleRate :: Bool
- inheritedQueries :: Bool
}
data PhysicalDeviceSparseProperties = PhysicalDeviceSparseProperties {
- residencyStandard2DBlockShape :: Bool
- residencyStandard2DMultisampleBlockShape :: Bool
- residencyStandard3DBlockShape :: Bool
- residencyAlignedMipSize :: Bool
- residencyNonResidentStrict :: Bool
}
data PhysicalDeviceLimits = PhysicalDeviceLimits {
- maxImageDimension1D :: Word32
- maxImageDimension2D :: Word32
- maxImageDimension3D :: Word32
- maxImageDimensionCube :: Word32
- maxImageArrayLayers :: Word32
- maxTexelBufferElements :: Word32
- maxUniformBufferRange :: Word32
- maxStorageBufferRange :: Word32
- maxPushConstantsSize :: Word32
- maxMemoryAllocationCount :: Word32
- maxSamplerAllocationCount :: Word32
- bufferImageGranularity :: DeviceSize
- sparseAddressSpaceSize :: DeviceSize
- maxBoundDescriptorSets :: Word32
- maxPerStageDescriptorSamplers :: Word32
- maxPerStageDescriptorUniformBuffers :: Word32
- maxPerStageDescriptorStorageBuffers :: Word32
- maxPerStageDescriptorSampledImages :: Word32
- maxPerStageDescriptorStorageImages :: Word32
- maxPerStageDescriptorInputAttachments :: Word32
- maxPerStageResources :: Word32
- maxDescriptorSetSamplers :: Word32
- maxDescriptorSetUniformBuffers :: Word32
- maxDescriptorSetUniformBuffersDynamic :: Word32
- maxDescriptorSetStorageBuffers :: Word32
- maxDescriptorSetStorageBuffersDynamic :: Word32
- maxDescriptorSetSampledImages :: Word32
- maxDescriptorSetStorageImages :: Word32
- maxDescriptorSetInputAttachments :: Word32
- maxVertexInputAttributes :: Word32
- maxVertexInputBindings :: Word32
- maxVertexInputAttributeOffset :: Word32
- maxVertexInputBindingStride :: Word32
- maxVertexOutputComponents :: Word32
- maxTessellationGenerationLevel :: Word32
- maxTessellationPatchSize :: Word32
- maxTessellationControlPerVertexInputComponents :: Word32
- maxTessellationControlPerVertexOutputComponents :: Word32
- maxTessellationControlPerPatchOutputComponents :: Word32
- maxTessellationControlTotalOutputComponents :: Word32
- maxTessellationEvaluationInputComponents :: Word32
- maxTessellationEvaluationOutputComponents :: Word32
- maxGeometryShaderInvocations :: Word32
- maxGeometryInputComponents :: Word32
- maxGeometryOutputComponents :: Word32
- maxGeometryOutputVertices :: Word32
- maxGeometryTotalOutputComponents :: Word32
- maxFragmentInputComponents :: Word32
- maxFragmentOutputAttachments :: Word32
- maxFragmentDualSrcAttachments :: Word32
- maxFragmentCombinedOutputResources :: Word32
- maxComputeSharedMemorySize :: Word32
- maxComputeWorkGroupCount :: (Word32, Word32, Word32)
- maxComputeWorkGroupInvocations :: Word32
- maxComputeWorkGroupSize :: (Word32, Word32, Word32)
- subPixelPrecisionBits :: Word32
- subTexelPrecisionBits :: Word32
- mipmapPrecisionBits :: Word32
- maxDrawIndexedIndexValue :: Word32
- maxDrawIndirectCount :: Word32
- maxSamplerLodBias :: Float
- maxSamplerAnisotropy :: Float
- maxViewports :: Word32
- maxViewportDimensions :: (Word32, Word32)
- viewportBoundsRange :: (Float, Float)
- viewportSubPixelBits :: Word32
- minMemoryMapAlignment :: Word64
- minTexelBufferOffsetAlignment :: DeviceSize
- minUniformBufferOffsetAlignment :: DeviceSize
- minStorageBufferOffsetAlignment :: DeviceSize
- minTexelOffset :: Int32
- maxTexelOffset :: Word32
- minTexelGatherOffset :: Int32
- maxTexelGatherOffset :: Word32
- minInterpolationOffset :: Float
- maxInterpolationOffset :: Float
- subPixelInterpolationOffsetBits :: Word32
- maxFramebufferWidth :: Word32
- maxFramebufferHeight :: Word32
- maxFramebufferLayers :: Word32
- framebufferColorSampleCounts :: SampleCountFlags
- framebufferDepthSampleCounts :: SampleCountFlags
- framebufferStencilSampleCounts :: SampleCountFlags
- framebufferNoAttachmentsSampleCounts :: SampleCountFlags
- maxColorAttachments :: Word32
- sampledImageColorSampleCounts :: SampleCountFlags
- sampledImageIntegerSampleCounts :: SampleCountFlags
- sampledImageDepthSampleCounts :: SampleCountFlags
- sampledImageStencilSampleCounts :: SampleCountFlags
- storageImageSampleCounts :: SampleCountFlags
- maxSampleMaskWords :: Word32
- timestampComputeAndGraphics :: Bool
- timestampPeriod :: Float
- maxClipDistances :: Word32
- maxCullDistances :: Word32
- maxCombinedClipAndCullDistances :: Word32
- discreteQueuePriorities :: Word32
- pointSizeRange :: (Float, Float)
- lineWidthRange :: (Float, Float)
- pointSizeGranularity :: Float
- lineWidthGranularity :: Float
- strictLines :: Bool
- standardSampleLocations :: Bool
- optimalBufferCopyOffsetAlignment :: DeviceSize
- optimalBufferCopyRowPitchAlignment :: DeviceSize
- nonCoherentAtomSize :: DeviceSize
}

Documentation

createInstance :: PokeChain a => InstanceCreateInfo a -> ("allocator" ::: Maybe AllocationCallbacks) -> IO Instance Source #

vkCreateInstance - Create a new Vulkan instance

Parameters

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

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

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

Parameters

Instance is the handle of the instance to destroy.

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

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

Parameters

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

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

Description

If pPhysicalDevices is NULL, then the number of physical devices available is returned in pPhysicalDeviceCount. Otherwise, pPhysicalDeviceCount must point to a variable set by the user to the number of elements in the pPhysicalDevices array, and on return the variable is overwritten with the number of handles actually written to pPhysicalDevices. If pPhysicalDeviceCount is less than the number of physical devices available, at most pPhysicalDeviceCount structures will be written. If pPhysicalDeviceCount is smaller than the number of physical devices available, 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

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. 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`

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

Parameters

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

pName is the name of the command to obtain.

Description

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.

`Instance`	`pName`	return value
*1	`NULL`	undefined
invalid non-`NULL` instance	*1	undefined
`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`

vkGetInstanceProcAddr 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.

Valid Usage (Implicit)

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

pName must be a null-terminated UTF-8 string

Parameters

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

pProperties is a pointer to a PhysicalDeviceProperties structure in which properties are returned.

Valid Usage (Implicit)

Parameters

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

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

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

Parameters

PhysicalDevice is the handle to the device to query.

pMemoryProperties is a pointer to a PhysicalDeviceMemoryProperties structure in which the properties are returned.

Valid Usage (Implicit)

Parameters

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

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

Valid Usage (Implicit)

Parameters

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

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

Valid Usage (Implicit)

Parameters

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

Format is a Format value specifying the image format, corresponding to 'Graphics.Vulkan.Core10.Image.ImageCreateInfo'::'Graphics.Vulkan.Core10.Enums.Format.Format'.
type is a ImageType value specifying the image type, corresponding to 'Graphics.Vulkan.Core10.Image.ImageCreateInfo'::'Graphics.Vulkan.Core10.Enums.ImageType.ImageType'.
tiling is a ImageTiling value specifying the image tiling, corresponding to ImageCreateInfo::tiling.
usage is a bitmask of ImageUsageFlagBits specifying the intended usage of the image, corresponding to ImageCreateInfo::usage.
Flags is a bitmask of ImageCreateFlagBits specifying additional parameters of the image, corresponding to 'Graphics.Vulkan.Core10.Image.ImageCreateInfo'::'Graphics.Vulkan.Core10.BaseType.Flags'.
pImageFormatProperties is a pointer to a ImageFormatProperties structure in which capabilities are returned.

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

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.

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 (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

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.

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'::'Graphics.Vulkan.Core10.BaseType.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:

either the set of bit flags returned in the propertyFlags member of X is a strict subset of the set of bit flags returned in the propertyFlags member of Y; or
the propertyFlags members of X and Y are equal, and X belongs to a memory heap with greater performance (as determined in an implementation-specific manner) ; or
or the propertyFlags members of X includes MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD or MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD and Y 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);

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.

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.

Members

The members of the PhysicalDeviceFeatures structure describe the following features:

robustBufferAccess :: Bool
robustBufferAccess specifies that accesses to buffers are bounds-checked against the range of the buffer descriptor (as determined by DescriptorBufferInfo::range, BufferViewCreateInfo::range, or the size of the buffer). Out of bounds accesses must not cause application termination, and the effects of shader loads, stores, and atomics must conform to an implementation-dependent behavior as described below.
- A buffer access is considered to be out of bounds if any of the following are true:
  - The pointer was formed by OpImageTexelPointer and the coordinate is less than zero or greater than or equal to the number of whole elements in the bound range.
  - The pointer was not formed by OpImageTexelPointer and the object pointed to is not wholly contained within the bound range. This includes accesses performed via variable pointers where the buffer descriptor being accessed cannot be statically determined. Uninitialized pointers and pointers equal to OpConstantNull are treated as pointing to a zero-sized object, so all accesses through such pointers are considered to be out of bounds. Buffer accesses through buffer device addresses are not bounds-checked. If the cooperativeMatrixRobustBufferAccess feature is not enabled, then accesses using OpCooperativeMatrixLoadNV and OpCooperativeMatrixStoreNV may not be bounds-checked.
    Note
    If a SPIR-V OpLoad instruction loads a structure and the tail end of the structure is out of bounds, then all members of the structure are considered out of bounds even if the members at the end are not statically used.
  - If any buffer access is determined to be out of bounds, then any other access of the same type (load, store, or atomic) to the same buffer that accesses an address less than 16 bytes away from the out of bounds address may also be considered out of bounds.
- Out-of-bounds buffer loads will return any of the following values:
  - Values from anywhere within the memory range(s) bound to the buffer (possibly including bytes of memory past the end of the buffer, up to the end of the bound range).
  - Zero values, or (0,0,0,x) vectors for vector reads where x is a valid value represented in the type of the vector components and may be any of:
    - 0, 1, or the maximum representable positive integer value, for signed or unsigned integer components
    - 0.0 or 1.0, for floating-point components
- Out-of-bounds writes may modify values within the memory range(s) bound to the buffer, but must not modify any other memory.
- Out-of-bounds atomics may modify values within the memory range(s) bound to the buffer, but must not modify any other memory, and return an undefined value.
- Vertex input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than either:
  - vertexBufferRangeSize, if bindingStride == 0; or
  - (vertexBufferRangeSize - (vertexBufferRangeSize % bindingStride))
  where vertexBufferRangeSize is the byte size of the memory range bound to the vertex buffer binding and bindingStride is the byte stride of the corresponding vertex input binding. Further, if any vertex input attribute using a specific vertex input binding is out of bounds, then all vertex input attributes using that vertex input binding for that vertex shader invocation are considered out of bounds.
  - If a vertex input attribute is out of bounds, it will be assigned one of the following values:
    - Values from anywhere within the memory range(s) bound to the buffer, converted according to the format of the attribute.
    - Zero values, format converted according to the format of the attribute.
    - Zero values, or (0,0,0,x) vectors, as described above.
- If robustBufferAccess is not enabled, applications must not perform out of bounds accesses.
fullDrawIndexUint32 :: Bool
fullDrawIndexUint32 specifies the full 32-bit range of indices is supported for indexed draw calls when using a IndexType of INDEX_TYPE_UINT32. maxDrawIndexedIndexValue is the maximum index value that may be used (aside from the primitive restart index, which is always 232-1 when the IndexType is INDEX_TYPE_UINT32). If this feature is supported, maxDrawIndexedIndexValue must be 232-1; otherwise it must be no smaller than 224-1. See maxDrawIndexedIndexValue.
imageCubeArray :: Bool
imageCubeArray specifies whether image views with a ImageViewType of IMAGE_VIEW_TYPE_CUBE_ARRAY can be created, and that the corresponding SampledCubeArray and ImageCubeArray SPIR-V capabilities can be used in shader code.
independentBlend :: Bool
independentBlend specifies whether the PipelineColorBlendAttachmentState settings are controlled independently per-attachment. If this feature is not enabled, the PipelineColorBlendAttachmentState settings for all color attachments must be identical. Otherwise, a different PipelineColorBlendAttachmentState can be provided for each bound color attachment.
geometryShader :: Bool
geometryShader specifies whether geometry shaders are supported. If this feature is not enabled, the SHADER_STAGE_GEOMETRY_BIT and PIPELINE_STAGE_GEOMETRY_SHADER_BIT enum values must not be used. This also specifies whether shader modules can declare the Geometry capability.
tessellationShader :: Bool
tessellationShader specifies whether tessellation control and evaluation shaders are supported. If this feature is not enabled, the SHADER_STAGE_TESSELLATION_CONTROL_BIT, SHADER_STAGE_TESSELLATION_EVALUATION_BIT, PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, and STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO enum values must not be used. This also specifies whether shader modules can declare the Tessellation capability.
sampleRateShading :: Bool
sampleRateShading specifies whether Sample Shading and multisample interpolation are supported. If this feature is not enabled, the sampleShadingEnable member of the PipelineMultisampleStateCreateInfo structure must be set to FALSE and the minSampleShading member is ignored. This also specifies whether shader modules can declare the SampleRateShading capability.
dualSrcBlend :: Bool
dualSrcBlend specifies whether blend operations which take two sources are supported. If this feature is not enabled, the BLEND_FACTOR_SRC1_COLOR, BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, BLEND_FACTOR_SRC1_ALPHA, and BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA enum values must not be used as source or destination blending factors. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#framebuffer-dsb.
logicOp :: Bool
LogicOp specifies whether logic operations are supported. If this feature is not enabled, the logicOpEnable member of the PipelineColorBlendStateCreateInfo structure must be set to FALSE, and the LogicOp member is ignored.
multiDrawIndirect :: Bool
multiDrawIndirect specifies whether multiple draw indirect is supported. If this feature is not enabled, the drawCount parameter to the cmdDrawIndirect and cmdDrawIndexedIndirect commands must be 0 or 1. The maxDrawIndirectCount member of the PhysicalDeviceLimits structure must also be 1 if this feature is not supported. See maxDrawIndirectCount.
drawIndirectFirstInstance :: Bool
drawIndirectFirstInstance specifies whether indirect draw calls support the firstInstance parameter. If this feature is not enabled, the firstInstance member of all DrawIndirectCommand and DrawIndexedIndirectCommand structures that are provided to the cmdDrawIndirect and cmdDrawIndexedIndirect commands must be 0.
depthClamp :: Bool
depthClamp specifies whether depth clamping is supported. If this feature is not enabled, the depthClampEnable member of the PipelineRasterizationStateCreateInfo structure must be set to FALSE. Otherwise, setting depthClampEnable to TRUE will enable depth clamping.
depthBiasClamp :: Bool
depthBiasClamp specifies whether depth bias clamping is supported. If this feature is not enabled, the depthBiasClamp member of the PipelineRasterizationStateCreateInfo structure must be set to 0.0 unless the DYNAMIC_STATE_DEPTH_BIAS dynamic state is enabled, and the depthBiasClamp parameter to cmdSetDepthBias must be set to 0.0.
fillModeNonSolid :: Bool
fillModeNonSolid specifies whether point and wireframe fill modes are supported. If this feature is not enabled, the POLYGON_MODE_POINT and POLYGON_MODE_LINE enum values must not be used.
depthBounds :: Bool
depthBounds specifies whether depth bounds tests are supported. If this feature is not enabled, the depthBoundsTestEnable member of the PipelineDepthStencilStateCreateInfo structure must be set to FALSE. When depthBoundsTestEnable is set to FALSE, the minDepthBounds and maxDepthBounds members of the PipelineDepthStencilStateCreateInfo structure are ignored.
wideLines :: Bool
wideLines specifies whether lines with width other than 1.0 are supported. If this feature is not enabled, the lineWidth member of the PipelineRasterizationStateCreateInfo structure must be set to 1.0 unless the DYNAMIC_STATE_LINE_WIDTH dynamic state is enabled, and the lineWidth parameter to cmdSetLineWidth must be set to 1.0. When this feature is supported, the range and granularity of supported line widths are indicated by the lineWidthRange and lineWidthGranularity members of the PhysicalDeviceLimits structure, respectively.
largePoints :: Bool
largePoints specifies whether points with size greater than 1.0 are supported. If this feature is not enabled, only a point size of 1.0 written by a shader is supported. The range and granularity of supported point sizes are indicated by the pointSizeRange and pointSizeGranularity members of the PhysicalDeviceLimits structure, respectively.
alphaToOne :: Bool
alphaToOne specifies whether the implementation is able to replace the alpha value of the color fragment output from the fragment shader with the maximum representable alpha value for fixed-point colors or 1.0 for floating-point colors. If this feature is not enabled, then the alphaToOneEnable member of the PipelineMultisampleStateCreateInfo structure must be set to FALSE. Otherwise setting alphaToOneEnable to TRUE will enable alpha-to-one behavior.
multiViewport :: Bool
multiViewport specifies whether more than one viewport is supported. If this feature is not enabled:
- The viewportCount and scissorCount members of the PipelineViewportStateCreateInfo structure must be set to 1.
- The firstViewport and viewportCount parameters to the cmdSetViewport command must be set to 0 and 1, respectively.
- The firstScissor and scissorCount parameters to the cmdSetScissor command must be set to 0 and 1, respectively.
- The exclusiveScissorCount member of the PipelineViewportExclusiveScissorStateCreateInfoNV structure must be set to 0 or 1.
- The firstExclusiveScissor and exclusiveScissorCount parameters to the cmdSetExclusiveScissorNV command must be set to 0 and 1, respectively.
samplerAnisotropy :: Bool
samplerAnisotropy specifies whether anisotropic filtering is supported. If this feature is not enabled, the anisotropyEnable member of the SamplerCreateInfo structure must be FALSE.
textureCompressionETC2 :: Bool
textureCompressionETC2 specifies whether all of the ETC2 and EAC compressed texture formats are supported. If this feature is enabled, then the FORMAT_FEATURE_SAMPLED_IMAGE_BIT, FORMAT_FEATURE_BLIT_SRC_BIT and FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT features must be supported in optimalTilingFeatures for the following formats:
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:
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:
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:
Note
shaderStorageImageExtendedFormats feature only adds a guarantee of format support, which is specified for the whole physical device. Therefore enabling or disabling the feature via createDevice has no practical effect.
To query for additional properties, or if the feature is not supported, getPhysicalDeviceFormatProperties and getPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats, as usual rules allow.
FORMAT_R32G32_UINT, FORMAT_R32G32_SINT, and FORMAT_R32G32_SFLOAT from StorageImageExtendedFormats SPIR-V capability, are already covered by core Vulkan mandatory format support.
shaderStorageImageMultisample :: Bool
shaderStorageImageMultisample specifies whether multisampled storage images are supported. If this feature is not enabled, images that are created with a usage that includes IMAGE_USAGE_STORAGE_BIT must be created with samples equal to SAMPLE_COUNT_1_BIT. This also specifies whether shader modules can declare the StorageImageMultisample capability.
shaderStorageImageReadWithoutFormat :: Bool
shaderStorageImageReadWithoutFormat specifies whether storage images require a format qualifier to be specified when reading from storage images. If this feature is not enabled, the OpImageRead instruction must not have an OpTypeImage of Unknown. This also specifies whether shader modules can declare the StorageImageReadWithoutFormat capability.
shaderStorageImageWriteWithoutFormat :: Bool
shaderStorageImageWriteWithoutFormat specifies whether storage images require a format qualifier to be specified when writing to storage images. If this feature is not enabled, the OpImageWrite instruction must not have an OpTypeImage of Unknown. This also specifies whether shader modules can declare the StorageImageWriteWithoutFormat capability.
shaderUniformBufferArrayDynamicIndexing :: Bool
shaderUniformBufferArrayDynamicIndexing specifies whether arrays of uniform buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the UniformBufferArrayDynamicIndexing capability.
shaderSampledImageArrayDynamicIndexing :: Bool
shaderSampledImageArrayDynamicIndexing specifies whether arrays of samplers or sampled images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of DESCRIPTOR_TYPE_SAMPLER, DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or DESCRIPTOR_TYPE_SAMPLED_IMAGE must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the SampledImageArrayDynamicIndexing capability.
shaderStorageBufferArrayDynamicIndexing :: Bool
shaderStorageBufferArrayDynamicIndexing specifies whether arrays of storage buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the StorageBufferArrayDynamicIndexing capability.
shaderStorageImageArrayDynamicIndexing :: Bool
shaderStorageImageArrayDynamicIndexing specifies whether arrays of storage images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type of DESCRIPTOR_TYPE_STORAGE_IMAGE must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare the StorageImageArrayDynamicIndexing capability.
shaderClipDistance :: Bool
shaderClipDistance specifies whether clip distances are supported in shader code. If this feature is not enabled, any members decorated with the ClipDistance built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare the ClipDistance capability.
shaderCullDistance :: Bool
shaderCullDistance specifies whether cull distances are supported in shader code. If this feature is not enabled, any members decorated with the CullDistance built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare the CullDistance capability.
shaderFloat64 :: Bool
shaderFloat64 specifies whether 64-bit floats (doubles) are supported in shader code. If this feature is not enabled, 64-bit floating-point types must not be used in shader code. This also specifies whether shader modules can declare the Float64 capability. Declaring and using 64-bit floats is enabled for all storage classes that SPIR-V allows with the Float64 capability.
shaderInt64 :: Bool
shaderInt64 specifies whether 64-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 64-bit integer types must not be used in shader code. This also specifies whether shader modules can declare the Int64 capability. Declaring and using 64-bit integers is enabled for all storage classes that SPIR-V allows with the Int64 capability.
shaderInt16 :: Bool
shaderInt16 specifies whether 16-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 16-bit integer types must not be used in shader code. This also specifies whether shader modules can declare the Int16 capability. However, this only enables a subset of the storage classes that SPIR-V allows for the Int16 SPIR-V capability: Declaring and using 16-bit integers in the Private, Workgroup, and Function storage classes is enabled, while declaring them in the interface storage classes (e.g., UniformConstant, Uniform, StorageBuffer, Input, Output, and PushConstant) is not enabled.
shaderResourceResidency :: Bool
shaderResourceResidency specifies whether image operations that return resource residency information are supported in shader code. If this feature is not enabled, the OpImageSparse* instructions must not be used in shader code. This also specifies whether shader modules can declare the SparseResidency capability. The feature requires at least one of the sparseResidency* features to be supported.
shaderResourceMinLod :: Bool
shaderResourceMinLod specifies whether image operations specifying the minimum resource LOD are supported in shader code. If this feature is not enabled, the MinLod image operand must not be used in shader code. This also specifies whether shader modules can declare the MinLod capability.
sparseBinding :: Bool
sparseBinding specifies whether resource memory can be managed at opaque sparse block level instead of at the object level. If this feature is not enabled, resource memory must be bound only on a per-object basis using the bindBufferMemory and bindImageMemory commands. In this case, buffers and images must not be created with BUFFER_CREATE_SPARSE_BINDING_BIT and IMAGE_CREATE_SPARSE_BINDING_BIT set in the Flags member of the BufferCreateInfo and ImageCreateInfo structures, respectively. Otherwise resource memory can be managed as described in Sparse Resource Features.
sparseResidencyBuffer :: Bool
sparseResidencyBuffer specifies whether the device can access partially resident buffers. If this feature is not enabled, buffers must not be created with BUFFER_CREATE_SPARSE_RESIDENCY_BIT set in the Flags member of the BufferCreateInfo structure.
sparseResidencyImage2D :: Bool
sparseResidencyImage2D specifies whether the device can access partially resident 2D images with 1 sample per pixel. If this feature is not enabled, images with an ImageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_1_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the Flags member of the ImageCreateInfo structure.
sparseResidencyImage3D :: Bool
sparseResidencyImage3D specifies whether the device can access partially resident 3D images. If this feature is not enabled, images with an ImageType of IMAGE_TYPE_3D must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the Flags member of the ImageCreateInfo structure.
sparseResidency2Samples :: Bool
sparseResidency2Samples specifies whether the physical device can access partially resident 2D images with 2 samples per pixel. If this feature is not enabled, images with an ImageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_2_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the Flags member of the ImageCreateInfo structure.
sparseResidency4Samples :: Bool
sparseResidency4Samples specifies whether the physical device can access partially resident 2D images with 4 samples per pixel. If this feature is not enabled, images with an ImageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_4_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the Flags member of the ImageCreateInfo structure.
sparseResidency8Samples :: Bool
sparseResidency8Samples specifies whether the physical device can access partially resident 2D images with 8 samples per pixel. If this feature is not enabled, images with an ImageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_8_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the Flags member of the ImageCreateInfo structure.
sparseResidency16Samples :: Bool
sparseResidency16Samples specifies whether the physical device can access partially resident 2D images with 16 samples per pixel. If this feature is not enabled, images with an ImageType of IMAGE_TYPE_2D and samples set to SAMPLE_COUNT_16_BIT must not be created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT set in the Flags member of the ImageCreateInfo structure.
sparseResidencyAliased :: Bool
sparseResidencyAliased specifies whether the physical device can correctly access data aliased into multiple locations. If this feature is not enabled, the BUFFER_CREATE_SPARSE_ALIASED_BIT and IMAGE_CREATE_SPARSE_ALIASED_BIT enum values must not be used in Flags members of the BufferCreateInfo and ImageCreateInfo structures, respectively.
variableMultisampleRate :: Bool
variableMultisampleRate specifies whether all pipelines that will be bound to a command buffer during a subpass with no attachments must have the same value for PipelineMultisampleStateCreateInfo::rasterizationSamples. If set to TRUE, the implementation supports variable multisample rates in a subpass with no attachments. If set to FALSE, then all pipelines bound in such a subpass must have the same multisample rate. This has no effect in situations where a subpass uses any attachments.
inheritedQueries :: Bool
inheritedQueries specifies whether a secondary command buffer may be executed while a query is active.

Instances

Show PhysicalDeviceFeatures Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> PhysicalDeviceFeatures -> ShowS # show :: PhysicalDeviceFeatures -> String # showList :: [PhysicalDeviceFeatures] -> ShowS #
Storable PhysicalDeviceFeatures Source #
Instance details Defined in Graphics.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 Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr PhysicalDeviceFeatures -> IO PhysicalDeviceFeatures Source #
ToCStruct PhysicalDeviceFeatures Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: PhysicalDeviceFeatures -> (Ptr PhysicalDeviceFeatures -> IO b) -> IO b Source # pokeCStruct :: Ptr PhysicalDeviceFeatures -> PhysicalDeviceFeatures -> IO b -> IO b Source # withZeroCStruct :: (Ptr PhysicalDeviceFeatures -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr PhysicalDeviceFeatures -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero PhysicalDeviceFeatures Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: PhysicalDeviceFeatures Source #

data PhysicalDeviceSparseProperties Source #

VkPhysicalDeviceSparseProperties - Structure specifying physical device sparse memory properties

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.

maxImageDimension1D :: Word32
maxImageDimension1D is the maximum dimension (width) supported for all images created with an ImageType of IMAGE_TYPE_1D.
maxImageDimension2D :: Word32
maxImageDimension2D is the maximum dimension (width or height) supported for all images created with an ImageType of IMAGE_TYPE_2D and without IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in Flags.
maxImageDimension3D :: Word32
maxImageDimension3D is the maximum dimension (width, height, or depth) supported for all images created with an ImageType of IMAGE_TYPE_3D.
maxImageDimensionCube :: Word32
maxImageDimensionCube is the maximum dimension (width or height) supported for all images created with an ImageType of IMAGE_TYPE_2D and with IMAGE_CREATE_CUBE_COMPATIBLE_BIT set in Flags.
maxImageArrayLayers :: Word32
maxImageArrayLayers is the maximum number of layers (arrayLayers) for an image.
maxTexelBufferElements :: Word32
maxTexelBufferElements is the maximum number of addressable texels for a buffer view created on a buffer which was created with the BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set in the usage member of the BufferCreateInfo structure.
maxUniformBufferRange :: Word32
maxUniformBufferRange is the maximum value that can be specified in the range member of any DescriptorBufferInfo structures passed to a call to updateDescriptorSets for descriptors of type DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC.
maxStorageBufferRange :: Word32
maxStorageBufferRange is the maximum value that can be specified in the range member of any DescriptorBufferInfo structures passed to a call to updateDescriptorSets for descriptors of type DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC.
maxPushConstantsSize :: Word32
maxPushConstantsSize is the maximum size, in bytes, of the pool of push constant memory. For each of the push constant ranges indicated by the pPushConstantRanges member of the PipelineLayoutCreateInfo structure, (offset + size) must be less than or equal to this limit.
maxMemoryAllocationCount :: Word32
maxMemoryAllocationCount is the maximum number of device memory allocations, as created by allocateMemory, which can simultaneously exist.
maxSamplerAllocationCount :: Word32
maxSamplerAllocationCount is the maximum number of sampler objects, as created by createSampler, which can simultaneously exist on a device.
bufferImageGranularity :: DeviceSize
bufferImageGranularity is the granularity, in bytes, at which buffer or linear image resources, and optimal image resources can be bound to adjacent offsets in the same DeviceMemory object without aliasing. See Buffer-Image Granularity for more details.
sparseAddressSpaceSize :: DeviceSize
sparseAddressSpaceSize is the total amount of address space available, in bytes, for sparse memory resources. This is an upper bound on the sum of the size of all sparse resources, regardless of whether any memory is bound to them.
maxBoundDescriptorSets :: Word32
maxBoundDescriptorSets is the maximum number of descriptor sets that can be simultaneously used by a pipeline. All DescriptorSet decorations in shader modules must have a value less than maxBoundDescriptorSets. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sets.
maxPerStageDescriptorSamplers :: Word32
maxPerStageDescriptorSamplers is the maximum number of samplers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_SAMPLER or DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sampler and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-combinedimagesampler.
maxPerStageDescriptorUniformBuffers :: Word32
maxPerStageDescriptorUniformBuffers is the maximum number of uniform buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbuffer and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbufferdynamic.
maxPerStageDescriptorStorageBuffers :: Word32
maxPerStageDescriptorStorageBuffers is the maximum number of storage buffers that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebuffer and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebufferdynamic.
maxPerStageDescriptorSampledImages :: Word32
maxPerStageDescriptorSampledImages is the maximum number of sampled images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, DESCRIPTOR_TYPE_SAMPLED_IMAGE, or DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-combinedimagesampler, https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sampledimage, and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformtexelbuffer.
maxPerStageDescriptorStorageImages :: Word32
maxPerStageDescriptorStorageImages is the maximum number of storage images that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_IMAGE, or DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storageimage, and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagetexelbuffer.
maxPerStageDescriptorInputAttachments :: Word32
maxPerStageDescriptorInputAttachments is the maximum number of input attachments that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. A descriptor is accessible to a pipeline shader stage when the stageFlags member of the DescriptorSetLayoutBinding structure has the bit for that shader stage set. These are only supported for the fragment stage. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-inputattachment.
maxPerStageResources :: Word32
maxPerStageResources is the maximum number of resources that can be accessible to a single shader stage in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, DESCRIPTOR_TYPE_SAMPLED_IMAGE, DESCRIPTOR_TYPE_STORAGE_IMAGE, DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, DESCRIPTOR_TYPE_UNIFORM_BUFFER, DESCRIPTOR_TYPE_STORAGE_BUFFER, DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, or DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. For the fragment shader stage the framebuffer color attachments also count against this limit.
maxDescriptorSetSamplers :: Word32
maxDescriptorSetSamplers is the maximum number of samplers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_SAMPLER or DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sampler and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-combinedimagesampler.
maxDescriptorSetUniformBuffers :: Word32
maxDescriptorSetUniformBuffers is the maximum number of uniform buffers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbuffer and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbufferdynamic.
maxDescriptorSetUniformBuffersDynamic :: Word32
maxDescriptorSetUniformBuffersDynamic is the maximum number of dynamic uniform buffers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformbufferdynamic.
maxDescriptorSetStorageBuffers :: Word32
maxDescriptorSetStorageBuffers is the maximum number of storage buffers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebuffer and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebufferdynamic.
maxDescriptorSetStorageBuffersDynamic :: Word32
maxDescriptorSetStorageBuffersDynamic is the maximum number of dynamic storage buffers that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagebufferdynamic.
maxDescriptorSetSampledImages :: Word32
maxDescriptorSetSampledImages is the maximum number of sampled images that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, DESCRIPTOR_TYPE_SAMPLED_IMAGE, or DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-combinedimagesampler, https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-sampledimage, and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-uniformtexelbuffer.
maxDescriptorSetStorageImages :: Word32
maxDescriptorSetStorageImages is the maximum number of storage images that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_STORAGE_IMAGE, or DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storageimage, and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-storagetexelbuffer.
maxDescriptorSetInputAttachments :: Word32
maxDescriptorSetInputAttachments is the maximum number of input attachments that can be included in a pipeline layout. Descriptors with a type of DESCRIPTOR_TYPE_INPUT_ATTACHMENT count against this limit. Only descriptors in descriptor set layouts created without the DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set count against this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#descriptorsets-inputattachment.
maxVertexInputAttributes :: Word32
maxVertexInputAttributes is the maximum number of vertex input attributes that can be specified for a graphics pipeline. These are described in the array of VertexInputAttributeDescription structures that are provided at graphics pipeline creation time via the pVertexAttributeDescriptions member of the PipelineVertexInputStateCreateInfo structure. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-attrib and https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-input.
maxVertexInputBindings :: Word32
maxVertexInputBindings is the maximum number of vertex buffers that can be specified for providing vertex attributes to a graphics pipeline. These are described in the array of VertexInputBindingDescription structures that are provided at graphics pipeline creation time via the pVertexBindingDescriptions member of the PipelineVertexInputStateCreateInfo structure. The binding member of VertexInputBindingDescription must be less than this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-input.
maxVertexInputAttributeOffset :: Word32
maxVertexInputAttributeOffset is the maximum vertex input attribute offset that can be added to the vertex input binding stride. The offset member of the VertexInputAttributeDescription structure must be less than or equal to this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-input.
maxVertexInputBindingStride :: Word32
maxVertexInputBindingStride is the maximum vertex input binding stride that can be specified in a vertex input binding. The stride member of the VertexInputBindingDescription structure must be less than or equal to this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fxvertex-input.
maxVertexOutputComponents :: Word32
maxVertexOutputComponents is the maximum number of components of output variables which can be output by a vertex shader. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#shaders-vertex.
maxTessellationGenerationLevel :: Word32
maxTessellationGenerationLevel is the maximum tessellation generation level supported by the fixed-function tessellation primitive generator. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#tessellation.
maxTessellationPatchSize :: Word32
maxTessellationPatchSize is the maximum patch size, in vertices, of patches that can be processed by the tessellation control shader and tessellation primitive generator. The patchControlPoints member of the PipelineTessellationStateCreateInfo structure specified at pipeline creation time and the value provided in the OutputVertices execution mode of shader modules must be less than or equal to this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#tessellation.
maxTessellationControlPerVertexInputComponents :: Word32
maxTessellationControlPerVertexInputComponents is the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation control shader stage.
maxTessellationControlPerVertexOutputComponents :: Word32
maxTessellationControlPerVertexOutputComponents is the maximum number of components of per-vertex output variables which can be output from the tessellation control shader stage.
maxTessellationControlPerPatchOutputComponents :: Word32
maxTessellationControlPerPatchOutputComponents is the maximum number of components of per-patch output variables which can be output from the tessellation control shader stage.
maxTessellationControlTotalOutputComponents :: Word32
maxTessellationControlTotalOutputComponents is the maximum total number of components of per-vertex and per-patch output variables which can be output from the tessellation control shader stage.
maxTessellationEvaluationInputComponents :: Word32
maxTessellationEvaluationInputComponents is the maximum number of components of input variables which can be provided as per-vertex inputs to the tessellation evaluation shader stage.
maxTessellationEvaluationOutputComponents :: Word32
maxTessellationEvaluationOutputComponents is the maximum number of components of per-vertex output variables which can be output from the tessellation evaluation shader stage.
maxGeometryShaderInvocations :: Word32
maxGeometryShaderInvocations is the maximum invocation count supported for instanced geometry shaders. The value provided in the Invocations execution mode of shader modules must be less than or equal to this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#geometry.
maxGeometryInputComponents :: Word32
maxGeometryInputComponents is the maximum number of components of input variables which can be provided as inputs to the geometry shader stage.
maxGeometryOutputComponents :: Word32
maxGeometryOutputComponents is the maximum number of components of output variables which can be output from the geometry shader stage.
maxGeometryOutputVertices :: Word32
maxGeometryOutputVertices is the maximum number of vertices which can be emitted by any geometry shader.
maxGeometryTotalOutputComponents :: Word32
maxGeometryTotalOutputComponents is the maximum total number of components of output, across all emitted vertices, which can be output from the geometry shader stage.
maxFragmentInputComponents :: Word32
maxFragmentInputComponents is the maximum number of components of input variables which can be provided as inputs to the fragment shader stage.
maxFragmentOutputAttachments :: Word32
maxFragmentOutputAttachments is the maximum number of output attachments which can be written to by the fragment shader stage.
maxFragmentDualSrcAttachments :: Word32
maxFragmentDualSrcAttachments is the maximum number of output attachments which can be written to by the fragment shader stage when blending is enabled and one of the dual source blend modes is in use. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#framebuffer-dsb and dualSrcBlend.
maxFragmentCombinedOutputResources :: Word32
maxFragmentCombinedOutputResources is the total number of storage buffers, storage images, and output buffers which can be used in the fragment shader stage.
maxComputeSharedMemorySize :: Word32
maxComputeSharedMemorySize is the maximum total storage size, in bytes, available for variables declared with the Workgroup storage class in shader modules (or with the shared storage qualifier in GLSL) in the compute shader stage. The amount of storage consumed by the variables declared with the Workgroup storage class is implementation-dependent. However, the amount of storage consumed may not exceed the largest block size that would be obtained if all active variables declared with Workgroup storage class were assigned offsets in an arbitrary order by successively taking the smallest valid offset according to the Standard Storage Buffer Layout rules. (This is equivalent to using the GLSL std430 layout rules.)
maxComputeWorkGroupCount :: (Word32, Word32, Word32)
maxComputeWorkGroupCount[3] is the maximum number of local workgroups that can be dispatched by a single dispatch command. These three values represent the maximum number of local workgroups for the X, Y, and Z dimensions, respectively. The workgroup count parameters to the dispatch commands must be less than or equal to the corresponding limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#dispatch.
maxComputeWorkGroupInvocations :: Word32
maxComputeWorkGroupInvocations is the maximum total number of compute shader invocations in a single local workgroup. The product of the X, Y, and Z sizes, as specified by the LocalSize execution mode in shader modules or by the object decorated by the WorkgroupSize decoration, must be less than or equal to this limit.
maxComputeWorkGroupSize :: (Word32, Word32, Word32)
maxComputeWorkGroupSize[3] is the maximum size of a local compute workgroup, per dimension. These three values represent the maximum local workgroup size in the X, Y, and Z dimensions, respectively. The x, y, and z sizes, as specified by the LocalSize execution mode or by the object decorated by the WorkgroupSize decoration in shader modules, must be less than or equal to the corresponding limit.
subPixelPrecisionBits :: Word32
subPixelPrecisionBits is the number of bits of subpixel precision in framebuffer coordinates xf and yf. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#primsrast.
subTexelPrecisionBits :: Word32
subTexelPrecisionBits is the number of bits of precision in the division along an axis of an image used for minification and magnification filters. 2subTexelPrecisionBits is the actual number of divisions along each axis of the image represented. Sub-texel values calculated during image sampling will snap to these locations when generating the filtered results.
mipmapPrecisionBits :: Word32
mipmapPrecisionBits is the number of bits of division that the LOD calculation for mipmap fetching get snapped to when determining the contribution from each mip level to the mip filtered results. 2mipmapPrecisionBits is the actual number of divisions.
maxDrawIndexedIndexValue :: Word32
maxDrawIndexedIndexValue is the maximum index value that can be used for indexed draw calls when using 32-bit indices. This excludes the primitive restart index value of 0xFFFFFFFF. See fullDrawIndexUint32.
maxDrawIndirectCount :: Word32
maxDrawIndirectCount is the maximum draw count that is supported for indirect draw calls. See multiDrawIndirect.
maxSamplerLodBias :: Float
maxSamplerLodBias is the maximum absolute sampler LOD bias. The sum of the mipLodBias member of the SamplerCreateInfo structure and the Bias operand of image sampling operations in shader modules (or 0 if no Bias operand is provided to an image sampling operation) are clamped to the range [-maxSamplerLodBias,+maxSamplerLodBias]. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#samplers-mipLodBias.
maxSamplerAnisotropy :: Float
maxSamplerAnisotropy is the maximum degree of sampler anisotropy. The maximum degree of anisotropic filtering used for an image sampling operation is the minimum of the maxAnisotropy member of the SamplerCreateInfo structure and this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#samplers-maxAnisotropy.
maxViewports :: Word32
maxViewports is the maximum number of active viewports. The viewportCount member of the PipelineViewportStateCreateInfo structure that is provided at pipeline creation must be less than or equal to this limit.
maxViewportDimensions :: (Word32, Word32)
maxViewportDimensions[2] are the maximum viewport dimensions in the X (width) and Y (height) dimensions, respectively. The maximum viewport dimensions must be greater than or equal to the largest image which can be created and used as a framebuffer attachment. See Controlling the Viewport.
viewportBoundsRange :: (Float, Float)
viewportBoundsRange[2] is the [minimum, maximum] range that the corners of a viewport must be contained in. This range must be at least [-2 × size, 2 × size - 1], where size = max(maxViewportDimensions[0], maxViewportDimensions[1]). See Controlling the Viewport.
Note
The intent of the viewportBoundsRange limit is to allow a maximum sized viewport to be arbitrarily shifted relative to the output target as long as at least some portion intersects. This would give a bounds limit of [-size + 1, 2 × size - 1] which would allow all possible non-empty-set intersections of the output target and the viewport. Since these numbers are typically powers of two, picking the signed number range using the smallest possible number of bits ends up with the specified range.
viewportSubPixelBits :: Word32
viewportSubPixelBits is the number of bits of subpixel precision for viewport bounds. The subpixel precision that floating-point viewport bounds are interpreted at is given by this limit.
minMemoryMapAlignment :: Word64
minMemoryMapAlignment is the minimum required alignment, in bytes, of host visible memory allocations within the host address space. When mapping a memory allocation with mapMemory, subtracting offset bytes from the returned pointer will always produce an integer multiple of this limit. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#memory-device-hostaccess.
minTexelBufferOffsetAlignment :: DeviceSize
minTexelBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the BufferViewCreateInfo structure for texel buffers. If texelBufferAlignment is enabled, this limit is equivalent to the maximum of the uniformTexelBufferOffsetAlignmentBytes and storageTexelBufferOffsetAlignmentBytes members of PhysicalDeviceTexelBufferAlignmentPropertiesEXT, but smaller alignment is optionally: allowed by storageTexelBufferOffsetSingleTexelAlignment and uniformTexelBufferOffsetSingleTexelAlignment. If texelBufferAlignment is not enabled, BufferViewCreateInfo::offset must be a multiple of this value.
minUniformBufferOffsetAlignment :: DeviceSize
minUniformBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the DescriptorBufferInfo structure for uniform buffers. When a descriptor of type DESCRIPTOR_TYPE_UNIFORM_BUFFER or DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC is updated, the offset must be an integer multiple of this limit. Similarly, dynamic offsets for uniform buffers must be multiples of this limit.
minStorageBufferOffsetAlignment :: DeviceSize
minStorageBufferOffsetAlignment is the minimum required alignment, in bytes, for the offset member of the DescriptorBufferInfo structure for storage buffers. When a descriptor of type DESCRIPTOR_TYPE_STORAGE_BUFFER or DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC is updated, the offset must be an integer multiple of this limit. Similarly, dynamic offsets for storage buffers must be multiples of this limit.
minTexelOffset :: Int32
minTexelOffset is the minimum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.
maxTexelOffset :: Word32
maxTexelOffset is the maximum offset value for the ConstOffset image operand of any of the OpImageSample* or OpImageFetch* image instructions.
minTexelGatherOffset :: Int32
minTexelGatherOffset is the minimum offset value for the Offset, ConstOffset, or ConstOffsets image operands of any of the OpImage*Gather image instructions.
maxTexelGatherOffset :: Word32
maxTexelGatherOffset is the maximum offset value for the Offset, ConstOffset, or ConstOffsets image operands of any of the OpImage*Gather image instructions.
minInterpolationOffset :: Float
minInterpolationOffset is the minimum negative offset value for the offset operand of the InterpolateAtOffset extended instruction.
maxInterpolationOffset :: Float
maxInterpolationOffset is the maximum positive offset value for the offset operand of the InterpolateAtOffset extended instruction.
subPixelInterpolationOffsetBits :: Word32
subPixelInterpolationOffsetBits is the number of subpixel fractional bits that the x and y offsets to the InterpolateAtOffset extended instruction may be rounded to as fixed-point values.
maxFramebufferWidth :: Word32
maxFramebufferWidth is the maximum width for a framebuffer. The width member of the FramebufferCreateInfo structure must be less than or equal to this limit.
maxFramebufferHeight :: Word32
maxFramebufferHeight is the maximum height for a framebuffer. The height member of the FramebufferCreateInfo structure must be less than or equal to this limit.
maxFramebufferLayers :: Word32
maxFramebufferLayers is the maximum layer count for a layered framebuffer. The layers member of the FramebufferCreateInfo structure must be less than or equal to this limit.
framebufferColorSampleCounts :: SampleCountFlags
framebufferColorSampleCounts is a bitmask1 of SampleCountFlagBits indicating the color sample counts that are supported for all framebuffer color attachments with floating- or fixed-point formats. There is no limit that specifies the color sample counts that are supported for all color attachments with integer formats.
framebufferDepthSampleCounts :: SampleCountFlags
framebufferDepthSampleCounts is a bitmask1 of SampleCountFlagBits indicating the supported depth sample counts for all framebuffer depth/stencil attachments, when the format includes a depth component.
framebufferStencilSampleCounts :: SampleCountFlags
framebufferStencilSampleCounts is a bitmask1 of SampleCountFlagBits indicating the supported stencil sample counts for all framebuffer depth/stencil attachments, when the format includes a stencil component.
framebufferNoAttachmentsSampleCounts :: SampleCountFlags
framebufferNoAttachmentsSampleCounts is a bitmask1 of SampleCountFlagBits indicating the supported sample counts for a framebuffer with no attachments.
maxColorAttachments :: Word32
maxColorAttachments is the maximum number of color attachments that can be used by a subpass in a render pass. The colorAttachmentCount member of the SubpassDescription structure must be less than or equal to this limit.
sampledImageColorSampleCounts :: SampleCountFlags
sampledImageColorSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample counts supported for all 2D images created with IMAGE_TILING_OPTIMAL, usage containing IMAGE_USAGE_SAMPLED_BIT, and a non-integer color format.
sampledImageIntegerSampleCounts :: SampleCountFlags
sampledImageIntegerSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample counts supported for all 2D images created with IMAGE_TILING_OPTIMAL, usage containing IMAGE_USAGE_SAMPLED_BIT, and an integer color format.
sampledImageDepthSampleCounts :: SampleCountFlags
sampledImageDepthSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample counts supported for all 2D images created with IMAGE_TILING_OPTIMAL, usage containing IMAGE_USAGE_SAMPLED_BIT, and a depth format.
sampledImageStencilSampleCounts :: SampleCountFlags
sampledImageStencilSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample supported for all 2D images created with IMAGE_TILING_OPTIMAL, usage containing IMAGE_USAGE_SAMPLED_BIT, and a stencil format.
storageImageSampleCounts :: SampleCountFlags
storageImageSampleCounts is a bitmask1 of SampleCountFlagBits indicating the sample counts supported for all 2D images created with IMAGE_TILING_OPTIMAL, and usage containing IMAGE_USAGE_STORAGE_BIT.
maxSampleMaskWords :: Word32
maxSampleMaskWords is the maximum number of array elements of a variable decorated with the SampleMask built-in decoration.
timestampComputeAndGraphics :: Bool
timestampComputeAndGraphics specifies support for timestamps on all graphics and compute queues. If this limit is set to TRUE, all queues that advertise the QUEUE_GRAPHICS_BIT or QUEUE_COMPUTE_BIT in the 'QueueFamilyProperties'::'Graphics.Vulkan.Core10.Enums.QueueFlagBits.QueueFlags' support QueueFamilyProperties::timestampValidBits of at least 36. See Timestamp Queries.
timestampPeriod :: Float
timestampPeriod is the number of nanoseconds required for a timestamp query to be incremented by 1. See Timestamp Queries.
maxClipDistances :: Word32
maxClipDistances is the maximum number of clip distances that can be used in a single shader stage. The size of any array declared with the ClipDistance built-in decoration in a shader module must be less than or equal to this limit.
maxCullDistances :: Word32
maxCullDistances is the maximum number of cull distances that can be used in a single shader stage. The size of any array declared with the CullDistance built-in decoration in a shader module must be less than or equal to this limit.
maxCombinedClipAndCullDistances :: Word32
maxCombinedClipAndCullDistances is the maximum combined number of clip and cull distances that can be used in a single shader stage. The sum of the sizes of any pair of arrays declared with the ClipDistance and CullDistance built-in decoration used by a single shader stage in a shader module must be less than or equal to this limit.
discreteQueuePriorities :: Word32
discreteQueuePriorities is the number of discrete priorities that can be assigned to a queue based on the value of each member of DeviceQueueCreateInfo::pQueuePriorities. This must be at least 2, and levels must be spread evenly over the range, with at least one level at 1.0, and another at 0.0. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#devsandqueues-priority.
pointSizeRange :: (Float, Float)
pointSizeRange[2] is the range [minimum,maximum] of supported sizes for points. Values written to variables decorated with the PointSize built-in decoration are clamped to this range.
lineWidthRange :: (Float, Float)
lineWidthRange[2] is the range [minimum,maximum] of supported widths for lines. Values specified by the lineWidth member of the PipelineRasterizationStateCreateInfo or the lineWidth parameter to cmdSetLineWidth are clamped to this range.
pointSizeGranularity :: Float
pointSizeGranularity is the granularity of supported point sizes. Not all point sizes in the range defined by pointSizeRange are supported. This limit specifies the granularity (or increment) between successive supported point sizes.
lineWidthGranularity :: Float
lineWidthGranularity is the granularity of supported line widths. Not all line widths in the range defined by lineWidthRange are supported. This limit specifies the granularity (or increment) between successive supported line widths.
strictLines :: Bool
strictLines specifies whether lines are rasterized according to the preferred method of rasterization. If set to FALSE, lines may be rasterized under a relaxed set of rules. If set to TRUE, lines are rasterized as per the strict definition. See Basic Line Segment Rasterization.
standardSampleLocations :: Bool
standardSampleLocations specifies whether rasterization uses the standard sample locations as documented in Multisampling. If set to TRUE, the implementation uses the documented sample locations. If set to FALSE, the implementation may use different sample locations.
optimalBufferCopyOffsetAlignment :: DeviceSize
optimalBufferCopyOffsetAlignment is the optimal buffer offset alignment in bytes for cmdCopyBufferToImage and cmdCopyImageToBuffer. The per texel alignment requirements are enforced, but applications should use the optimal alignment for optimal performance and power use.
optimalBufferCopyRowPitchAlignment :: DeviceSize
optimalBufferCopyRowPitchAlignment is the optimal buffer row pitch alignment in bytes for cmdCopyBufferToImage and cmdCopyImageToBuffer. Row pitch is the number of bytes between texels with the same X coordinate in adjacent rows (Y coordinates differ by one). The per texel alignment requirements are enforced, but applications should use the optimal alignment for optimal performance and power use.
nonCoherentAtomSize :: DeviceSize
nonCoherentAtomSize is the size and alignment in bytes that bounds concurrent access to host-mapped device memory.

Instances

Show PhysicalDeviceLimits Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> PhysicalDeviceLimits -> ShowS # show :: PhysicalDeviceLimits -> String # showList :: [PhysicalDeviceLimits] -> ShowS #
Storable PhysicalDeviceLimits Source #
Instance details Defined in Graphics.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 Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr PhysicalDeviceLimits -> IO PhysicalDeviceLimits Source #
ToCStruct PhysicalDeviceLimits Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: PhysicalDeviceLimits -> (Ptr PhysicalDeviceLimits -> IO b) -> IO b Source # pokeCStruct :: Ptr PhysicalDeviceLimits -> PhysicalDeviceLimits -> IO b -> IO b Source # withZeroCStruct :: (Ptr PhysicalDeviceLimits -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr PhysicalDeviceLimits -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero PhysicalDeviceLimits Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: PhysicalDeviceLimits Source #

Show PhysicalDeviceProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> PhysicalDeviceProperties -> ShowS # show :: PhysicalDeviceProperties -> String # showList :: [PhysicalDeviceProperties] -> ShowS #
FromCStruct PhysicalDeviceProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr PhysicalDeviceProperties -> IO PhysicalDeviceProperties Source #
ToCStruct PhysicalDeviceProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: PhysicalDeviceProperties -> (Ptr PhysicalDeviceProperties -> IO b) -> IO b Source # pokeCStruct :: Ptr PhysicalDeviceProperties -> PhysicalDeviceProperties -> IO b -> IO b Source # withZeroCStruct :: (Ptr PhysicalDeviceProperties -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr PhysicalDeviceProperties -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero PhysicalDeviceProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: PhysicalDeviceProperties Source #

Show ApplicationInfo Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> ApplicationInfo -> ShowS # show :: ApplicationInfo -> String # showList :: [ApplicationInfo] -> ShowS #
FromCStruct ApplicationInfo Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr ApplicationInfo -> IO ApplicationInfo Source #
ToCStruct ApplicationInfo Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: ApplicationInfo -> (Ptr ApplicationInfo -> IO b) -> IO b Source # pokeCStruct :: Ptr ApplicationInfo -> ApplicationInfo -> IO b -> IO b Source # withZeroCStruct :: (Ptr ApplicationInfo -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr ApplicationInfo -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero ApplicationInfo Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: ApplicationInfo Source #

Extensible InstanceCreateInfo Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods extensibleType :: StructureType Source # getNext :: InstanceCreateInfo es -> Chain es Source # setNext :: InstanceCreateInfo ds -> Chain es -> InstanceCreateInfo es Source # extends :: Typeable e => proxy e -> (Extends InstanceCreateInfo e -> b) -> Maybe b Source #
Show (Chain es) => Show (InstanceCreateInfo es) Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> InstanceCreateInfo es -> ShowS # show :: InstanceCreateInfo es -> String # showList :: [InstanceCreateInfo es] -> ShowS #
PeekChain es => FromCStruct (InstanceCreateInfo es) Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr (InstanceCreateInfo es) -> IO (InstanceCreateInfo es) Source #
PokeChain es => ToCStruct (InstanceCreateInfo es) Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: InstanceCreateInfo es -> (Ptr (InstanceCreateInfo es) -> IO b) -> IO b Source # pokeCStruct :: Ptr (InstanceCreateInfo es) -> InstanceCreateInfo es -> IO b -> IO b Source # withZeroCStruct :: (Ptr (InstanceCreateInfo es) -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr (InstanceCreateInfo es) -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
es ~ ([] :: [Type]) => Zero (InstanceCreateInfo es) Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: InstanceCreateInfo es Source #

Show QueueFamilyProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> QueueFamilyProperties -> ShowS # show :: QueueFamilyProperties -> String # showList :: [QueueFamilyProperties] -> ShowS #
FromCStruct QueueFamilyProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr QueueFamilyProperties -> IO QueueFamilyProperties Source #
ToCStruct QueueFamilyProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: QueueFamilyProperties -> (Ptr QueueFamilyProperties -> IO b) -> IO b Source # pokeCStruct :: Ptr QueueFamilyProperties -> QueueFamilyProperties -> IO b -> IO b Source # withZeroCStruct :: (Ptr QueueFamilyProperties -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr QueueFamilyProperties -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero QueueFamilyProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: QueueFamilyProperties Source #

Show PhysicalDeviceMemoryProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> PhysicalDeviceMemoryProperties -> ShowS # show :: PhysicalDeviceMemoryProperties -> String # showList :: [PhysicalDeviceMemoryProperties] -> ShowS #
FromCStruct PhysicalDeviceMemoryProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr PhysicalDeviceMemoryProperties -> IO PhysicalDeviceMemoryProperties Source #
ToCStruct PhysicalDeviceMemoryProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: PhysicalDeviceMemoryProperties -> (Ptr PhysicalDeviceMemoryProperties -> IO b) -> IO b Source # pokeCStruct :: Ptr PhysicalDeviceMemoryProperties -> PhysicalDeviceMemoryProperties -> IO b -> IO b Source # withZeroCStruct :: (Ptr PhysicalDeviceMemoryProperties -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr PhysicalDeviceMemoryProperties -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero PhysicalDeviceMemoryProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: PhysicalDeviceMemoryProperties Source #

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.

Show MemoryType Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> MemoryType -> ShowS # show :: MemoryType -> String # showList :: [MemoryType] -> ShowS #
Storable MemoryType Source #
Instance details Defined in Graphics.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 Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr MemoryType -> IO MemoryType Source #
ToCStruct MemoryType Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: MemoryType -> (Ptr MemoryType -> IO b) -> IO b Source # pokeCStruct :: Ptr MemoryType -> MemoryType -> IO b -> IO b Source # withZeroCStruct :: (Ptr MemoryType -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr MemoryType -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero MemoryType Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: MemoryType Source #

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.

Show MemoryHeap Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> MemoryHeap -> ShowS # show :: MemoryHeap -> String # showList :: [MemoryHeap] -> ShowS #
Storable MemoryHeap Source #
Instance details Defined in Graphics.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 Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr MemoryHeap -> IO MemoryHeap Source #
ToCStruct MemoryHeap Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: MemoryHeap -> (Ptr MemoryHeap -> IO b) -> IO b Source # pokeCStruct :: Ptr MemoryHeap -> MemoryHeap -> IO b -> IO b Source # withZeroCStruct :: (Ptr MemoryHeap -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr MemoryHeap -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero MemoryHeap Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: MemoryHeap Source #

Show FormatProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> FormatProperties -> ShowS # show :: FormatProperties -> String # showList :: [FormatProperties] -> ShowS #
Storable FormatProperties Source #
Instance details Defined in Graphics.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 Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr FormatProperties -> IO FormatProperties Source #
ToCStruct FormatProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: FormatProperties -> (Ptr FormatProperties -> IO b) -> IO b Source # pokeCStruct :: Ptr FormatProperties -> FormatProperties -> IO b -> IO b Source # withZeroCStruct :: (Ptr FormatProperties -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr FormatProperties -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero FormatProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: FormatProperties Source #

ImageFormatProperties
Fields maxExtent :: Extent3D maxMipLevels :: Word32 maxArrayLayers :: Word32 sampleCounts :: SampleCountFlags maxResourceSize :: DeviceSize

Show ImageFormatProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> ImageFormatProperties -> ShowS # show :: ImageFormatProperties -> String # showList :: [ImageFormatProperties] -> ShowS #
FromCStruct ImageFormatProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr ImageFormatProperties -> IO ImageFormatProperties Source #
ToCStruct ImageFormatProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: ImageFormatProperties -> (Ptr ImageFormatProperties -> IO b) -> IO b Source # pokeCStruct :: Ptr ImageFormatProperties -> ImageFormatProperties -> IO b -> IO b Source # withZeroCStruct :: (Ptr ImageFormatProperties -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr ImageFormatProperties -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero ImageFormatProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: ImageFormatProperties Source #

Show PhysicalDeviceSparseProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods showsPrec :: Int -> PhysicalDeviceSparseProperties -> ShowS # show :: PhysicalDeviceSparseProperties -> String # showList :: [PhysicalDeviceSparseProperties] -> ShowS #
Storable PhysicalDeviceSparseProperties Source #
Instance details Defined in Graphics.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 Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods peekCStruct :: Ptr PhysicalDeviceSparseProperties -> IO PhysicalDeviceSparseProperties Source #
ToCStruct PhysicalDeviceSparseProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods withCStruct :: PhysicalDeviceSparseProperties -> (Ptr PhysicalDeviceSparseProperties -> IO b) -> IO b Source # pokeCStruct :: Ptr PhysicalDeviceSparseProperties -> PhysicalDeviceSparseProperties -> IO b -> IO b Source # withZeroCStruct :: (Ptr PhysicalDeviceSparseProperties -> IO b) -> IO b Source # pokeZeroCStruct :: Ptr PhysicalDeviceSparseProperties -> IO b -> IO b Source # cStructSize :: Int Source # cStructAlignment :: Int Source #
Zero PhysicalDeviceSparseProperties Source #
Instance details Defined in Graphics.Vulkan.Core10.DeviceInitialization Methods zero :: PhysicalDeviceSparseProperties Source #

Documentation

Parameters

Description

Valid Usage

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Valid Usage

Valid Usage (Implicit)

Host Synchronization

See Also

Parameters

Description

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Description

Valid Usage (Implicit)

See Also

Parameters

Description

Valid Usage (Implicit)

See Also

Parameters

Valid Usage (Implicit)

See Also

Parameters

Description

Valid Usage (Implicit)

See Also

Parameters

Valid Usage (Implicit)

See Also

Parameters

Valid Usage (Implicit)

See Also

Parameters

Valid Usage (Implicit)

See Also

Parameters

Description

Return Codes

See Also

Description

See Also

Description

Valid Usage (Implicit)

See Also

Valid Usage (Implicit)

See Also

Description

See Also

Description

See Also

See Also

See Also

Description

See Also

Members

Description

See Also

Members

See Also

See Also

Members

Description

See Also