Struct MultiDispatcher

pub struct MultiDispatcher(/* private fields */);

MultiDispatcher Dispatcher implementation which stores vulkan commands on the heap using smart pointers This adds a small overhead:

• Smart Vulkan handles must store an additional pointer
• Creating/dropping smart Vulkan Handles has the additional cost of cloning/dropping a std::sync::Arc If you only use at most one vulkan instance and one device at any given time, you should use DynamicDispatcher instead When the loaded feature is enabled and the dispatcher is loaded with MultiDispatcher::new_loaded, The vulkan library will be unloaded as soon as all dispatchers are dropped

Trait Implementations

impl Clone for MultiDispatcher

fn clone(&self) -> MultiDispatcher

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Dispatcher for MultiDispatcher

fn get_command_dispatcher(&self) -> &CommandsDispatcher

Return the associated vk::CommandsDispatcher with this Dispatcher You can then use the command table to call any command that has been loaded or load new commands

unsafe fn new(get_instance_proc_addr: GetInstanceProcAddrSignature) -> Self

Create a new dispatcher given the get_instance_proc_addr entry point this will load basic (non-instance and non-device dependent) commands

fn clone_with_instance(&self, instance: &Instance) -> Self

fn clone_with_device(&self, device: &Device) -> Self

unsafe fn new_loaded() -> Result<Self, LoadingError>

Create a loads the Vulkan library, retrieve the entry point from it and initialize the dispatcher using it* This will return an error if the vulkan library or its entry point cannot be found Library unloading depends on the implementation, for MultiDispatcher it happends as soon as all dispatcher are dropped. While for DynamicDispatcher one should call DynamicDispatcher::unload() SAFETY:

unsafe fn new_loaded_and_lib() -> Result<(Self, Library), LoadingError>

Internal function used to load a library and return the dispatcher along with a library object which ensures the llibrary is kept loaded while the object is alive