Struct ResourceManager

pub struct ResourceManager { /* private fields */ }

Resource manager controls loading and lifetime of resource in the engine. Resource manager can hold resources of arbitrary types via type erasure mechanism.

Built-in Resources

Built-in resources are special kinds of resources, whose data is packed in the executable (i.e. via include_bytes macro). Such resources reference the data that cannot be “loaded” from external source. To support such kind of resource the manager provides built_in_resources hash map where you can register your own built-in resource and access existing ones.

Internals

It is a simple wrapper over ResourceManagerState that can be shared (cloned). In other words, it is just a strong reference to the inner state.

Implementations

impl ResourceManager

pub fn new(task_pool: Arc<TaskPool>) -> ResourceManager

Creates a resource manager with default settings and loaders.

pub fn state(&self) -> MutexGuard<'_, RawMutex, ResourceManagerState>

Returns a guarded reference to internal state of resource manager.

pub fn resource_io(&self) -> Arc<dyn ResourceIo>

Returns the ResourceIo used by this resource manager

pub fn task_pool(&self) -> Arc<TaskPool>

Returns the task pool used by this resource manager.

pub fn request<T>(&self, path: impl AsRef<Path>) -> Resource<T>

where T: TypedResourceData,

Requests a resource of the given type located at the given path. This method is non-blocking, instead it immediately returns the typed resource wrapper. Loading of the resource is managed automatically in a separate thread (or thread pool) on PC, and JS micro-task (the same thread) on WebAssembly.

Sharing

If the resource at the given path is already was requested (no matter in which state the actual resource is), this method will return the existing instance. This way the resource manager guarantees that the actual resource data will be loaded once, and it can be shared.

Waiting

If you need to wait until the resource is loaded, use .await on the result of the method. Every resource implements Future trait and can be used in async contexts.

Resource state

Keep in mind, that the resource itself is a small state machine. It could be in three main states:

• ResourceState::Pending - a resource is in the queue to load or still loading.
• ResourceState::LoadError - a resource is failed to load.
• ResourceState::Ok - a resource is successfully loaded.

Actual resource state can be fetched by Resource::state method. If you know for sure that the resource is already loaded, then you can use Resource::data_ref to obtain a reference to the actual resource data. Keep in mind, that this method will panic if the resource non in Ok state.

Panic

This method will panic, if type UUID of T does not match the actual type UUID of the resource. If this is undesirable, use Self::try_request instead.

pub fn try_request<T>(&self, path: impl AsRef<Path>) -> Option<Resource<T>>

where T: TypedResourceData,

The same as Self::request, but returns None if type UUID of T does not match the actual type UUID of the resource.

Panic

This method does not panic.

pub fn request_untyped<P>(&self, path: P) -> UntypedResource

where P: AsRef<Path>,

Same as Self::request, but returns untyped resource.

pub fn register<P, F>( &self, resource: UntypedResource, path: P, on_register: F, ) -> Result<(), ResourceRegistrationError>

where P: AsRef<Path>, F: FnMut(&mut (dyn ResourceData + 'static), &Path) -> bool,

Saves given resources in the specified path and registers it in resource manager, so it will be accessible through it later.

pub async fn move_resource( &self, resource: UntypedResource, new_path: impl AsRef<Path>, working_directory: impl AsRef<Path>, filter: impl FnMut(&UntypedResource) -> bool, ) -> Result<(), FileLoadError>

Attempts to move a resource from its current location to the new path.

pub async fn reload_resources(&self)

Reloads all loaded resources. Normally it should never be called, because it is very heavy method! This method is asynchronous, it uses all available CPU power to reload resources as fast as possible.

Trait Implementations

impl Clone for ResourceManager

fn clone(&self) -> ResourceManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResourceManager

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.