Struct fyrox::asset::manager::ResourceManagerState

pub struct ResourceManagerState {
    pub loaders: ResourceLoadersContainer,
    pub event_broadcaster: ResourceEventBroadcaster,
    pub constructors_container: ResourceConstructorContainer,
    pub built_in_resources: HashMap<PathBuf, UntypedResource, BuildHasherDefault<FxHasher>>,
    pub resource_io: Arc<dyn ResourceIo>,
    /* private fields */
}

See module docs.

Fields

loaders: ResourceLoadersContainer

A set of resource loaders. Use this field to register your own resource loader.

event_broadcaster: ResourceEventBroadcaster

Event broadcaster can be used to “subscribe” for events happening inside the container.

constructors_container: ResourceConstructorContainer

A container for resource constructors.

built_in_resources: HashMap<PathBuf, UntypedResource, BuildHasherDefault<FxHasher>>

A set of built-in resources, that will be used to resolve references on deserialization.

resource_io: Arc<dyn ResourceIo>

The resource acccess interface

Implementations

impl ResourceManagerState

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

Returns the task pool used by this resource manager.

pub fn set_resource_io(&mut self, resource_io: Arc<dyn ResourceIo>)

Set the IO source that the resource manager should use when loading assets

pub fn set_watcher(&mut self, watcher: Option<FileSystemWatcher>)

Sets resource watcher which will track any modifications in file system and forcing the manager to reload changed resources. By default there is no watcher, since it may be an undesired effect to reload resources at runtime. This is very useful thing for fast iterative development.

pub fn count_registered_resources(&self) -> usize

Returns total amount of registered resources.

pub fn loading_progress(&self) -> usize

Returns percentage of loading progress. This method is useful to show progress on loading screen in your game. This method could be used alone if your game depends only on external resources, or if your game doing some heavy calculations this value can be combined with progress of your tasks.

pub fn update(&mut self, dt: f32)

Update resource containers and do hot-reloading.

Resources are removed if they’re not used or reloaded if they have changed in disk.

Normally, this is called from Engine::update(). You should only call this manually if you don’t use that method.

pub fn push(&mut self, resource: UntypedResource)

Adds a new resource in the container.

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

where P: AsRef<Path>,

Tries to find a resources by its path. Returns None if no resource was found.

Complexity

O(n)

pub fn len(&self) -> usize

Returns total amount of resources in the container.

pub fn is_empty(&self) -> bool

Returns true if the resource manager has no resources.

pub fn iter(&self) -> impl Iterator<Item = &UntypedResource>

Creates an iterator over resources in the manager.

pub fn destroy_unused_resources(&mut self)

Immediately destroys all resources in the manager that are not used anywhere else.

pub fn count_pending_resources(&self) -> usize

Returns total amount of resources that still loading.

pub fn count_loaded_resources(&self) -> usize

Returns total amount of completely loaded resources.

pub fn resources(&self) -> Vec<UntypedResource>

Returns a set of resource handled by this container.

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

where P: AsRef<Path>,

Tries to load a resources at a given path.

pub fn reload_resource(&mut self, resource: UntypedResource)

Reloads a single resource.

pub fn reload_resources(&mut self) -> Vec<UntypedResource>

Reloads all resources in the container. Returns a list of resources that will be reloaded. You can use the list to wait until all resources are loading.

pub fn get_wait_context(&self) -> ResourceWaitContext

Wait until all resources are loaded (or failed to load).

pub fn try_reload_resource_from_path(&mut self, path: &Path) -> bool

Tries to reload a resource at the given path.

pub fn unregister(&mut self, path: &Path)

Forgets that a resource at the given path was ever loaded, thus making it possible to reload it again as a new instance.