Modulevulkan-utils-0.5.11.0Haskell2010

Vulkan.Utils.Initialization

12 values

Packagevulkan-utils-0.5.11.0
Exports12
LanguageHaskell2010
LicenceBSD-3-Clause
SourceInitialization.hs

Instance creation

3 declarations

valueallocateInstanceFromRequirements

:: (MonadResource m, Extendss InstanceCreateInfo es, PokeChain es)
=> [InstanceRequirement]
Required
-> [InstanceRequirement]
Optional
-> InstanceCreateInfo es
-> m Instance

Create an 'Instance from some requirements.

Will throw an 'IOError in the case of unsatisfied non-optional requirements. Unsatisfied requirements will be listed on stderr.

valueallocateDebugInstanceFromRequirements

:: (MonadResource m, Extendss InstanceCreateInfo es, PokeChain es)
=> [InstanceRequirement]
Required
-> [InstanceRequirement]
Optional
-> InstanceCreateInfo es
-> m Instance

Like allocateInstanceFromRequirements except it will create a debug utils messenger (from the VK_EXT_debug_utils extension).

If the VK_EXT_validation_features extension (from the VK_LAYER_KHRONOS_validation layer) is available is it will be enabled and best practices messages enabled.

valueallocateVulkanInstance

:: MonadResource m
=> Vector ByteString
Backend-required instance extensions (e.g. from Vulkan.Utils.Init.SDL2.getRequiredInstanceExtensions). mempty for headless.
-> Maybe ApplicationInfo
-> [InstanceRequirement]
Caller's required requirements
-> [InstanceRequirement]
Caller's optional requirements
-> m Instance

Build a Vulkan Instance from a backend-supplied extension list plus caller-supplied requirements. Automatically merges portabilityRequirements into the required list and portabilityFlags into the create flags so macOS apps work without per-call plumbing.

Pass mempty for the extension list when running headless; or call allocateInstance which does so.

macOS portability

3 declarations

valueportabilityRequirements :: [InstanceRequirement]

valueportabilityFlags :: InstanceCreateFlags

Instance create flag bits that pair with portabilityRequirements. zero on every non-macOS platform.

valuedevicePortabilityRequirements :: [DeviceRequirement]

Device requirements needed on macOS: the Vulkan spec mandates that VK_KHR_portability_subset be enabled whenever a physical device advertises it (as MoltenVK does). Empty on every other platform.

Device creation

1 declaration

valueallocateDeviceFromRequirements

:: MonadResource m
=> [DeviceRequirement]
Required
-> [DeviceRequirement]
Optional
-> PhysicalDevice
-> DeviceCreateInfo '[]
-> m Device

Create a Device from some requirements.

Will throw an 'IOError in the case of unsatisfied non-optional requirements. Unsatisfied requirements will be listed on stderr.

Physical device selection

2 declarations

valuepickPhysicalDevice

:: (MonadIO m, Ord b)
=> Instance
-> (PhysicalDevice -> m (Maybe a))
A suitability funcion for a PhysicalDevice, Nothing if it is not to be chosen.
-> (a -> b)
Scoring function to rate this result
-> m (Maybe (a, PhysicalDevice))
The score and the device

Get a single PhysicalDevice deciding with a scoring function

Pass a function which will extract any required values from a device in the spirit of parse-don't-validate. Also provide a function to compare these results for sorting multiple suitable devices.

As an example, the suitability function could return a tuple of device memory and the compute queue family index, and the scoring function could be fst to select devices based on their memory capacity. Consider using assignQueues to find your desired queues in the suitability function.

Pehaps also use the functionality in Vulkan.Utils.Requirements and return the DeviceCreateInfo too.

If no devices are deemed suitable then a NoSuchThing IOError is thrown.