Struct ResourceManager 

pub struct ResourceManager {
    pub resources: HashMap<String, Box<dyn LoadableResource>>,
}

Manages a collection of loadable resources indexed by their name

Fields

resources: HashMap<String, Box<dyn LoadableResource>>

Map resource name to a type that implements LoadableResource trait

Implementations

impl ResourceManager

pub fn new() -> Self

Create a new manager with empty resources field

Examples found in repository

examples/hello.rs (line 60)

async fn main() {
    let resource_manager = Arc::new(Mutex::new(ResourceManager::new()));
    let graphics = graphics::GraphicsBuilder::new()
        .window_name(String::from("game"))
        .dimensions((500, 500))
        .resource_manager(resource_manager.clone())
        // we bulk load resources here because either we'll have to deal with
        // ownership of `graphics` (the actual `let graphics`, not the closure
        // argument)
        // you may think of it like about just some initialization func
        .initializer(|graphics| {
            resource_manager.lock().unwrap().load_dir(PathBuf::from("assets"), graphics).unwrap();
        })
        .build();
    let mut window = Window::new(graphics.unwrap(), resource_manager);

    // because events::run takes a `&'static mut dyn WindowEventHandler` as a second argument we
    // need to do this seemingly weird thing (while `app.rs` in fennel-engine has an ass solution
    // with raw pointers lmfao) 
    let handler: &'static mut dyn WindowEventHandler = {
        let boxed = Box::new(State);
        Box::leak(boxed) as &'static mut dyn WindowEventHandler
    };
    events::run(&mut window, handler).await;
}

pub fn load_dir(&mut self, path: PathBuf, graphics: &mut Graphics) -> Result<()>

Loads assets from a directory, which must contain a manifest

Errors

Returns an error if manifest does not exist in the target directory

Examples found in repository

examples/hello.rs (line 70)

async fn main() {
    let resource_manager = Arc::new(Mutex::new(ResourceManager::new()));
    let graphics = graphics::GraphicsBuilder::new()
        .window_name(String::from("game"))
        .dimensions((500, 500))
        .resource_manager(resource_manager.clone())
        // we bulk load resources here because either we'll have to deal with
        // ownership of `graphics` (the actual `let graphics`, not the closure
        // argument)
        // you may think of it like about just some initialization func
        .initializer(|graphics| {
            resource_manager.lock().unwrap().load_dir(PathBuf::from("assets"), graphics).unwrap();
        })
        .build();
    let mut window = Window::new(graphics.unwrap(), resource_manager);

    // because events::run takes a `&'static mut dyn WindowEventHandler` as a second argument we
    // need to do this seemingly weird thing (while `app.rs` in fennel-engine has an ass solution
    // with raw pointers lmfao) 
    let handler: &'static mut dyn WindowEventHandler = {
        let boxed = Box::new(State);
        Box::leak(boxed) as &'static mut dyn WindowEventHandler
    };
    events::run(&mut window, handler).await;
}

pub fn cache_asset(&mut self, asset: Box<dyn LoadableResource>) -> Result<()>

Insert a loaded asset into the cache

The asset is stored under the key returned by asset.name()

pub fn get_asset(&self, name: String) -> Result<&Box<dyn LoadableResource>>

pub fn is_cached(&self, name: String) -> bool

Check if a resource is cached

Trait Implementations

impl Default for ResourceManager

fn default() -> Self

default() is equivalent to ResourceManager::new().

impl Send for ResourceManager

impl Sync for ResourceManager