Struct Assets 

pub struct Assets { /* private fields */ }

Everything Config::with_assets loaded, by name across all sources.

A name only one source used is read bare, "Ship"; a name more than one shares needs its source, "props#Ship".

Implementations

impl Assets

pub fn mesh<P: Part>(&self, name: &str) -> MeshData<P, NoClips>

The mesh a source loaded under name, its material names resolved to the parts P.

A part names exactly one material; one that resolves to no part is drawn as authored unless a draw repaints every slot. A missing or ambiguous name, a part no material resolves to, and a part two materials resolve to each return empty data, which carries the name into the startup error.

Examples found in repository

examples/sprite-adventure.rs (line 729)

    fn build(&self, assets: &Assets) -> MeshData {
        assets.mesh(DOOR_MESH)
    }
}

/// The loaded gem, repainted whole per draw so its glow color shifts.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Gem;

impl Mesh for Gem {
    fn build(&self, assets: &Assets) -> MeshData {
        assets.mesh(GEM_MESH)
    }

examples/breakout-game.rs (line 181)

    fn build(&self, assets: &Assets) -> MeshData<PaddlePart> {
        assets.mesh(PADDLE_MESH)
    }

pub fn model<P: Part, C: Clip>(&self, name: &str) -> MeshData<P, C>

The model a source loaded under name: the mesh of one of its root nodes, the joints that pose it, and one animation per clip of C.

Material names resolve to the parts P as mesh resolves them, and each clip resolves the one animation of the source whose name it matches. An animation no clip matches is left alone; a clip that matches none, a clip two animations match, and a clip whose animation moves no joint of this model each return empty data, which carries the name into the startup error.

Examples found in repository

examples/animation.rs (line 285)

    fn build(&self, assets: &Assets) -> MeshData<NoParts, ElfClip> {
        assets.model(ELF_ROOT)
    }
}

/// What the game fills each tick to move `ElfState` on.
#[derive(Default)]
struct ElfInput {
    /// The elf's speed this tick, a fraction of [`ELF_SPEED`].
    speed: f32,
    attack: bool,
    /// True the tick a hurt patch is stepped onto and [`FATAL_HITS`] have
    /// not yet landed.
    hit: bool,
    /// True the tick a hurt patch is stepped onto the third time, which
    /// [`FATAL_HITS`] counts.
    dying: bool,
    jump: bool,
    /// True the tick `Jump`'s own height curve returns the elf to the
    /// ground after it launches.
    landed: bool,
    dance: bool,
    /// `Button::Interact`, read as sitting down, standing back up, or
    /// nothing, by the state it reaches.
    interact: bool,
    /// Whether the elf stands close enough to the cube to sit on it.
    near_seat: bool,
}

#[derive(Clone, Copy, Eq, PartialEq, Debug)]
enum ElfState {
    Idle,
    Locomotion,
    Attack,
    Hit,
    Death,
    SitDown,
    Sit,
    StandUp,
    Jump,
    Dance,
}

impl ElfState {
    /// Whether the elf is on the seat, or on its way onto or off it.
    fn seated(self) -> bool {
        matches!(self, Self::SitDown | Self::Sit | Self::StandUp)
    }

    /// `Locomotion` where `input` reads a walk or a run, `Idle` at rest:
    /// where a grounded state returns once whatever interrupted it ends.
    fn grounded(input: &ElfInput) -> Self {
        match input.speed > WALK_THRESHOLD {
            true => Self::Locomotion,
            false => Self::Idle,
        }
    }
}

impl AnimationStates for ElfState {
    type Clip = ElfClip;
    type Input = ElfInput;

    fn entry() -> Self {
        Self::Idle
    }

    fn motion(&self, input: &ElfInput) -> Motion<ElfClip> {
        match self {
            Self::Idle => Motion::looping(ElfClip::Idle),
            Self::Locomotion => {
                Motion::blend(ElfClip::Walk, ElfClip::Jog, input.speed).paced(input.speed)
            }
            Self::Attack => Motion::once(ElfClip::Attack),
            Self::Hit => Motion::once(ElfClip::Hit),
            Self::Death => Motion::once(ElfClip::Death),
            Self::SitDown => Motion::once(ElfClip::SitDown),
            Self::Sit => Motion::looping(ElfClip::Sit),
            Self::StandUp => Motion::once(ElfClip::StandUp),
            Self::Jump => Motion::once(ElfClip::Jump),
            Self::Dance => Motion::looping(ElfClip::Dance),
        }
    }

    fn next(&self, input: &ElfInput, at: Progress) -> Option<Transition<Self>> {
        match (self, input) {
            (Self::Death, _) => None,
            (_, ElfInput { dying: true, .. }) => Some(Self::Death.fade(DEATH_FADE)),
            (_, ElfInput { hit: true, .. }) if *self != Self::Hit => {
                Some(Self::Hit.fade(HIT_ENTER_FADE))
            }
            (Self::Hit, _) if at.ended() => Some(ElfState::grounded(input).fade(HIT_EXIT_FADE)),
            (Self::Attack, ElfInput { attack: true, .. }) if at.past(ATTACK_RELEASE) => Some(
                Self::Attack
                    .restarted()
                    .entering_at(ATTACK_CHAIN_ENTRY)
                    .fade(ATTACK_CHAIN_FADE),
            ),
            (Self::Attack, _) if at.past(ATTACK_RELEASE) => {
                Some(ElfState::grounded(input).fade(ATTACK_EXIT_FADE))
            }
            (Self::SitDown | Self::Sit | Self::StandUp, i) if i.speed > WALK_THRESHOLD => {
                Some(Self::Locomotion.fade(STAND_EXIT_FADE))
            }
            (Self::SitDown | Self::Sit | Self::StandUp, ElfInput { attack: true, .. }) => {
                Some(Self::Attack.fade(ATTACK_ENTER_FADE))
            }
            (Self::SitDown | Self::Sit | Self::StandUp, ElfInput { jump: true, .. }) => {
                Some(Self::Jump.fade(JUMP_ENTER_FADE))
            }
            (Self::SitDown, _) if at.ended() => Some(Self::Sit.at_once()),
            (Self::Sit, ElfInput { interact: true, .. }) => Some(Self::StandUp.fade(STAND_UP_FADE)),
            (Self::StandUp, _) if at.ended() => Some(Self::Idle.fade(STAND_EXIT_FADE)),
            (Self::Jump, ElfInput { landed: true, .. }) => {
                Some(ElfState::grounded(input).fade(JUMP_EXIT_FADE))
            }
            (Self::Jump, _) if at.ended() => Some(ElfState::grounded(input).fade(JUMP_EXIT_FADE)),
            (
                Self::Idle | Self::Locomotion,
                ElfInput {
                    interact: true,
                    near_seat: true,
                    ..
                },
            ) => Some(Self::SitDown.fade(SIT_DOWN_FADE)),
            (Self::Idle | Self::Locomotion, ElfInput { attack: true, .. }) => {
                Some(Self::Attack.fade(ATTACK_ENTER_FADE))
            }
            (Self::Idle | Self::Locomotion, ElfInput { jump: true, .. }) => {
                Some(Self::Jump.fade(JUMP_ENTER_FADE))
            }
            (Self::Idle, ElfInput { dance: true, .. }) => Some(Self::Dance.fade(DANCE_FADE)),
            (Self::Dance, i) if i.speed > WALK_THRESHOLD => {
                Some(Self::Locomotion.fade(IDLE_LOCOMOTION_FADE))
            }
            (Self::Idle, i) if i.speed > WALK_THRESHOLD => {
                Some(Self::Locomotion.fade(IDLE_LOCOMOTION_FADE))
            }
            (Self::Locomotion, i) if i.speed <= WALK_THRESHOLD => {
                Some(Self::Idle.fade(IDLE_LOCOMOTION_FADE))
            }
            _ => None,
        }
    }
}

/// A machine of one state, posed by nothing but the value it scrubs.
#[derive(Clone, Copy, Eq, PartialEq, Debug)]
enum ScrubbedState {
    SitDown,
}

/// What the game fills each tick to move `ScrubbedState` on.
#[derive(Default)]
struct ScrubbedInput {
    /// How far into sitting down the second elf reads, a fraction in
    /// `0.0..=1.0`.
    settled: f32,
}

impl AnimationStates for ScrubbedState {
    type Clip = ElfClip;
    type Input = ScrubbedInput;

    fn entry() -> Self {
        Self::SitDown
    }

    fn motion(&self, input: &ScrubbedInput) -> Motion<ElfClip> {
        Motion::scrubbed(ElfClip::SitDown, input.settled)
    }

    fn next(&self, _input: &ScrubbedInput, _at: Progress) -> Option<Transition<Self>> {
        None
    }
}

#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Butterfly;

/// The one clip `FlyingState` plays, named as the source names it.
#[derive(Clip, Clone, Debug, PartialEq, Eq, Hash)]
enum ButterflyClip {
    #[clip("fly")]
    Fly,
}

impl Mesh<NoParts, ButterflyClip> for Butterfly {
    fn build(&self, assets: &Assets) -> MeshData<NoParts, ButterflyClip> {
        assets.model(BUTTERFLY_ROOT)
    }

examples/flock-parallelism.rs (line 161)

    fn build(&self, assets: &Assets) -> MeshData<NoParts, ButterflyClip> {
        assets
            .model(BUTTERFLY_ROOT)
            .with_texture(greyed(&assets.texture(BUTTERFLY_SKIN)))
    }

pub fn texture(&self, name: &str) -> TextureData

The texture a source loaded under name.

A missing name returns empty pixels carrying the name into the startup error.

Examples found in repository

examples/isometric-board.rs (line 198)

    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(SPRITE_TEXTURE).pixelated())
    }

examples/sprite-adventure.rs (line 572)

    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(GROUND_SHEET).pixelated())
    }
}

/// The shoreline sprite laid over the pond's styled water, cutout so the
/// water shows through its cleared middle.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Shore;

impl Mesh for Shore {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(POND_SHEET).pixelated())
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A crate prop, its texture drawn over a cube.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Crate;

impl Mesh for Crate {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(CRATE_TEXTURE).pixelated())
    }
}

/// The well's rim.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Well;

impl Mesh for Well {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(WELL_SHEET).pixelated())
    }
}

/// The well's mouth, laid flat over the rim's top face.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct WellMouth;

impl Mesh for WellMouth {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(WELL_SHEET).pixelated())
    }
}

/// A stone box: the mouth's pillars and lintel.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Stone;

impl Mesh for Stone {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(STONE_SHEET).pixelated())
    }
}

/// A bush sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Bush;

impl Mesh for Bush {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(BUSH_SPRITE).pixelated())
            .with_relief(assets.relief(BUSH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A rock sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Rock;

impl Mesh for Rock {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(ROCK_SPRITE).pixelated())
            .with_relief(assets.relief(ROCK_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's post sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Torch;

impl Mesh for Torch {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(TORCH_SPRITE).pixelated())
            .with_relief(assets.relief(TORCH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's flame sprite, added over the dark rather than lit.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Flame;

impl Mesh for Flame {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(FLAME_SHEET).pixelated())
            .with_material(Material::color(FLAME_TINT).additive())
    }
}

/// The player's sprite, cutout with its own relief, its sheet shared
/// with `examples/isometric-board.rs`.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Walker;

impl Mesh for Walker {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(WALKER_SHEET).pixelated())
            .with_relief(assets.relief(WALKER_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// The cave floor tile.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct CaveFloor;

impl Mesh for CaveFloor {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(CAVE_SHEET).pixelated())
    }
}

/// The cave wall face.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct CaveWall;

impl Mesh for CaveWall {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(CAVE_SHEET).pixelated())
    }

examples/flock-parallelism.rs (line 162)

    fn build(&self, assets: &Assets) -> MeshData<NoParts, ButterflyClip> {
        assets
            .model(BUTTERFLY_ROOT)
            .with_texture(greyed(&assets.texture(BUTTERFLY_SKIN)))
    }

pub fn relief(&self, name: &str) -> ReliefData

The texture a source loaded under name, read as a relief holding a normal and a depth per texel.

A missing name returns empty pixels carrying the name into the startup error.

Examples found in repository

examples/sprite-adventure.rs (line 643)

    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(BUSH_SPRITE).pixelated())
            .with_relief(assets.relief(BUSH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A rock sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Rock;

impl Mesh for Rock {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(ROCK_SPRITE).pixelated())
            .with_relief(assets.relief(ROCK_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's post sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Torch;

impl Mesh for Torch {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(TORCH_SPRITE).pixelated())
            .with_relief(assets.relief(TORCH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's flame sprite, added over the dark rather than lit.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Flame;

impl Mesh for Flame {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(FLAME_SHEET).pixelated())
            .with_material(Material::color(FLAME_TINT).additive())
    }
}

/// The player's sprite, cutout with its own relief, its sheet shared
/// with `examples/isometric-board.rs`.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Walker;

impl Mesh for Walker {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(WALKER_SHEET).pixelated())
            .with_relief(assets.relief(WALKER_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }

pub fn skybox(&self, name: &str) -> SkyboxData

The same pixels read as the whole sky: the whole way around across the image, and zenith to nadir down it.

A missing name returns a black sky carrying that name into the startup error, and so does an image that is no sky at all, under the name of the skybox it was built for.

Examples found in repository

examples/material-playground.rs (line 611)

    fn build(&self, assets: &Assets) -> SkyboxData {
        let sky = match self {
            Self::Dawn => SkyboxData::gradient(
                Color::rgb(0.55, 0.55, 0.75),
                Color::rgb(0.95, 0.6, 0.35),
                Color::rgb(0.12, 0.08, 0.06),
            ),
            Self::Noon => SkyboxData::gradient(
                Color::rgb(0.2, 0.45, 0.85),
                Color::rgb(0.75, 0.82, 0.9),
                Color::rgb(0.3, 0.3, 0.28),
            ),
            Self::Dusk => SkyboxData::gradient(
                Color::rgb(0.18, 0.1, 0.3),
                Color::rgb(0.85, 0.35, 0.2),
                Color::rgb(0.03, 0.02, 0.03),
            ),
            Self::Night => SkyboxData::gradient(
                Color::rgb(0.02, 0.02, 0.06),
                Color::rgb(0.05, 0.05, 0.1),
                Color::rgb(0.0, 0.0, 0.0),
            ),
            Self::Clear => assets.skybox("sky-clear"),
            Self::Classic => assets.skybox("sky-classic"),
            Self::ImageDawn => assets.skybox("sky-dawn"),
            Self::Sinister => assets.skybox("sky-sinister"),
            Self::LightBlueStars => assets.skybox("sky-stars-lightblue"),
            Self::BlueStars => assets.skybox("sky-stars-blue"),
            Self::Default => SkyboxData::gradient(DEFAULT_SKY, DEFAULT_SKY, DEFAULT_SKY),
        };
        let sky = match self.ground() {
            Some(ground) => sky.with_ground(ground),
            None => sky,
        };

        sky.lit_by(self.light())
    }

pub fn sound(&self, name: &str) -> SoundData

The sound a source loaded under name.

A missing name returns silence, which carries the name into the startup error.

Examples found in repository

examples/isometric-board.rs (line 234)

    fn build(&self, assets: &Assets) -> SoundData {
        match self {
            Sound::Click => assets.sound("click"),
        }
    }

examples/sprite-adventure.rs (line 763)

    fn build(&self, assets: &Assets) -> SoundData {
        match self {
            Sound::Interact => assets.sound("click"),
            Sound::Gem => assets.sound("win"),
        }
    }

examples/breakout-game.rs (line 207)

    fn build(&self, assets: &Assets) -> SoundData {
        match self {
            Sound::Serve => assets.sound("serve"),
            Sound::BallLost => assets.sound("lost"),
            Sound::LevelClear => assets.sound("win"),
            Sound::GameOver => assets.sound("gameover"),
            Sound::Bounce => assets.sound("bounce"),
            Sound::BrickBreak => assets.sound("break"),
            Sound::Music => assets.sound("music").streamed(),
            Sound::MenuMusic => assets.sound("menu_music").streamed(),
            Sound::Click => assets.sound("click"),
        }
    }

examples/sound-lab.rs (line 275)

    fn build(&self, assets: &Assets) -> SoundData {
        match self {
            Sound::Bounce => assets.sound("bounce"),
            Sound::Break => assets.sound("break"),
            Sound::Serve => assets.sound("serve"),
            Sound::GameOver => assets.sound("gameover"),
            Sound::Lost => assets.sound("lost"),
            Sound::Win => assets.sound("win"),
            Sound::Click => assets.sound("click"),
            Sound::Theme => assets.sound("music").streamed(),
            Sound::ThemeDecoded => assets.sound("music"),
            Sound::MenuTheme => assets.sound("menu_music").streamed(),
            Sound::Pulse => assets.sound("break"),
        }
    }

Trait Implementations

impl Default for Assets

fn default() -> Self

Returns the “default value” for a type.