Struct jumpy::prelude::AllPacksData

pub struct AllPacksData<'a, Core, Pack>
where
    Core: HasSchema,
    Pack: HasSchema,
{
    core_root: Root<'a, Core>,
    pack_roots: Packs<'a, Pack>,
}

A helper system param that allows for iteration over data contained in the core game asset pack (the one in the assets/ directory) and the supplementary asset packs (the sub-directories of the packs/ directory).

This is intended for use with lists contained in the asset packs. For example, the core and supplementary asset packs may contain lists of characters that users can choose to play as. This system param may be used to iterate all of the characters available in all of the asset packs.

Example

use bones_framework::prelude::*;
use tracing::info;

#[derive(Clone, Default, HasSchema)]
#[type_data(metadata_asset("root"))]
#[repr(C)]
struct GameMeta {
    maps: SVec<Handle<MapMeta>>,
}

#[derive(Clone, Default, HasSchema)]
#[type_data(metadata_asset("pack"))]
#[repr(C)]
struct PackMeta {
    maps: SVec<Handle<MapMeta>>,
}

#[derive(Clone, Default, HasSchema)]
#[type_data(metadata_asset("root"))]
struct MapMeta {
    name: String,
}

// Log the names of all maps in the core and other asset packs.
fn test(asset_server: Res<AssetServer>, packs: AllPacksData<GameMeta, PackMeta>) {
    for handle in packs.iter_with(
        |game: &GameMeta| game.maps.iter().copied(),
        |pack: &PackMeta| pack.maps.iter().copied()
    ) {
        let map_meta = asset_server.get(handle);
        info!(name = map_meta.name, "map");
    }
}

// Make sure that `AllPacksData` is a valid system param.
IntoSystem::system(test);

Fields

core_root: Root<'a, Core>

pack_roots: Packs<'a, Pack>

Implementations

impl<'a, Core, Pack> AllPacksData<'a, Core, Pack>

where Core: HasSchema, Pack: HasSchema,

pub fn iter_with<T, CoreItemIt, PackItemIt>( &'a self, core_accessor: impl FnMut(&'a Core) -> CoreItemIt, pack_accessor: impl FnMut(&'a Pack) -> PackItemIt + 'static, ) -> AllPacksDataIter<'a, T, CoreItemIt, Pack, PacksIter<'a, Pack>, PackItemIt>

where CoreItemIt: Iterator<Item = T>, PackItemIt: Iterator<Item = T>,

Get the iterator over the core and supplementary asset packs.

The first argument core_accessor is a function that must produce an iterator of T from the core asset metadata. This is only called once, prior to iteration.

Similarly, the second argument pack_accessor is a function that must produce an iterator of T from a pack asset metadata. This is called once per pack, during iteration.

Trait Implementations

impl<'a, Core, Pack> SystemParam for AllPacksData<'a, Core, Pack>

where Core: HasSchema, Pack: HasSchema,

type State = (<Root<'a, Core> as SystemParam>::State, <Packs<'a, Pack> as SystemParam>::State)

The intermediate state for the parameter, that may be extracted from the world.

type Param<'s> = AllPacksData<'s, Core, Pack>

The type of the parameter, ranging over the lifetime of the intermediate state.

fn get_state( world: &World, ) -> <AllPacksData<'a, Core, Pack> as SystemParam>::State

This is called to produce the intermediate state of the system parameter.

fn borrow<'s>( world: &'s World, state: &'s mut <AllPacksData<'a, Core, Pack> as SystemParam>::State, ) -> <AllPacksData<'a, Core, Pack> as SystemParam>::Param<'s>

This is used create an instance of the system parame, possibly borrowed from the intermediate parameter state.