Struct Cache 

pub struct Cache<'w> { /* private fields */ }

Combined system parameter for the cache manifest and config resources.

This removes the need to request both ResMut<CacheManifest> and Res<CacheConfig> in every system that interacts with the cache.

use bevy::prelude::*;
use bevy_cache::prelude::*;

fn cache_screenshot(
    mut cache: Cache,
    asset_server: Res<AssetServer>,
) {
    cache
        .store(
            "screenshots/title",
            "png",
            std::io::Cursor::new(vec![1, 2, 3]),
            None,
        )
        .expect("cache write failed");

    let _handle: Handle<Image> = cache
        .load_cached(&asset_server, "screenshots/title")
        .expect("cache load failed");
}

Implementations

impl<'w> Cache<'w>

pub fn config(&self) -> &CacheConfig

Returns the cache configuration resource.

pub fn manifest(&self) -> &CacheManifest

Returns the cache manifest resource.

pub fn manifest_mut(&mut self) -> &mut CacheManifest

Returns the cache manifest resource mutably.

pub fn store<R: Read>( &mut self, key: &str, extension: &str, reader: R, max_age: Option<Duration>, ) -> Result<(), CacheError>

Store data in the cache under key using the given file extension.

pub fn remove(&mut self, key: &str) -> Result<(), CacheError>

Remove a cache entry and its backing file from disk.

pub fn contains(&self, key: &str) -> bool

Check whether a key exists in the manifest.

pub fn get(&self, key: &str) -> Option<&CacheEntry>

Get a manifest entry by key.

pub fn asset_path(&self, key: &str) -> Option<String>

Return the cache:// asset path for key, if present.

pub fn is_cached(&self, key: &str) -> bool

Check whether the cached file for key still exists on disk.

pub fn total_size_bytes(&self) -> u64

Returns the total manifest-reported size of cached data in bytes.

pub fn load<A: Asset>( &self, asset_server: &AssetServer, key: &str, ) -> Option<Handle<A>>

Load a cached asset path through the provided AssetServer.

This returns None when the key does not exist in the manifest.

pub fn load_cached<A: Asset>( &self, asset_server: &AssetServer, key: &str, ) -> Result<Handle<A>, CacheError>

Load a cached asset through the provided AssetServer, returning an error when the manifest entry is missing or stale.

Trait Implementations

impl SystemParam for Cache<'_>

type State = FetchState

Used to store data which persists across invocations of a system.

type Item<'w, 's> = Cache<'w>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state(world: &mut World) -> Self::State

Creates a new instance of this param’s State.

fn init_access( state: &Self::State, system_meta: &mut SystemMeta, component_access_set: &mut FilteredAccessSet, world: &mut World, )

Registers any World access used by this SystemParam

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during ApplyDeferred.

fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next ApplyDeferred.

unsafe fn validate_param<'w, 's>( state: &'s mut Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, ) -> Result<(), SystemParamValidationError>

Validates that the param can be acquired by the get_param.

unsafe fn get_param<'w, 's>( state: &'s mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> Self::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction.

impl<'w, 's> ReadOnlySystemParam for Cache<'w>

where ResMut<'w, CacheManifest>: ReadOnlySystemParam, Res<'w, CacheConfig>: ReadOnlySystemParam,