Struct TickContext 

pub struct TickContext<'a, G: Game> { /* private fields */ }

The work Game::tick may do: simulate, never draw.

Implementations

impl<'a, G: Game> TickContext<'a, G>

pub fn down<A: InputButtonAction>(&self, action: A) -> bool

where G::InputActions: Seats<A, A::Binding>,

Whether action is held right now.

Every tick of one drawn frame reads the same controls.

Examples found in repository

examples/animation.rs (line 703)

    fn advance(&mut self, ctx: &mut TickContext<'_, Scene>) -> f32 {
        let control = ctx.axis2(Move::Walk).clamp_length_max(1.0);
        let turn = Quat::from_rotation_y(self.camera_yaw);
        let heading = turn * Vec3::X * control.x + turn * Vec3::NEG_Z * control.y;
        let dt = ctx.dt().as_secs_f32();
        if let Some(direction) = heading.try_normalize() {
            let wanted = direction.x.atan2(direction.z);
            let turn = (wanted - self.elf_yaw + core::f32::consts::PI).rem_euclid(TAU)
                - core::f32::consts::PI;
            self.elf_yaw += turn.clamp(-TURN_RATE * dt, TURN_RATE * dt);
        }
        let cap = if ctx.down(Button::Run) { 1.0 } else { WALK_CAP };
        self.elf_pos += heading * cap * ELF_SPEED * dt;
        heading.length() * cap
    }

pub fn pressed<A: InputButtonAction>(&self, action: A) -> bool

where G::InputActions: Seats<A, A::Binding>,

Whether action went down since the last frame whose ticks ran.

A frame that runs no ticks holds its edges for the ticks that follow, so every press is read by the ticks of exactly one frame.

Examples found in repository

examples/breakout-game.rs (line 404)

    fn hold_ball(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        self.ball_prev = self.ball_pos;
        self.ball_pos.x = self.paddle_x;
        self.ball_trail = [self.ball_pos; TRAIL_LEN + 1];

        if !ctx.ui_wants_keyboard() && ctx.pressed(Button::Serve) {
            self.launch();
            ctx.play(Sound::Serve);
        }
    }

examples/ui-fonts.rs (line 804)

    fn tick(&mut self, ctx: &mut TickContext<'_, Self>) {
        self.elapsed += ctx.dt();
        self.orbit.yaw += AUTO_TURN_RATE * ctx.dt().as_secs_f32();

        if let Some(dialogue) = &mut self.dialogue {
            dialogue.tick();
        }
        if ctx.pressed(Trigger::Close) {
            self.dialogue = None;
            self.hailed = None;
        }
        if ctx.pressed(Trigger::Sheet) {
            self.sheet_open = !self.sheet_open;
        }
        if ctx.pressed(Trigger::Hail) && !ctx.ui_wants_pointer() {
            self.handle_hail(ctx);
        }
    }

examples/sound-lab.rs (line 488)

    fn handle_drag(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        // Read before the check below for the UI's own claim on the
        // pointer, so a release over it still frees a source a drag moved
        // there.
        if ctx.released(Button::Select) {
            self.dragging = None;
        }
        if ctx.ui_wants_pointer() {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if ctx.pressed(Button::Select) {
            self.dragging = self.sources.iter().position(|source| {
                ray.hit_sphere(source.position, SOURCE_PICK_RADIUS)
                    .is_some()
            });
        }

        let Some(index) = self.dragging else {
            return;
        };
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let hit = ray.at(distance);
        let dropped =
            Vec2::new(hit.x, hit.z).clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
        self.sources[index].position = Vec3::new(dropped.x, SOURCE_HEIGHT, dropped.y);
    }

examples/animation.rs (line 737)

    fn tick_elf(&mut self, ctx: &mut TickContext<'_, Scene>) {
        let grounded = matches!(
            self.elf_animator.state(),
            ElfState::Idle | ElfState::Locomotion
        );

        self.elf_input.speed = self.advance(ctx);
        self.elf_input.attack = ctx.pressed(Button::Attack);
        self.elf_input.jump = ctx.pressed(Button::Jump);
        self.elf_input.dance = ctx.pressed(Button::Dance);

        self.elf_input.near_seat = self.elf_pos.distance(SEAT_POSITION) < SEAT_INTERACT_RADIUS;
        self.elf_input.interact = ctx.pressed(Button::Interact);
        if self.elf_input.interact && grounded && self.elf_input.near_seat {
            self.elf_pos = SEAT_SPOT;
            self.elf_yaw = SEAT_FACING;
        }

        let underfoot = self.patch_underfoot();
        let entered_patch = underfoot.is_some() && !self.in_patch;
        self.in_patch = underfoot.is_some();
        self.hits += u32::from(entered_patch);
        self.elf_input.hit = entered_patch && self.hits < FATAL_HITS;
        self.elf_input.dying = entered_patch && self.hits >= FATAL_HITS;
        if entered_patch {
            self.last_event = match self.elf_input.dying {
                true => "elf died",
                false => "elf hit",
            };
        }
    }

    /// Starts a new [`Animator`] over the elf's own state, its position and
    /// hit count reset with it.
    fn restart_elf(&mut self) {
        self.elf_animator = Animator::new();
        self.elf_pos = ELF_START;
        self.elf_prev = ELF_START;
        self.elf_yaw = 0.0;
        self.elf_height = 0.0;
        self.elf_height_prev = 0.0;
        self.jump_speed = 0.0;
        self.elf_input = ElfInput::default();
        self.hits = 0;
        self.in_patch = false;
        self.last_event = "new elf started";
    }

    fn panel(&self, ctx: &mut FrameContext<'_, Scene>) {
        let state = match self.elf_animator.state() {
            ElfState::Idle => "idle",
            ElfState::Locomotion if self.elf_input.speed > WALK_CAP => "running",
            ElfState::Locomotion => "walking",
            ElfState::Attack => "attacking",
            ElfState::Hit => "hit",
            ElfState::Death => "dead",
            ElfState::SitDown => "sitting down",
            ElfState::Sit => "sitting",
            ElfState::StandUp => "standing up",
            ElfState::Jump => "jumping",
            ElfState::Dance => "dancing",
        };
        ctx.ui(|ui| {
            egui::Frame::new()
                .fill(egui::Color32::from_black_alpha(PANEL_BACKDROP))
                .inner_margin(PANEL_PADDING)
                .corner_radius(f32::from(PANEL_PADDING))
                .show(ui, |ui| {
                    ui.heading(panel_text(format!("elf is {state}")));
                    ui.label(panel_text(format!(
                        "hits taken {} of the {} red patches hurt for, {}",
                        self.hits, FATAL_HITS, self.last_event
                    )));
                    ui.label(panel_text(match self.elf_animator.transitioning() {
                        true => "fading between clips",
                        false => "one clip playing",
                    }));
                    ui.add_space(f32::from(PANEL_PADDING));
                    egui::Grid::new("controls").show(ui, |ui| {
                        for (key, does) in CONTROLS {
                            ui.label(panel_text(key));
                            ui.label(panel_text(does));
                            ui.end_row();
                        }
                    });
                });
        });
    }

    /// A prompt over the seat, each hurt patch, and the scrubbed elf,
    /// naming what a player finds there; the seat's own prompt names the
    /// live binding of `Button::Interact` by its own name, not one fixed
    /// in the code, and is absent while the elf sits on it.
    fn draw_prompts(&self, ctx: &mut FrameContext<'_, Scene>, camera: Camera) {
        let sit_key = ctx
            .bindings(Button::Interact)
            .into_iter()
            .next()
            .map_or_else(|| "interact".to_owned(), |binding| binding.to_string());
        let sit = ctx.text_layout(
            &format!("{sit_key} sits"),
            egui::FontId::proportional(PROMPT_SIZE),
        );
        let hurts = ctx.text_layout("hurts", egui::FontId::proportional(PROMPT_SIZE));
        let walk_closer = ctx.text_layout("walk closer", egui::FontId::proportional(PROMPT_SIZE));

        let mut prompts = vec![(
            SCRUBBED_ELF_POSITION + Vec3::Y * (ELF_HEIGHT + PROMPT_LIFT),
            walk_closer,
        )];
        if !self.elf_animator.state().seated() {
            prompts.push((
                SEAT_POSITION + Vec3::Y * (SEAT_HEAD_HEIGHT + PROMPT_LIFT),
                sit,
            ));
        }
        prompts.extend(HURT_PATCHES.map(|patch| (patch + Vec3::Y * PROMPT_LIFT, hurts.clone())));

        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();
        ctx.ui(|ui| {
            let painter = ui.painter();
            for (point, galley) in prompts {
                let Some(pixel) = camera.pixel_of(point, window_size) else {
                    continue;
                };
                let at = logical(pixel, pixels_per_point);
                let ink = galley.mesh_bounds;
                let pos = egui::pos2(at.x - ink.center().x, at.y - ink.center().y);
                let backdrop = egui::Rect::from_center_size(
                    at,
                    ink.size() + egui::Vec2::splat(PROMPT_PADDING * 2.0),
                );
                painter.rect_filled(
                    backdrop,
                    PROMPT_PADDING,
                    egui::Color32::from_black_alpha(PANEL_BACKDROP),
                );
                painter.galley(pos, galley, PANEL_TEXT_COLOR);
            }
        });
    }
}

impl Game for Scene {
    type Meshes = Shape;
    type Sounds = NoSounds;
    type InputActions = Controls;
    type Skyboxes = Sky;
    type SurfaceStyles = NoSurfaceStyles;
    type PostEffects = NoPostEffects;

    fn tick(&mut self, ctx: &mut TickContext<'_, Scene>) {
        self.elf_prev = self.elf_pos;
        self.elf_height_prev = self.elf_height;

        if ctx.pressed(Button::Restart) {
            self.restart_elf();
        }
        if ctx.pressed(Button::Hold) {
            self.holding = true;
        }
        if ctx.pressed(Button::Release) {
            self.holding = false;
        }

        self.elf_input.landed = self.fall(ctx.dt().as_secs_f32());
        self.tick_elf(ctx);
        ctx.animate(Elf, &mut self.elf_animator, &self.elf_input);

        if self.elf_animator.entered(ElfState::Jump) {
            self.jump_speed = JUMP_LAUNCH_SPEED;
        }
        if self.elf_animator.left(ElfState::StandUp) {
            self.last_event = "elf stood up";
        }
        if self.elf_animator.entered(ElfState::Sit) {
            self.last_event = "elf sat down";
        }
        if self.elf_animator.entered(ElfState::Death) {
            self.last_event = "elf died";
        }

        let scrubbed_input = ScrubbedInput {
            settled: settled_at(self.elf_pos.distance(SCRUBBED_ELF_POSITION)),
        };
        ctx.animate(Elf, &mut self.scrubbed_animator, &scrubbed_input);
        ctx.animate(Butterfly, &mut self.butterfly_animator, &());
    }

examples/isometric-board.rs (line 415)

    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

examples/sprite-adventure.rs (line 1169)

    fn tick_cave(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.push_out_of(Self::cave_obstacles(self.door_obstacle()));
        self.position.x = self.position.x.clamp(-CAVE_HALF_WIDTH, CAVE_HALF_WIDTH);
        self.position.z = self.position.z.clamp(CAVE_WALK_FAR_Z, CAVE_WALK_NEAR_Z);

        let target = if self.position.z < DOOR_WALL_NEAR_Z {
            1.0
        } else {
            0.0
        };
        let step = 1.0 / GHOST_RAMP_TICKS as f32;
        self.ghost += (target - self.ghost).clamp(-step, step);

        if !self.door_opening
            && ctx.pressed(Button::Interact)
            && self.position.distance(INTERACT_POINT) < INTERACT_RADIUS
        {
            self.door_opening = true;
            self.swing_ticks = 0;
            ctx.play(Sound::Interact);
        }
        if self.door_opening && self.swing_ticks < DOOR_SWING_TICKS {
            self.swing_ticks += 1;
        }

        if !self.gem_taken && self.position.distance(GEM_POSITION) < PICKUP_RADIUS {
            self.gem_taken = true;
            ctx.play(Sound::Gem);
            ctx.save(Flag::GemTaken, true);
            ctx.save(Position::X, self.position.x as f64);
            ctx.save(Position::Z, self.position.z as f64);
        }

        if EXIT.holds(self.position) {
            if EXIT.holds(self.previous) {
                self.position.z = self.previous.z;
            } else {
                self.exit_cave(ctx);
            }
        }
    }

    /// Puts the player back at [`PLAYER_SPAWN`] with the cave and the gem
    /// returned to their saved fallbacks, all in this tick: a reset saves
    /// every key's own fallback, since there is nothing to clear it to.
    fn reset(&mut self, ctx: &mut TickContext<'_, Keep>) {
        ctx.save(Position::X, Position::X.fallback());
        ctx.save(Position::Z, Position::Z.fallback());
        ctx.save(Flag::InCave, Flag::InCave.fallback());
        ctx.save(Flag::GemTaken, Flag::GemTaken.fallback());

        self.area = Area::Overworld;
        self.position = PLAYER_SPAWN;
        self.previous = PLAYER_SPAWN;
        self.gem_taken = false;
        self.door_opening = false;
        self.swing_ticks = 0;
        self.ghost = 0.0;
    }

    /// Steps into the cave at [`CAVE_SPAWN`], saving the transition.
    fn enter_cave(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.area = Area::Cave;
        self.position = CAVE_SPAWN;
        self.previous = CAVE_SPAWN;
        ctx.save(Flag::InCave, true);
        ctx.save(Position::X, CAVE_SPAWN.x as f64);
        ctx.save(Position::Z, CAVE_SPAWN.z as f64);
    }

    /// Steps back out to the mouth at [`RETURN_SPAWN`], saving the
    /// transition.
    fn exit_cave(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.area = Area::Overworld;
        self.position = RETURN_SPAWN;
        self.previous = RETURN_SPAWN;
        ctx.save(Flag::InCave, false);
        ctx.save(Position::X, RETURN_SPAWN.x as f64);
        ctx.save(Position::Z, RETURN_SPAWN.z as f64);
    }

    fn draw_ground(&self, ctx: &mut FrameContext<'_, Keep>) {
        for col in -GROUND_DRAW_HALF..=GROUND_DRAW_HALF {
            for row in -GROUND_DRAW_HALF..=GROUND_DRAW_HALF {
                ctx.draw(
                    Ground
                        .at(Vec3::new(
                            col as f32 * TILE_SIZE,
                            0.0,
                            row as f32 * TILE_SIZE,
                        ))
                        .frame(ground_cell(col, row)),
                );
            }
        }
    }

    /// Two staggered rows of bushes around the clearing, open where the path
    /// leaves it, drawn between the camera and the ground's edge. The rows
    /// running along `Z` skip their two ends, which the rows running along
    /// `X` already cover.
    fn draw_hedgerow(&self, ctx: &mut FrameContext<'_, Keep>) {
        for (row, half) in [HEDGE_INNER_HALF, HEDGE_OUTER_HALF].into_iter().enumerate() {
            let row = row as i32;
            // The inner row covers both corners; the outer one is half a
            // span in from each, backing the gaps the inner row leaves.
            let spans = ((2.0 * half / HEDGE_STEP).round() as i32).max(1);
            let span = 2.0 * half / spans as f32;
            let steps = spans - row;
            for step in 0..=steps {
                let along = -half + (step as f32 + 0.5 * row as f32) * span;
                let scale = if (step + row) % 2 == 0 { 1.0 } else { 0.8 };
                let (width, height) = (BUSH_WIDTH * scale, BUSH_HEIGHT * scale);
                // The path leaves through the rows running along `X`, so only
                // those two open around it.
                let gated = along.abs() < HEDGE_GATE_HALF;
                let corner = step == 0 || step == steps;
                let places = [
                    (along, -half, gated),
                    (along, half, gated),
                    (-half, along, corner),
                    (half, along, corner),
                ];
                for (x, z, skip) in places {
                    if skip {
                        continue;
                    }
                    ctx.draw(
                        Bush.at(Transform::from_scale_rotation_translation(
                            Vec3::new(width, height, width),
                            Quat::IDENTITY,
                            Vec3::new(x, height * 0.5, z),
                        ))
                        .upright(),
                    );
                }
            }
        }
    }

    /// The pond: a square of styled water, and the shoreline sprite laid over
    /// it, which rings the open middle and hides the water's own edges.
    fn draw_pond(&self, ctx: &mut FrameContext<'_, Keep>) {
        ctx.draw(
            Plane
                .at(Transform::from_scale_rotation_translation(
                    Vec3::splat(POND_WATER_HALF * 2.0),
                    Quat::IDENTITY,
                    POND_CENTER,
                ))
                .material(Material::shaded(WATER_COLOR, WATER_LITNESS))
                .surface_style::<Water>(),
        );
        ctx.draw(
            Shore
                .at(Transform::from_scale_rotation_translation(
                    Vec3::splat(POND_HALF * 2.0),
                    Quat::IDENTITY,
                    Vec3::new(POND_CENTER.x, 0.0, POND_CENTER.z),
                ))
                .frame(Sheet::new(UVec2::new(POND_CELLS, 1)).cell(POND_SHORE_CELL)),
        );
    }

    fn draw_crates(&self, ctx: &mut FrameContext<'_, Keep>) {
        for &(x, z, turn) in &CRATE_POSITIONS {
            ctx.draw(Crate.at(Transform::from_scale_rotation_translation(
                Vec3::splat(CRATE_SIZE),
                Quat::from_rotation_y(turn),
                Vec3::new(x, CRATE_SIZE * 0.5, z),
            )));
        }
    }

    /// The well: its rim in grey masonry, and the mouth cell laid over the
    /// rim's top face.
    fn draw_well(&self, ctx: &mut FrameContext<'_, Keep>) {
        let cells = Sheet::new(UVec2::new(WELL_CELLS, 1));
        ctx.draw(
            Well.at(Transform::from_scale_rotation_translation(
                WELL_SIZE,
                Quat::IDENTITY,
                WELL_POSITION + Vec3::Y * (WELL_SIZE.y * 0.5),
            ))
            .frame(cells.cell(WELL_RIM_CELL)),
        );
        ctx.draw(
            WellMouth
                .at(Transform::from_scale_rotation_translation(
                    Vec3::new(WELL_SIZE.x, 1.0, WELL_SIZE.z),
                    Quat::IDENTITY,
                    WELL_POSITION + Vec3::Y * (WELL_SIZE.y + WELL_MOUTH_LIFT),
                ))
                .frame(cells.cell(WELL_MOUTH_CELL)),
        );
    }

    fn draw_flora(&self, ctx: &mut FrameContext<'_, Keep>) {
        for &(x, z, rock) in &FLORA {
            let (width, height) = if rock {
                (ROCK_WIDTH, ROCK_HEIGHT)
            } else {
                (BUSH_WIDTH, BUSH_HEIGHT)
            };
            let standing = Transform::from_scale_rotation_translation(
                Vec3::new(width, height, width),
                Quat::IDENTITY,
                Vec3::new(x, height * 0.5, z),
            );
            let flora: Instance<Shape, _> = if rock {
                Rock.at(standing).into_set()
            } else {
                Bush.at(standing).into_set()
            };
            ctx.draw(flora.upright());
        }
    }

    /// One stone box drawn on the ground at `at`, `size` across, sampling
    /// the part of the sheet `frame` covers.
    fn draw_stone(ctx: &mut FrameContext<'_, Keep>, at: Vec3, size: Vec3, frame: Frame) {
        ctx.draw(
            Stone
                .at(Transform::from_scale_rotation_translation(
                    size,
                    Quat::IDENTITY,
                    at + Vec3::Y * (size.y * 0.5),
                ))
                .frame(frame),
        );
    }

    /// Two stone pillars drawn where `mouth` blocks the player, each a
    /// capital over its own course of masonry, and, on the one the camera
    /// looks into, the lintel across their tops and the dark filling
    /// the opening under it.
    fn draw_mouth(ctx: &mut FrameContext<'_, Keep>, mouth: Mouth) {
        for at in mouth.pillars() {
            Self::draw_stone(ctx, at, MOUTH_PILLAR_SIZE, Frame::default());
        }
        if !mouth.looked_into() {
            return;
        }

        Self::draw_stone(
            ctx,
            mouth.at + Vec3::Y * MOUTH_PILLAR_SIZE.y,
            MOUTH_LINTEL_SIZE,
            masonry(MOUTH_LINTEL_TILES),
        );
        ctx.draw(
            Quad.at(Transform::from_scale_rotation_translation(
                Vec3::new(MOUTH_PILLAR_OFFSET * 2.0, MOUTH_DARK_HEIGHT, 1.0),
                Quat::IDENTITY,
                mouth.at + Vec3::Y * (MOUTH_DARK_HEIGHT * 0.5),
            ))
            .material(Material::color(Color::BLACK)),
        );
    }

    fn draw_cave_floor(&self, ctx: &mut FrameContext<'_, Keep>) {
        let half = CAVE_HALF_WIDTH as i32;
        let near = CAVE_NEAR_Z as i32;
        let far = CAVE_FAR_Z as i32;
        for col in -half..=half {
            for row in far..=near {
                let variant = (col * 13 + row * 7).rem_euclid(CAVE_COLUMNS as i32) as u32;
                ctx.draw(
                    CaveFloor
                        .at(Vec3::new(
                            col as f32 * TILE_SIZE,
                            0.0,
                            row as f32 * TILE_SIZE,
                        ))
                        .frame(
                            Sheet::new(UVec2::new(CAVE_COLUMNS, CAVE_ROWS))
                                .cell_at(UVec2::new(variant, CAVE_FLOOR_ROW)),
                        ),
                );
            }
        }
    }

    /// The wall drawn at `at` over the meters `standing`, in courses
    /// [`WALL_HEIGHT`] tall from the floor up, each cut to the part of it the
    /// span leaves; its faces are picked by `seed` and its stone faded to
    /// `fade`, which is `1.0` wherever it is solid.
    fn draw_wall(
        ctx: &mut FrameContext<'_, Keep>,
        at: Vec2,
        standing: Range<f32>,
        seed: i32,
        fade: f32,
    ) {
        for course in 0..WALL_COURSES {
            let base = course as f32 * WALL_HEIGHT;
            let low = (standing.start - base).max(0.0);
            let high = (standing.end - base).min(WALL_HEIGHT);
            if high <= low {
                continue;
            }

            let variant = (seed + course).rem_euclid(CAVE_COLUMNS as i32) as u32;
            ctx.draw(
                CaveWall
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::new(TILE_SIZE, high - low, TILE_SIZE),
                        Quat::IDENTITY,
                        Vec3::new(at.x, base + (low + high) * 0.5, at.y),
                    ))
                    .frame(cave_wall_face(variant, low..high))
                    .faded(fade),
            );
        }
    }

    /// The room's two side walls and its back wall, full height, and the low
    /// wall closing its near end between the side walls and the mouth. The
    /// back wall stops short of the corners the side walls already fill, and
    /// the near one leaves the mouth's own tile open.
    fn draw_cave_walls(&self, ctx: &mut FrameContext<'_, Keep>) {
        let half = CAVE_HALF_WIDTH as i32 + 1;
        let near = CAVE_NEAR_Z as i32;
        let far = CAVE_FAR_Z as i32;

        for row in far..=near {
            let z = row as f32 * TILE_SIZE;
            let west = Vec2::new(-half as f32 * TILE_SIZE, z);
            let east = Vec2::new(half as f32 * TILE_SIZE, z);
            Self::draw_wall(ctx, west, 0.0..WALL_TOP, row * 5, SOLID);
            Self::draw_wall(ctx, east, 0.0..WALL_TOP, row * 5 + 1, SOLID);
        }
        for col in (-half + 1)..half {
            let x = col as f32 * TILE_SIZE;
            let back = Vec2::new(x, far as f32 * TILE_SIZE);
            Self::draw_wall(ctx, back, 0.0..WALL_TOP, col * 5 + 2, SOLID);
            if col != 0 {
                let lip = Vec2::new(x, CAVE_LIP_Z);
                Self::draw_wall(ctx, lip, 0.0..CAVE_LIP_HEIGHT, col * 5 + 4, SOLID);
            }
        }
    }

    /// The wall the door hangs in, run across the room between the side walls
    /// with one tile left open on the room's axis for the doorway and stone
    /// filling the column over the door. A player behind the wall is drawn
    /// through the stacks between them and the camera, at `seen_through`,
    /// faded by `ghost`; the rest of it stays solid, and keeps casting.
    fn draw_door_wall(ctx: &mut FrameContext<'_, Keep>, seen_through: Option<f32>, ghost: f32) {
        let stone = |x: f32| match seen_through {
            Some(at) if (x - at).abs() < GHOST_CORRIDOR_HALF => ghost_alpha(ghost),
            _ => SOLID,
        };
        let half = CAVE_HALF_WIDTH as i32;

        for col in (-half..=half).filter(|&col| col != 0) {
            let x = col as f32 * TILE_SIZE;
            Self::draw_wall(
                ctx,
                Vec2::new(x, DOOR_Z),
                0.0..WALL_TOP,
                col * 5 + 3,
                stone(x),
            );
        }
        Self::draw_wall(
            ctx,
            Vec2::new(0.0, DOOR_Z),
            DOOR_HEIGHT..WALL_TOP,
            3,
            stone(0.0),
        );
    }

    /// The two torches: an upright cutout post apiece, the flame's loop
    /// burning over its binding, and the light that flame casts.
    fn draw_torches(&self, ctx: &mut FrameContext<'_, Keep>) {
        let elapsed = self.simulated.as_secs_f32();
        let loop_cells = Sheet::new(UVec2::new(FLAME_CELLS, 1));

        for (index, &(x, z)) in TORCH_POSITIONS.iter().enumerate() {
            let base = Vec3::new(x, 0.0, z);
            ctx.draw(
                Torch
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::new(TORCH_SPRITE_WIDTH, TORCH_STAND_HEIGHT, 1.0),
                        Quat::IDENTITY,
                        base + Vec3::Y * (TORCH_STAND_HEIGHT * 0.5),
                    ))
                    .upright(),
            );

            let phase = index as f32 * 2.1;
            let flicker = (elapsed * FLAME_FLICKER_SPEED + phase).sin();
            let flame_pos =
                base + Vec3::Y * (TORCH_STAND_HEIGHT + FLAME_LIFT + flicker * FLAME_BOB);

            let light_pos = flame_pos + Vec3::new(0.0, TORCH_LIGHT_LIFT, TORCH_LIGHT_STANDOFF);
            ctx.light(Light::point(light_pos, TORCH_LIGHT_COLOR, TORCH_LIGHT_RANGE).shadow());
            // The pair burn an even share of the loop apart.
            let offset = index as u32 * FLAME_CELLS / TORCH_POSITIONS.len() as u32;
            ctx.draw(
                Flame
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::splat(FLAME_SIZE),
                        Quat::IDENTITY,
                        flame_pos,
                    ))
                    .billboard()
                    .roll(flicker * FLAME_ROLL)
                    .frame(loop_cells.cell((elapsed * FLAME_RATE) as u32 + offset)),
            );
        }
    }

    /// The door at its hinge — swung back against the wall once opened —
    /// drawn through alongside its wall, faded by `ghost`.
    fn draw_door(&self, ctx: &mut FrameContext<'_, Keep>, ghost: f32) {
        let fade = ghost_alpha(ghost);
        let swung = if self.door_opening {
            Quat::from_rotation_y(core::f32::consts::FRAC_PI_2)
        } else {
            Quat::IDENTITY
        };

        ctx.draw(
            Door.at(Transform::from_rotation_translation(swung, DOOR_HINGE))
                .material(Material::shaded(DOOR_COLOR, DOOR_LITNESS))
                .faded(fade),
        );
    }

    /// The posts and lintel framing the doorway, in a color the stone never
    /// is, standing clear of the wall so the opening reads as a door from
    /// across the chamber. Glowing of their own while the door is closed and
    /// within [`INTERACT_RADIUS`], the cue that it opens.
    fn draw_door_frame(&self, ctx: &mut FrameContext<'_, Keep>, ghost: f32) {
        let reachable =
            !self.door_opening && self.position.distance(INTERACT_POINT) < INTERACT_RADIUS;
        let material =
            Material::shaded(DOOR_FRAME_COLOR, DOOR_FRAME_LITNESS).emissive(if reachable {
                DOOR_FRAME_GLOW
            } else {
                Color::BLACK
            });
        let fade = ghost_alpha(ghost);
        let z = DOOR_WALL_NEAR_Z + DOOR_FRAME_STANDOFF;
        let jamb_height = DOOR_HEIGHT + DOOR_FRAME_THICKNESS;

        for side in SIDES {
            ctx.draw(
                Cube.at(Transform::from_scale_rotation_translation(
                    Vec3::new(DOOR_FRAME_THICKNESS, jamb_height, DOOR_FRAME_THICKNESS),
                    Quat::IDENTITY,
                    Vec3::new(
                        side * (DOORWAY_HALF + DOOR_FRAME_THICKNESS * 0.5),
                        jamb_height * 0.5,
                        z,
                    ),
                ))
                .material(material)
                .faded(fade),
            );
        }
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::new(
                    DOOR_WIDTH + DOOR_FRAME_THICKNESS * 2.0,
                    DOOR_FRAME_THICKNESS,
                    DOOR_FRAME_THICKNESS,
                ),
                Quat::IDENTITY,
                Vec3::new(0.0, DOOR_HEIGHT + DOOR_FRAME_THICKNESS * 0.5, z),
            ))
            .material(material)
            .faded(fade),
        );
    }

    /// A world prompt over the door: what opens it while the player is
    /// within [`INTERACT_RADIUS`] and it is closed, and that it swings while
    /// it does; gone once it has swung [`DOOR_SWING_TICKS`]. Laid out and
    /// placed like `examples/animation.rs`'s own prompt.
    fn draw_door_prompt(&self, ctx: &mut FrameContext<'_, Keep>, camera: Camera) {
        let near = self.position.distance(INTERACT_POINT) < INTERACT_RADIUS;
        let swinging = self.door_opening && self.swing_ticks < DOOR_SWING_TICKS;
        let text = if swinging {
            "opening"
        } else if near && !self.door_opening {
            "e opens the door"
        } else {
            return;
        };

        let galley = ctx.text_layout(text, egui::FontId::proportional(DOOR_PROMPT_SIZE));
        let point = INTERACT_POINT + Vec3::Y * (DOOR_HEIGHT + DOOR_PROMPT_LIFT);
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();
        let Some(pixel) = camera.pixel_of(point, window_size) else {
            return;
        };

        ctx.ui(|ui| {
            let painter = ui.painter();
            let at = logical(pixel, pixels_per_point);
            let ink = galley.mesh_bounds;
            let pos = egui::pos2(at.x - ink.center().x, at.y - ink.center().y);
            let backdrop = egui::Rect::from_center_size(
                at,
                ink.size() + egui::Vec2::splat(DOOR_PROMPT_PADDING * 2.0),
            );
            painter.rect_filled(
                backdrop,
                DOOR_PROMPT_PADDING,
                egui::Color32::from_black_alpha(DOOR_PROMPT_BACKDROP),
            );
            painter.galley(pos, galley, DOOR_PROMPT_COLOR);
        });
    }

    /// The gem, spinning and bobbing over the chamber's floor, and the light
    /// it casts over it.
    fn draw_gem(&self, ctx: &mut FrameContext<'_, Keep>) {
        let t = self.simulated.as_secs_f32();
        let bob = (t * 2.0).sin() * GEM_BOB_HEIGHT;
        ctx.light(
            Light::point(
                GEM_POSITION + Vec3::Y * (bob + GEM_LIGHT_LIFT),
                GEM_LIGHT_COLOR,
                GEM_LIGHT_RANGE,
            )
            .shadow(),
        );
        ctx.draw(
            Gem.at(Transform::from_scale_rotation_translation(
                Vec3::ONE,
                Quat::from_rotation_y(t * GEM_SPIN_SPEED),
                GEM_POSITION + Vec3::Y * bob,
            ))
            .material(Material::shaded(GEM_COLOR, 0.7).emissive(GEM_COLOR.dimmed(1.6))),
        );
    }

    /// The player: upright so it always faces the camera about `+Y`,
    /// windowed to its facing's row and the walk cycle's current frame.
    fn draw_walker(&self, ctx: &mut FrameContext<'_, Keep>, ground: Vec3) {
        let step = if self.walk_ticks > 0 {
            (self.walk_ticks / TICKS_PER_WALK_FRAME) % WALKER_COLUMNS
        } else {
            0
        };
        let cell = Sheet::new(UVec2::new(WALKER_COLUMNS, WALKER_ROWS))
            .cell_at(UVec2::new(step, self.facing as u32));
        let size = Vec2::new(WALKER_WIDTH, WALKER_HEIGHT);

        ctx.draw(
            Walker
                .at(Transform::from_scale_rotation_translation(
                    size.extend(1.0),
                    Quat::IDENTITY,
                    ground + Vec3::Y * (WALKER_HEIGHT * 0.5),
                ))
                .upright()
                .frame(cell),
        );
    }

    fn frame_overworld(&mut self, ctx: &mut FrameContext<'_, Keep>) {
        let drawn_at = self.previous.lerp(self.position, ctx.alpha());
        ctx.set_camera(Self::camera(drawn_at, OVERWORLD_CAMERA_OFFSET));
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        self.draw_ground(ctx);
        self.draw_hedgerow(ctx);
        self.draw_pond(ctx);
        self.draw_crates(ctx);
        self.draw_well(ctx);
        self.draw_flora(ctx);
        Self::draw_mouth(ctx, ENTRANCE);
        self.draw_walker(ctx, drawn_at);
    }

    fn frame_cave(&mut self, ctx: &mut FrameContext<'_, Keep>) {
        let drawn_at = self.previous.lerp(self.position, ctx.alpha());
        let camera = Self::camera(drawn_at, CAVE_CAMERA_OFFSET);
        ctx.set_camera(camera);

        self.draw_cave_floor(ctx);
        self.draw_cave_walls(ctx);
        Self::draw_door_wall(ctx, (self.ghost > 0.0).then_some(drawn_at.x), self.ghost);
        Self::draw_mouth(ctx, EXIT);
        self.draw_torches(ctx);
        self.draw_door(ctx, self.ghost);
        self.draw_door_frame(ctx, self.ghost);
        if !self.gem_taken {
            self.draw_gem(ctx);
        }
        self.draw_walker(ctx, drawn_at);
        self.draw_door_prompt(ctx, camera);
    }

    /// Instructions and the door's interact hint — gathered before `ctx.ui`,
    /// which cannot read `ctx`.
    fn overlay(&mut self, ctx: &mut FrameContext<'_, Keep>) {
        let near_door = self.area == Area::Cave
            && !self.door_opening
            && self.position.distance(INTERACT_POINT) < INTERACT_RADIUS;
        let gem_taken = self.area == Area::Cave && self.gem_taken;
        let mut reset_clicked = false;

        ctx.ui(|ui| {
            egui::Frame::new()
                .fill(egui::Color32::from_black_alpha(HUD_BACKDROP))
                .inner_margin(HUD_PADDING)
                .corner_radius(f32::from(HUD_PADDING))
                .show(ui, |ui| {
                    ui.visuals_mut().override_text_color = Some(egui::Color32::WHITE);
                    ui.label("wasd / arrows / stick to walk");
                    if near_door {
                        ui.label("e / west button to open the door");
                    }
                    if gem_taken {
                        ui.label("gem recovered");
                    }
                    ui.label("kept between runs: position, gem, cave");
                    ui.label("r to reset world");
                    if ui.button("reset world").clicked() {
                        reset_clicked = true;
                    }
                });
        });

        if reset_clicked {
            self.reset_requested = true;
        }
    }
}

impl Game for Keep {
    type Meshes = Shape;
    type Sounds = Sound;
    type InputActions = Controls;
    type Skyboxes = NoSkyboxes;
    type SurfaceStyles = Looks;
    type PostEffects = NoPostEffects;

    fn tick(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.previous = self.position;

        if self.reset_requested || ctx.pressed(Button::Reset) {
            self.reset_requested = false;
            self.reset(ctx);
            return;
        }

        let heading = if ctx.ui_wants_keyboard() {
            Vec2::ZERO
        } else {
            ctx.axis2(Move::Walk)
        };
        match Facing::from_heading(heading) {
            Some(facing) => {
                self.facing = facing;
                self.walk_ticks += 1;
            }
            None => self.walk_ticks = 0,
        }
        let stride = Vec3::new(heading.x, 0.0, -heading.y) * WALK_SPEED * ctx.dt().as_secs_f32();
        self.position += stride;
        self.simulated += ctx.dt();

        match self.area {
            Area::Overworld => self.tick_overworld(ctx),
            Area::Cave => self.tick_cave(ctx),
        }
    }

pub fn released<A: InputButtonAction>(&self, action: A) -> bool

where G::InputActions: Seats<A, A::Binding>,

Whether action came up since the last frame whose ticks ran.

A release is held for the ticks that follow, the same as a press.

Examples found in repository

examples/sound-lab.rs (line 478)

    fn handle_drag(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        // Read before the check below for the UI's own claim on the
        // pointer, so a release over it still frees a source a drag moved
        // there.
        if ctx.released(Button::Select) {
            self.dragging = None;
        }
        if ctx.ui_wants_pointer() {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if ctx.pressed(Button::Select) {
            self.dragging = self.sources.iter().position(|source| {
                ray.hit_sphere(source.position, SOURCE_PICK_RADIUS)
                    .is_some()
            });
        }

        let Some(index) = self.dragging else {
            return;
        };
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let hit = ray.at(distance);
        let dropped =
            Vec2::new(hit.x, hit.z).clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
        self.sources[index].position = Vec3::new(dropped.x, SOURCE_HEIGHT, dropped.y);
    }

pub fn clicks<A: InputButtonAction>(&self, action: A) -> u32

where G::InputActions: Seats<A, A::Binding>,

Presses of action in a row, counting the one these ticks read: 1 for a single click, 2 for a double, 0 where they read no press; see FrameContext::clicks.

The ticks of one frame read one press however many landed in them, so a control pressed twice inside one frame reads one press of two clicks.

pub fn axis<A: InputAxisAction>(&self, action: A) -> f32

where G::InputActions: Seats<A, A::Binding>,

Analog reading of action: a fraction in -1..=1 from a pad axis, a joystick axis or a button composite, of which a trigger reads 0..=1, and the scaled distance, which nothing clamps, from a PointerDelta or WheelDelta lane.

Read those two in Game::frame: the ticks of one frame each read the whole distance that frame moved.

Examples found in repository

examples/breakout-game.rs (line 985)

    fn tick(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        if self.paused {
            return;
        }

        let dt = ctx.dt().as_secs_f32();
        self.paddle_flash = (self.paddle_flash - dt).max(0.0);
        self.brick_flash = (self.brick_flash - dt).max(0.0);
        self.life_lost_flash = (self.life_lost_flash - dt).max(0.0);
        self.step_sparks(dt);

        // Decay runs before the end-screen return below, so the last pulse and
        // burst do not stay on screen.
        if matches!(self.phase, Phase::Won | Phase::Lost) {
            return;
        }

        let axis = if ctx.ui_wants_keyboard() {
            0.0
        } else {
            ctx.axis(Move::Paddle)
        };
        self.step_paddle(axis, dt);

        match self.phase {
            Phase::Serving => self.hold_ball(ctx),
            _ => self.step_ball(ctx, dt),
        }
    }

pub fn axis2<A: InputAxis2Action>(&self, action: A) -> Vec2

where G::InputActions: Seats<A, A::Binding>,

action’s reading: a vector no longer than 1 from a stick or a button composite, and the scaled distance, which nothing clamps, from Axis2Binding::pointer.

Read the pointer in Game::frame: the ticks of one frame each read the whole distance that frame moved.

Examples found in repository

examples/sound-lab.rs (line 466)

    fn handle_walk(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        self.player_prev = self.player;
        if ctx.ui_wants_keyboard() {
            return;
        }
        let walk = ctx.axis2(Move::Walk);
        let world = Vec2::new(walk.x, -walk.y);
        self.player = (self.player + world * WALK_SPEED * ctx.dt().as_secs_f32())
            .clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
    }

examples/animation.rs (line 693)

    fn advance(&mut self, ctx: &mut TickContext<'_, Scene>) -> f32 {
        let control = ctx.axis2(Move::Walk).clamp_length_max(1.0);
        let turn = Quat::from_rotation_y(self.camera_yaw);
        let heading = turn * Vec3::X * control.x + turn * Vec3::NEG_Z * control.y;
        let dt = ctx.dt().as_secs_f32();
        if let Some(direction) = heading.try_normalize() {
            let wanted = direction.x.atan2(direction.z);
            let turn = (wanted - self.elf_yaw + core::f32::consts::PI).rem_euclid(TAU)
                - core::f32::consts::PI;
            self.elf_yaw += turn.clamp(-TURN_RATE * dt, TURN_RATE * dt);
        }
        let cap = if ctx.down(Button::Run) { 1.0 } else { WALK_CAP };
        self.elf_pos += heading * cap * ELF_SPEED * dt;
        heading.length() * cap
    }

examples/sprite-adventure.rs (line 1813)

    fn tick(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.previous = self.position;

        if self.reset_requested || ctx.pressed(Button::Reset) {
            self.reset_requested = false;
            self.reset(ctx);
            return;
        }

        let heading = if ctx.ui_wants_keyboard() {
            Vec2::ZERO
        } else {
            ctx.axis2(Move::Walk)
        };
        match Facing::from_heading(heading) {
            Some(facing) => {
                self.facing = facing;
                self.walk_ticks += 1;
            }
            None => self.walk_ticks = 0,
        }
        let stride = Vec3::new(heading.x, 0.0, -heading.y) * WALK_SPEED * ctx.dt().as_secs_f32();
        self.position += stride;
        self.simulated += ctx.dt();

        match self.area {
            Area::Overworld => self.tick_overworld(ctx),
            Area::Cave => self.tick_cave(ctx),
        }
    }

pub fn pointer(&self) -> Vec2

Pointer position, in physical pixels from the drawing area’s top left; the origin until it is first seen.

The mouse and the first touch share it, and window_size is in the same pixels, so Camera::ray_through takes it as it is.

Examples found in repository

examples/ui-fonts.rs (line 637)

    fn handle_hail(&mut self, ctx: &mut TickContext<'_, Self>) {
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let Some(station) = hit_station(ray) else {
            return;
        };

        if self.hailed != Some(station) {
            self.hailed = Some(station);
            let look = station.look();
            self.dialogue = Some(Dialogue::start(look.name, look.lines.map(str::to_owned)));
            return;
        }
        let Some(dialogue) = &mut self.dialogue else {
            return;
        };
        if !dialogue.advance() {
            self.dialogue = None;
            self.hailed = None;
        }
    }

examples/sound-lab.rs (line 486)

    fn handle_drag(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        // Read before the check below for the UI's own claim on the
        // pointer, so a release over it still frees a source a drag moved
        // there.
        if ctx.released(Button::Select) {
            self.dragging = None;
        }
        if ctx.ui_wants_pointer() {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if ctx.pressed(Button::Select) {
            self.dragging = self.sources.iter().position(|source| {
                ray.hit_sphere(source.position, SOURCE_PICK_RADIUS)
                    .is_some()
            });
        }

        let Some(index) = self.dragging else {
            return;
        };
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let hit = ray.at(distance);
        let dropped =
            Vec2::new(hit.x, hit.z).clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
        self.sources[index].position = Vec3::new(dropped.x, SOURCE_HEIGHT, dropped.y);
    }

examples/isometric-board.rs (line 420)

    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

pub fn play(&mut self, sound: impl Into<SoundCue<G::Sounds>>)

Plays sound once, keeping wherever it is placed as of this tick.

Every call is a voice of its own, so the same sound twice over is heard twice; the ticks of one frame are played together at the end of it.

Examples found in repository

examples/breakout-game.rs (line 406)

    fn hold_ball(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        self.ball_prev = self.ball_pos;
        self.ball_pos.x = self.paddle_x;
        self.ball_trail = [self.ball_pos; TRAIL_LEN + 1];

        if !ctx.ui_wants_keyboard() && ctx.pressed(Button::Serve) {
            self.launch();
            ctx.play(Sound::Serve);
        }
    }

    fn step_paddle(&mut self, axis: f32, dt: f32) {
        self.paddle_prev_x = self.paddle_x;
        self.paddle_x =
            (self.paddle_x + axis * PADDLE_SPEED * dt).clamp(-PADDLE_LIMIT, PADDLE_LIMIT);
    }

    fn step_ball(&mut self, ctx: &mut TickContext<'_, Breakout>, dt: f32) {
        self.ball_prev = self.ball_pos;
        self.ball_pos += self.ball_vel * dt;

        self.bounce_walls(ctx);
        self.bounce_paddle(ctx);
        self.bounce_bricks(ctx);
        self.push_trail();

        if self.ball_pos.z - BALL_RADIUS > COURT_HALF_DEPTH {
            self.lose_life(ctx);
        }
    }

    /// Shifts the ghost trail back one slot and records the ball's newly
    /// resolved position at the front.
    fn push_trail(&mut self) {
        self.ball_trail.rotate_right(1);
        self.ball_trail[0] = self.ball_pos;
    }

    fn bounce_walls(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        let left = -COURT_HALF_WIDTH + WALL_THICKNESS;
        let right = COURT_HALF_WIDTH - WALL_THICKNESS;
        let top = -COURT_HALF_DEPTH + WALL_THICKNESS;

        let mut hit = false;
        if self.ball_pos.x - BALL_RADIUS < left {
            self.ball_pos.x = left + BALL_RADIUS;
            self.ball_vel.x = self.ball_vel.x.abs();
            hit = true;
        } else if self.ball_pos.x + BALL_RADIUS > right {
            self.ball_pos.x = right - BALL_RADIUS;
            self.ball_vel.x = -self.ball_vel.x.abs();
            hit = true;
        }

        if self.ball_pos.z - BALL_RADIUS < top {
            self.ball_pos.z = top + BALL_RADIUS;
            self.ball_vel.z = self.ball_vel.z.abs();
            hit = true;
        }

        if hit {
            ctx.play(Sound::Bounce.pitch(WALL_BOUNCE_PITCH));
        }
    }

    /// Bounces the ball off the paddle, steering it by where it landed.
    fn bounce_paddle(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        if self.ball_vel.z <= 0.0 {
            return;
        }
        let reach_x = PADDLE_HALF_WIDTH + BALL_RADIUS;
        let reach_z = PADDLE_HALF_DEPTH + BALL_RADIUS;
        let dx = self.ball_pos.x - self.paddle_x;
        let dz = self.ball_pos.z - PADDLE_Z;
        if dx.abs() > reach_x || dz.abs() > reach_z {
            return;
        }

        let offset = (dx / PADDLE_HALF_WIDTH).clamp(-1.0, 1.0);
        self.ball_vel = Vec3::new(offset, 0.0, -1.0).normalize() * BALL_SPEED;
        self.ball_pos.z = PADDLE_Z - reach_z;
        self.paddle_flash = PADDLE_FLASH;
        ctx.play(Sound::Bounce.pitch(PADDLE_BOUNCE_PITCH));
    }

    /// Bounces the ball off the nearest overlapping brick, damaging it.
    fn bounce_bricks(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        let reach_x = BRICK_HALF_WIDTH + BALL_RADIUS;
        let reach_z = BRICK_HALF_DEPTH + BALL_RADIUS;
        let mut broken = None;

        for brick in self
            .bricks
            .iter_mut()
            .filter(|brick| brick.hits_remaining > 0)
        {
            let dx = self.ball_pos.x - brick.position.x;
            let dz = self.ball_pos.z - brick.position.z;
            if dx.abs() > reach_x || dz.abs() > reach_z {
                continue;
            }

            if reach_x - dx.abs() < reach_z - dz.abs() {
                self.ball_vel.x = if dx < 0.0 {
                    -self.ball_vel.x.abs()
                } else {
                    self.ball_vel.x.abs()
                };
            } else {
                self.ball_vel.z = if dz < 0.0 {
                    -self.ball_vel.z.abs()
                } else {
                    self.ball_vel.z.abs()
                };
            }

            brick.hits_remaining -= 1;
            self.score += 10 * (BRICK_ROWS - brick.row) as u32;
            ctx.play(Sound::Bounce.pitch(BRICK_BOUNCE_PITCH));
            if brick.hits_remaining == 0 {
                ctx.play(
                    Sound::BrickBreak
                        .at(brick.position)
                        .reference(BRICK_BREAK_REFERENCE),
                );
                self.brick_flash = BRICK_FLASH;
                broken = Some((brick.position, BRICK_ROW_COLORS[brick.row]));
            }
            break;
        }

        if let Some((position, color)) = broken {
            self.spawn_sparks(position, color);
        }

        if self.bricks.iter().all(|brick| brick.hits_remaining == 0) {
            self.phase = Phase::Won;
            ctx.play(Sound::LevelClear);
        }
    }

    /// Sends [`SPARK_BURST_COUNT`] sparks outward and upward from a broken
    /// brick's position, spread by index so no randomness is needed.
    fn spawn_sparks(&mut self, position: Vec3, color: Color) {
        for i in 0..SPARK_BURST_COUNT {
            let t = i as f32 / SPARK_BURST_COUNT as f32;
            let azimuth = t * TAU;
            let rise = 0.6 + 0.4 * (t * 3.0).fract();
            let speed = SPARK_SPEED_MIN.lerp(SPARK_SPEED_MAX, (t * 5.0).fract());
            let direction = Vec3::new(azimuth.cos(), rise, azimuth.sin()).normalize();
            self.sparks.push(Spark {
                position,
                velocity: direction * speed,
                roll: azimuth,
                age: 0.0,
                color,
            });
        }
    }

    /// Integrates and ages the live sparks, dropping any past their
    /// lifetime.
    fn step_sparks(&mut self, dt: f32) {
        for spark in &mut self.sparks {
            spark.velocity.y -= SPARK_GRAVITY * dt;
            spark.position += spark.velocity * dt;
            spark.age += dt;
        }
        self.sparks.retain(|spark| spark.age < SPARK_LIFETIME);
    }

    fn lose_life(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        self.life_lost_flash = LIFE_LOST_FLASH;
        self.lives = self.lives.saturating_sub(1);
        if self.lives == 0 {
            self.phase = Phase::Lost;
            ctx.play(Sound::GameOver);
        } else {
            ctx.play(Sound::BallLost);
            self.ready_serve();
        }
    }

examples/isometric-board.rs (line 455)

    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

examples/sprite-adventure.rs (line 1174)

    fn tick_cave(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.push_out_of(Self::cave_obstacles(self.door_obstacle()));
        self.position.x = self.position.x.clamp(-CAVE_HALF_WIDTH, CAVE_HALF_WIDTH);
        self.position.z = self.position.z.clamp(CAVE_WALK_FAR_Z, CAVE_WALK_NEAR_Z);

        let target = if self.position.z < DOOR_WALL_NEAR_Z {
            1.0
        } else {
            0.0
        };
        let step = 1.0 / GHOST_RAMP_TICKS as f32;
        self.ghost += (target - self.ghost).clamp(-step, step);

        if !self.door_opening
            && ctx.pressed(Button::Interact)
            && self.position.distance(INTERACT_POINT) < INTERACT_RADIUS
        {
            self.door_opening = true;
            self.swing_ticks = 0;
            ctx.play(Sound::Interact);
        }
        if self.door_opening && self.swing_ticks < DOOR_SWING_TICKS {
            self.swing_ticks += 1;
        }

        if !self.gem_taken && self.position.distance(GEM_POSITION) < PICKUP_RADIUS {
            self.gem_taken = true;
            ctx.play(Sound::Gem);
            ctx.save(Flag::GemTaken, true);
            ctx.save(Position::X, self.position.x as f64);
            ctx.save(Position::Z, self.position.z as f64);
        }

        if EXIT.holds(self.position) {
            if EXIT.holds(self.previous) {
                self.position.z = self.previous.z;
            } else {
                self.exit_cave(ctx);
            }
        }
    }

pub fn saved<K: SaveKey>(&self, key: K) -> K::Value

The value the last run to save key kept, or its fallback where none did, or where what was kept no longer reads as the key’s own value, with a debug log.

pub fn save<K: SaveKey>(&mut self, key: K, value: K::Value)

Keeps value under key, for the rest of this run and the runs after it.

The store is written once the frame these ticks belong to is drawn, and only where a value changed, so saving every tick costs nothing.

Examples found in repository

examples/sprite-adventure.rs (line 1183)

    fn tick_cave(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.push_out_of(Self::cave_obstacles(self.door_obstacle()));
        self.position.x = self.position.x.clamp(-CAVE_HALF_WIDTH, CAVE_HALF_WIDTH);
        self.position.z = self.position.z.clamp(CAVE_WALK_FAR_Z, CAVE_WALK_NEAR_Z);

        let target = if self.position.z < DOOR_WALL_NEAR_Z {
            1.0
        } else {
            0.0
        };
        let step = 1.0 / GHOST_RAMP_TICKS as f32;
        self.ghost += (target - self.ghost).clamp(-step, step);

        if !self.door_opening
            && ctx.pressed(Button::Interact)
            && self.position.distance(INTERACT_POINT) < INTERACT_RADIUS
        {
            self.door_opening = true;
            self.swing_ticks = 0;
            ctx.play(Sound::Interact);
        }
        if self.door_opening && self.swing_ticks < DOOR_SWING_TICKS {
            self.swing_ticks += 1;
        }

        if !self.gem_taken && self.position.distance(GEM_POSITION) < PICKUP_RADIUS {
            self.gem_taken = true;
            ctx.play(Sound::Gem);
            ctx.save(Flag::GemTaken, true);
            ctx.save(Position::X, self.position.x as f64);
            ctx.save(Position::Z, self.position.z as f64);
        }

        if EXIT.holds(self.position) {
            if EXIT.holds(self.previous) {
                self.position.z = self.previous.z;
            } else {
                self.exit_cave(ctx);
            }
        }
    }

    /// Puts the player back at [`PLAYER_SPAWN`] with the cave and the gem
    /// returned to their saved fallbacks, all in this tick: a reset saves
    /// every key's own fallback, since there is nothing to clear it to.
    fn reset(&mut self, ctx: &mut TickContext<'_, Keep>) {
        ctx.save(Position::X, Position::X.fallback());
        ctx.save(Position::Z, Position::Z.fallback());
        ctx.save(Flag::InCave, Flag::InCave.fallback());
        ctx.save(Flag::GemTaken, Flag::GemTaken.fallback());

        self.area = Area::Overworld;
        self.position = PLAYER_SPAWN;
        self.previous = PLAYER_SPAWN;
        self.gem_taken = false;
        self.door_opening = false;
        self.swing_ticks = 0;
        self.ghost = 0.0;
    }

    /// Steps into the cave at [`CAVE_SPAWN`], saving the transition.
    fn enter_cave(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.area = Area::Cave;
        self.position = CAVE_SPAWN;
        self.previous = CAVE_SPAWN;
        ctx.save(Flag::InCave, true);
        ctx.save(Position::X, CAVE_SPAWN.x as f64);
        ctx.save(Position::Z, CAVE_SPAWN.z as f64);
    }

    /// Steps back out to the mouth at [`RETURN_SPAWN`], saving the
    /// transition.
    fn exit_cave(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.area = Area::Overworld;
        self.position = RETURN_SPAWN;
        self.previous = RETURN_SPAWN;
        ctx.save(Flag::InCave, false);
        ctx.save(Position::X, RETURN_SPAWN.x as f64);
        ctx.save(Position::Z, RETURN_SPAWN.z as f64);
    }

pub fn sound_unlocked(&self) -> bool

Whether the platform allows sound to start right now; see FrameContext::sound_unlocked.

pub fn animate<M, P, S>( &mut self, mesh: M, animator: &mut Animator<M, S>, input: &S::Input, )

where G::Meshes: Holds<M>, M: Mesh<P, S::Clip>, P: Part, S: AnimationStates,

Runs animator up to this tick against input, over the clips mesh holds: where its state goes from here, and what the state it lands in plays.

Takes a mesh of Game::Meshes and a machine typed by that mesh, so a machine runs on the clips of the value the game draws and no other. Every tick of one drawn frame runs at one instant, as every one of them reads one snapshot of the controls, and the frame draws at that same instant.

Examples found in repository

examples/flock-parallelism.rs (line 737)

    fn tick(&mut self, ctx: &mut TickContext<'_, Self>) {
        let dt = ctx.dt().as_secs_f32();
        let start = Instant::now();
        self.butterflies
            .step(dt, self.world, self.settings.sequential);
        self.last_tick_ms = start.elapsed().as_secs_f32() * 1000.0;

        self.flown += dt;
        for (group, flap) in self.flaps.iter_mut().enumerate() {
            ctx.animate(Butterfly, flap, &flap_phase(group, self.flown));
        }
    }

examples/animation.rs (line 898)

    fn tick(&mut self, ctx: &mut TickContext<'_, Scene>) {
        self.elf_prev = self.elf_pos;
        self.elf_height_prev = self.elf_height;

        if ctx.pressed(Button::Restart) {
            self.restart_elf();
        }
        if ctx.pressed(Button::Hold) {
            self.holding = true;
        }
        if ctx.pressed(Button::Release) {
            self.holding = false;
        }

        self.elf_input.landed = self.fall(ctx.dt().as_secs_f32());
        self.tick_elf(ctx);
        ctx.animate(Elf, &mut self.elf_animator, &self.elf_input);

        if self.elf_animator.entered(ElfState::Jump) {
            self.jump_speed = JUMP_LAUNCH_SPEED;
        }
        if self.elf_animator.left(ElfState::StandUp) {
            self.last_event = "elf stood up";
        }
        if self.elf_animator.entered(ElfState::Sit) {
            self.last_event = "elf sat down";
        }
        if self.elf_animator.entered(ElfState::Death) {
            self.last_event = "elf died";
        }

        let scrubbed_input = ScrubbedInput {
            settled: settled_at(self.elf_pos.distance(SCRUBBED_ELF_POSITION)),
        };
        ctx.animate(Elf, &mut self.scrubbed_animator, &scrubbed_input);
        ctx.animate(Butterfly, &mut self.butterfly_animator, &());
    }

pub fn dt(&self) -> Duration

This tick’s fixed time step: Config::tick_interval until set_tick_interval changes it.

Examples found in repository

examples/sound-lab.rs (line 468)

    fn handle_walk(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        self.player_prev = self.player;
        if ctx.ui_wants_keyboard() {
            return;
        }
        let walk = ctx.axis2(Move::Walk);
        let world = Vec2::new(walk.x, -walk.y);
        self.player = (self.player + world * WALK_SPEED * ctx.dt().as_secs_f32())
            .clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
    }

examples/isometric-board.rs (line 810)

    fn tick(&mut self, ctx: &mut TickContext<'_, Board>) {
        self.sprite.previous = self.sprite.position;
        self.block.previous = self.block.position;

        self.handle_click(ctx);

        if self.current_mut().advance(ctx.dt()) {
            if let Some(tile) = tile_at(self.current().position) {
                self.current_mut().tile = tile;
            }
            self.turn = self.turn.other();
            self.selected = false;
        }
    }

examples/flock-parallelism.rs (line 729)

    fn tick(&mut self, ctx: &mut TickContext<'_, Self>) {
        let dt = ctx.dt().as_secs_f32();
        let start = Instant::now();
        self.butterflies
            .step(dt, self.world, self.settings.sequential);
        self.last_tick_ms = start.elapsed().as_secs_f32() * 1000.0;

        self.flown += dt;
        for (group, flap) in self.flaps.iter_mut().enumerate() {
            ctx.animate(Butterfly, flap, &flap_phase(group, self.flown));
        }
    }

examples/ui-fonts.rs (line 798)

    fn tick(&mut self, ctx: &mut TickContext<'_, Self>) {
        self.elapsed += ctx.dt();
        self.orbit.yaw += AUTO_TURN_RATE * ctx.dt().as_secs_f32();

        if let Some(dialogue) = &mut self.dialogue {
            dialogue.tick();
        }
        if ctx.pressed(Trigger::Close) {
            self.dialogue = None;
            self.hailed = None;
        }
        if ctx.pressed(Trigger::Sheet) {
            self.sheet_open = !self.sheet_open;
        }
        if ctx.pressed(Trigger::Hail) && !ctx.ui_wants_pointer() {
            self.handle_hail(ctx);
        }
    }

examples/animation.rs (line 696)

    fn advance(&mut self, ctx: &mut TickContext<'_, Scene>) -> f32 {
        let control = ctx.axis2(Move::Walk).clamp_length_max(1.0);
        let turn = Quat::from_rotation_y(self.camera_yaw);
        let heading = turn * Vec3::X * control.x + turn * Vec3::NEG_Z * control.y;
        let dt = ctx.dt().as_secs_f32();
        if let Some(direction) = heading.try_normalize() {
            let wanted = direction.x.atan2(direction.z);
            let turn = (wanted - self.elf_yaw + core::f32::consts::PI).rem_euclid(TAU)
                - core::f32::consts::PI;
            self.elf_yaw += turn.clamp(-TURN_RATE * dt, TURN_RATE * dt);
        }
        let cap = if ctx.down(Button::Run) { 1.0 } else { WALK_CAP };
        self.elf_pos += heading * cap * ELF_SPEED * dt;
        heading.length() * cap
    }

    /// Integrates [`Self::elf_height`] under [`GRAVITY`] from
    /// [`Self::jump_speed`], held at the ground; `true` the tick it
    /// returns there from above it.
    fn fall(&mut self, dt: f32) -> bool {
        let off_ground = self.elf_height > 0.0;
        self.jump_speed -= GRAVITY * dt;
        self.elf_height = (self.elf_height + self.jump_speed * dt).max(0.0);
        if self.elf_height == 0.0 {
            self.jump_speed = 0.0;
        }
        off_ground && self.elf_height == 0.0
    }

    /// The hurt patch `elf_pos` stands inside, if any.
    fn patch_underfoot(&self) -> Option<Vec3> {
        HURT_PATCHES
            .into_iter()
            .find(|&patch| self.elf_pos.distance(patch) < HURT_RADIUS)
    }

    /// Reads the controls and moves the elf, filling [`Self::elf_input`]
    /// for [`ElfState`] to read.
    fn tick_elf(&mut self, ctx: &mut TickContext<'_, Scene>) {
        let grounded = matches!(
            self.elf_animator.state(),
            ElfState::Idle | ElfState::Locomotion
        );

        self.elf_input.speed = self.advance(ctx);
        self.elf_input.attack = ctx.pressed(Button::Attack);
        self.elf_input.jump = ctx.pressed(Button::Jump);
        self.elf_input.dance = ctx.pressed(Button::Dance);

        self.elf_input.near_seat = self.elf_pos.distance(SEAT_POSITION) < SEAT_INTERACT_RADIUS;
        self.elf_input.interact = ctx.pressed(Button::Interact);
        if self.elf_input.interact && grounded && self.elf_input.near_seat {
            self.elf_pos = SEAT_SPOT;
            self.elf_yaw = SEAT_FACING;
        }

        let underfoot = self.patch_underfoot();
        let entered_patch = underfoot.is_some() && !self.in_patch;
        self.in_patch = underfoot.is_some();
        self.hits += u32::from(entered_patch);
        self.elf_input.hit = entered_patch && self.hits < FATAL_HITS;
        self.elf_input.dying = entered_patch && self.hits >= FATAL_HITS;
        if entered_patch {
            self.last_event = match self.elf_input.dying {
                true => "elf died",
                false => "elf hit",
            };
        }
    }

    /// Starts a new [`Animator`] over the elf's own state, its position and
    /// hit count reset with it.
    fn restart_elf(&mut self) {
        self.elf_animator = Animator::new();
        self.elf_pos = ELF_START;
        self.elf_prev = ELF_START;
        self.elf_yaw = 0.0;
        self.elf_height = 0.0;
        self.elf_height_prev = 0.0;
        self.jump_speed = 0.0;
        self.elf_input = ElfInput::default();
        self.hits = 0;
        self.in_patch = false;
        self.last_event = "new elf started";
    }

    fn panel(&self, ctx: &mut FrameContext<'_, Scene>) {
        let state = match self.elf_animator.state() {
            ElfState::Idle => "idle",
            ElfState::Locomotion if self.elf_input.speed > WALK_CAP => "running",
            ElfState::Locomotion => "walking",
            ElfState::Attack => "attacking",
            ElfState::Hit => "hit",
            ElfState::Death => "dead",
            ElfState::SitDown => "sitting down",
            ElfState::Sit => "sitting",
            ElfState::StandUp => "standing up",
            ElfState::Jump => "jumping",
            ElfState::Dance => "dancing",
        };
        ctx.ui(|ui| {
            egui::Frame::new()
                .fill(egui::Color32::from_black_alpha(PANEL_BACKDROP))
                .inner_margin(PANEL_PADDING)
                .corner_radius(f32::from(PANEL_PADDING))
                .show(ui, |ui| {
                    ui.heading(panel_text(format!("elf is {state}")));
                    ui.label(panel_text(format!(
                        "hits taken {} of the {} red patches hurt for, {}",
                        self.hits, FATAL_HITS, self.last_event
                    )));
                    ui.label(panel_text(match self.elf_animator.transitioning() {
                        true => "fading between clips",
                        false => "one clip playing",
                    }));
                    ui.add_space(f32::from(PANEL_PADDING));
                    egui::Grid::new("controls").show(ui, |ui| {
                        for (key, does) in CONTROLS {
                            ui.label(panel_text(key));
                            ui.label(panel_text(does));
                            ui.end_row();
                        }
                    });
                });
        });
    }

    /// A prompt over the seat, each hurt patch, and the scrubbed elf,
    /// naming what a player finds there; the seat's own prompt names the
    /// live binding of `Button::Interact` by its own name, not one fixed
    /// in the code, and is absent while the elf sits on it.
    fn draw_prompts(&self, ctx: &mut FrameContext<'_, Scene>, camera: Camera) {
        let sit_key = ctx
            .bindings(Button::Interact)
            .into_iter()
            .next()
            .map_or_else(|| "interact".to_owned(), |binding| binding.to_string());
        let sit = ctx.text_layout(
            &format!("{sit_key} sits"),
            egui::FontId::proportional(PROMPT_SIZE),
        );
        let hurts = ctx.text_layout("hurts", egui::FontId::proportional(PROMPT_SIZE));
        let walk_closer = ctx.text_layout("walk closer", egui::FontId::proportional(PROMPT_SIZE));

        let mut prompts = vec![(
            SCRUBBED_ELF_POSITION + Vec3::Y * (ELF_HEIGHT + PROMPT_LIFT),
            walk_closer,
        )];
        if !self.elf_animator.state().seated() {
            prompts.push((
                SEAT_POSITION + Vec3::Y * (SEAT_HEAD_HEIGHT + PROMPT_LIFT),
                sit,
            ));
        }
        prompts.extend(HURT_PATCHES.map(|patch| (patch + Vec3::Y * PROMPT_LIFT, hurts.clone())));

        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();
        ctx.ui(|ui| {
            let painter = ui.painter();
            for (point, galley) in prompts {
                let Some(pixel) = camera.pixel_of(point, window_size) else {
                    continue;
                };
                let at = logical(pixel, pixels_per_point);
                let ink = galley.mesh_bounds;
                let pos = egui::pos2(at.x - ink.center().x, at.y - ink.center().y);
                let backdrop = egui::Rect::from_center_size(
                    at,
                    ink.size() + egui::Vec2::splat(PROMPT_PADDING * 2.0),
                );
                painter.rect_filled(
                    backdrop,
                    PROMPT_PADDING,
                    egui::Color32::from_black_alpha(PANEL_BACKDROP),
                );
                painter.galley(pos, galley, PANEL_TEXT_COLOR);
            }
        });
    }
}

impl Game for Scene {
    type Meshes = Shape;
    type Sounds = NoSounds;
    type InputActions = Controls;
    type Skyboxes = Sky;
    type SurfaceStyles = NoSurfaceStyles;
    type PostEffects = NoPostEffects;

    fn tick(&mut self, ctx: &mut TickContext<'_, Scene>) {
        self.elf_prev = self.elf_pos;
        self.elf_height_prev = self.elf_height;

        if ctx.pressed(Button::Restart) {
            self.restart_elf();
        }
        if ctx.pressed(Button::Hold) {
            self.holding = true;
        }
        if ctx.pressed(Button::Release) {
            self.holding = false;
        }

        self.elf_input.landed = self.fall(ctx.dt().as_secs_f32());
        self.tick_elf(ctx);
        ctx.animate(Elf, &mut self.elf_animator, &self.elf_input);

        if self.elf_animator.entered(ElfState::Jump) {
            self.jump_speed = JUMP_LAUNCH_SPEED;
        }
        if self.elf_animator.left(ElfState::StandUp) {
            self.last_event = "elf stood up";
        }
        if self.elf_animator.entered(ElfState::Sit) {
            self.last_event = "elf sat down";
        }
        if self.elf_animator.entered(ElfState::Death) {
            self.last_event = "elf died";
        }

        let scrubbed_input = ScrubbedInput {
            settled: settled_at(self.elf_pos.distance(SCRUBBED_ELF_POSITION)),
        };
        ctx.animate(Elf, &mut self.scrubbed_animator, &scrubbed_input);
        ctx.animate(Butterfly, &mut self.butterfly_animator, &());
    }

examples/breakout-game.rs (line 970)

    fn tick(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        if self.paused {
            return;
        }

        let dt = ctx.dt().as_secs_f32();
        self.paddle_flash = (self.paddle_flash - dt).max(0.0);
        self.brick_flash = (self.brick_flash - dt).max(0.0);
        self.life_lost_flash = (self.life_lost_flash - dt).max(0.0);
        self.step_sparks(dt);

        // Decay runs before the end-screen return below, so the last pulse and
        // burst do not stay on screen.
        if matches!(self.phase, Phase::Won | Phase::Lost) {
            return;
        }

        let axis = if ctx.ui_wants_keyboard() {
            0.0
        } else {
            ctx.axis(Move::Paddle)
        };
        self.step_paddle(axis, dt);

        match self.phase {
            Phase::Serving => self.hold_ball(ctx),
            _ => self.step_ball(ctx, dt),
        }
    }

Additional examples can be found in:

• examples/sprite-adventure.rs

pub fn set_tick_interval(&mut self, interval: Duration)

Sets the simulated time every later tick covers; see FrameContext::set_tick_interval.

pub fn close(&mut self)

Ends the run once the frame these ticks belong to is drawn; see FrameContext::close.

pub fn ui_wants_pointer(&self) -> bool

Whether the UI took the pointer last frame. Always false without the ui feature.

Examples found in repository

examples/ui-fonts.rs (line 811)

    fn tick(&mut self, ctx: &mut TickContext<'_, Self>) {
        self.elapsed += ctx.dt();
        self.orbit.yaw += AUTO_TURN_RATE * ctx.dt().as_secs_f32();

        if let Some(dialogue) = &mut self.dialogue {
            dialogue.tick();
        }
        if ctx.pressed(Trigger::Close) {
            self.dialogue = None;
            self.hailed = None;
        }
        if ctx.pressed(Trigger::Sheet) {
            self.sheet_open = !self.sheet_open;
        }
        if ctx.pressed(Trigger::Hail) && !ctx.ui_wants_pointer() {
            self.handle_hail(ctx);
        }
    }

examples/sound-lab.rs (line 481)

    fn handle_drag(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        // Read before the check below for the UI's own claim on the
        // pointer, so a release over it still frees a source a drag moved
        // there.
        if ctx.released(Button::Select) {
            self.dragging = None;
        }
        if ctx.ui_wants_pointer() {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if ctx.pressed(Button::Select) {
            self.dragging = self.sources.iter().position(|source| {
                ray.hit_sphere(source.position, SOURCE_PICK_RADIUS)
                    .is_some()
            });
        }

        let Some(index) = self.dragging else {
            return;
        };
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let hit = ray.at(distance);
        let dropped =
            Vec2::new(hit.x, hit.z).clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
        self.sources[index].position = Vec3::new(dropped.x, SOURCE_HEIGHT, dropped.y);
    }

examples/isometric-board.rs (line 415)

    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

pub fn ui_wants_keyboard(&self) -> bool

Whether the UI took the keyboard last frame. Always false without the ui feature.

Examples found in repository

examples/breakout-game.rs (line 404)

    fn hold_ball(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        self.ball_prev = self.ball_pos;
        self.ball_pos.x = self.paddle_x;
        self.ball_trail = [self.ball_pos; TRAIL_LEN + 1];

        if !ctx.ui_wants_keyboard() && ctx.pressed(Button::Serve) {
            self.launch();
            ctx.play(Sound::Serve);
        }
    }

    fn step_paddle(&mut self, axis: f32, dt: f32) {
        self.paddle_prev_x = self.paddle_x;
        self.paddle_x =
            (self.paddle_x + axis * PADDLE_SPEED * dt).clamp(-PADDLE_LIMIT, PADDLE_LIMIT);
    }

    fn step_ball(&mut self, ctx: &mut TickContext<'_, Breakout>, dt: f32) {
        self.ball_prev = self.ball_pos;
        self.ball_pos += self.ball_vel * dt;

        self.bounce_walls(ctx);
        self.bounce_paddle(ctx);
        self.bounce_bricks(ctx);
        self.push_trail();

        if self.ball_pos.z - BALL_RADIUS > COURT_HALF_DEPTH {
            self.lose_life(ctx);
        }
    }

    /// Shifts the ghost trail back one slot and records the ball's newly
    /// resolved position at the front.
    fn push_trail(&mut self) {
        self.ball_trail.rotate_right(1);
        self.ball_trail[0] = self.ball_pos;
    }

    fn bounce_walls(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        let left = -COURT_HALF_WIDTH + WALL_THICKNESS;
        let right = COURT_HALF_WIDTH - WALL_THICKNESS;
        let top = -COURT_HALF_DEPTH + WALL_THICKNESS;

        let mut hit = false;
        if self.ball_pos.x - BALL_RADIUS < left {
            self.ball_pos.x = left + BALL_RADIUS;
            self.ball_vel.x = self.ball_vel.x.abs();
            hit = true;
        } else if self.ball_pos.x + BALL_RADIUS > right {
            self.ball_pos.x = right - BALL_RADIUS;
            self.ball_vel.x = -self.ball_vel.x.abs();
            hit = true;
        }

        if self.ball_pos.z - BALL_RADIUS < top {
            self.ball_pos.z = top + BALL_RADIUS;
            self.ball_vel.z = self.ball_vel.z.abs();
            hit = true;
        }

        if hit {
            ctx.play(Sound::Bounce.pitch(WALL_BOUNCE_PITCH));
        }
    }

    /// Bounces the ball off the paddle, steering it by where it landed.
    fn bounce_paddle(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        if self.ball_vel.z <= 0.0 {
            return;
        }
        let reach_x = PADDLE_HALF_WIDTH + BALL_RADIUS;
        let reach_z = PADDLE_HALF_DEPTH + BALL_RADIUS;
        let dx = self.ball_pos.x - self.paddle_x;
        let dz = self.ball_pos.z - PADDLE_Z;
        if dx.abs() > reach_x || dz.abs() > reach_z {
            return;
        }

        let offset = (dx / PADDLE_HALF_WIDTH).clamp(-1.0, 1.0);
        self.ball_vel = Vec3::new(offset, 0.0, -1.0).normalize() * BALL_SPEED;
        self.ball_pos.z = PADDLE_Z - reach_z;
        self.paddle_flash = PADDLE_FLASH;
        ctx.play(Sound::Bounce.pitch(PADDLE_BOUNCE_PITCH));
    }

    /// Bounces the ball off the nearest overlapping brick, damaging it.
    fn bounce_bricks(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        let reach_x = BRICK_HALF_WIDTH + BALL_RADIUS;
        let reach_z = BRICK_HALF_DEPTH + BALL_RADIUS;
        let mut broken = None;

        for brick in self
            .bricks
            .iter_mut()
            .filter(|brick| brick.hits_remaining > 0)
        {
            let dx = self.ball_pos.x - brick.position.x;
            let dz = self.ball_pos.z - brick.position.z;
            if dx.abs() > reach_x || dz.abs() > reach_z {
                continue;
            }

            if reach_x - dx.abs() < reach_z - dz.abs() {
                self.ball_vel.x = if dx < 0.0 {
                    -self.ball_vel.x.abs()
                } else {
                    self.ball_vel.x.abs()
                };
            } else {
                self.ball_vel.z = if dz < 0.0 {
                    -self.ball_vel.z.abs()
                } else {
                    self.ball_vel.z.abs()
                };
            }

            brick.hits_remaining -= 1;
            self.score += 10 * (BRICK_ROWS - brick.row) as u32;
            ctx.play(Sound::Bounce.pitch(BRICK_BOUNCE_PITCH));
            if brick.hits_remaining == 0 {
                ctx.play(
                    Sound::BrickBreak
                        .at(brick.position)
                        .reference(BRICK_BREAK_REFERENCE),
                );
                self.brick_flash = BRICK_FLASH;
                broken = Some((brick.position, BRICK_ROW_COLORS[brick.row]));
            }
            break;
        }

        if let Some((position, color)) = broken {
            self.spawn_sparks(position, color);
        }

        if self.bricks.iter().all(|brick| brick.hits_remaining == 0) {
            self.phase = Phase::Won;
            ctx.play(Sound::LevelClear);
        }
    }

    /// Sends [`SPARK_BURST_COUNT`] sparks outward and upward from a broken
    /// brick's position, spread by index so no randomness is needed.
    fn spawn_sparks(&mut self, position: Vec3, color: Color) {
        for i in 0..SPARK_BURST_COUNT {
            let t = i as f32 / SPARK_BURST_COUNT as f32;
            let azimuth = t * TAU;
            let rise = 0.6 + 0.4 * (t * 3.0).fract();
            let speed = SPARK_SPEED_MIN.lerp(SPARK_SPEED_MAX, (t * 5.0).fract());
            let direction = Vec3::new(azimuth.cos(), rise, azimuth.sin()).normalize();
            self.sparks.push(Spark {
                position,
                velocity: direction * speed,
                roll: azimuth,
                age: 0.0,
                color,
            });
        }
    }

    /// Integrates and ages the live sparks, dropping any past their
    /// lifetime.
    fn step_sparks(&mut self, dt: f32) {
        for spark in &mut self.sparks {
            spark.velocity.y -= SPARK_GRAVITY * dt;
            spark.position += spark.velocity * dt;
            spark.age += dt;
        }
        self.sparks.retain(|spark| spark.age < SPARK_LIFETIME);
    }

    fn lose_life(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        self.life_lost_flash = LIFE_LOST_FLASH;
        self.lives = self.lives.saturating_sub(1);
        if self.lives == 0 {
            self.phase = Phase::Lost;
            ctx.play(Sound::GameOver);
        } else {
            ctx.play(Sound::BallLost);
            self.ready_serve();
        }
    }

    fn camera() -> Camera {
        Camera::new(
            View::look_at(Vec3::new(0.0, 13.5, 12.5), Vec3::new(0.0, 0.0, 0.5)),
            Projection::perspective(50.0),
        )
    }

    /// The paddle's face material: fully lit by the court's own lights, its
    /// base tone flashed with emissive light past `1.0` just after it last
    /// hit the ball, and a small emissive kept under that so it stays
    /// visible where the ball's own light does not reach.
    fn paddle_face_material(&self) -> Material {
        let t = (self.paddle_flash / PADDLE_FLASH).clamp(0.0, 1.0);
        let flash = PADDLE_FLASH_EMISSIVE.dimmed(t);
        let emissive = Color::rgb(
            PADDLE_AMBIENT_EMISSIVE.red + flash.red,
            PADDLE_AMBIENT_EMISSIVE.green + flash.green,
            PADDLE_AMBIENT_EMISSIVE.blue + flash.blue,
        );
        Material::lit(PADDLE_BASE).emissive(emissive)
    }

    fn draw_court(&self, ctx: &mut FrameContext<'_, Breakout>) {
        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    COURT_HALF_WIDTH * 2.0,
                    1.0,
                    COURT_HALF_DEPTH * 2.0,
                )))
                .material(Material::lit(FLOOR_COLOR)),
        );

        let side_half = Vec3::new(WALL_THICKNESS * 0.5, WALL_HEIGHT * 0.5, COURT_HALF_DEPTH);
        for side in [-1.0, 1.0] {
            let x = side * (COURT_HALF_WIDTH - WALL_THICKNESS * 0.5);
            ctx.draw(
                Cube.at(Transform::from_scale_rotation_translation(
                    side_half * 2.0,
                    Quat::IDENTITY,
                    Vec3::new(x, side_half.y, 0.0),
                ))
                .material(Material::lit(WALL_COLOR)),
            );
        }

        let top_half = Vec3::new(COURT_HALF_WIDTH, WALL_HEIGHT * 0.5, WALL_THICKNESS * 0.5);
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                top_half * 2.0,
                Quat::IDENTITY,
                Vec3::new(0.0, top_half.y, -COURT_HALF_DEPTH + WALL_THICKNESS * 0.5),
            ))
            .material(Material::lit(WALL_COLOR)),
        );
    }

    fn draw_bricks(&self, ctx: &mut FrameContext<'_, Breakout>) {
        let scale = Vec3::new(
            BRICK_HALF_WIDTH * 2.0,
            BRICK_HALF_HEIGHT * 2.0,
            BRICK_HALF_DEPTH * 2.0,
        );
        for brick in self.bricks.iter().filter(|brick| brick.hits_remaining > 0) {
            let health = f32::from(brick.hits_remaining) / f32::from(BRICK_HITS);
            let color = BRICK_ROW_COLORS[brick.row].dimmed(0.4 + 0.6 * health);
            ctx.draw(
                Cube.at(Transform::from_scale_rotation_translation(
                    scale,
                    Quat::IDENTITY,
                    brick.position,
                ))
                .material(Material::shaded(color, health)),
            );
        }
    }

    /// Draws the live spark burst: additive, tumbling by roll as they age,
    /// shrinking and fading out over their lifetime.
    fn draw_sparks(&self, ctx: &mut FrameContext<'_, Breakout>) {
        for spark in &self.sparks {
            let age = (spark.age / SPARK_LIFETIME).clamp(0.0, 1.0);
            let fade = 1.0 - age;
            let size = SPARK_SIZE_START.lerp(SPARK_SIZE_END, age);
            ctx.draw(
                Quad.at(Transform::from_scale_rotation_translation(
                    Vec3::splat(size),
                    Quat::IDENTITY,
                    spark.position,
                ))
                .billboard()
                .roll(spark.roll + spark.age * SPARK_SPIN_SPEED)
                .material(
                    Material::color(spark.color.with_alpha(fade))
                        .emissive(spark.color.dimmed(SPARK_EMISSIVE_PEAK))
                        .additive(),
                ),
            );
        }
    }

    /// Draws the ball's ghost trail, each ghost smaller and more transparent
    /// than the one ahead of it; each ghost's position interpolates between
    /// its own last two resolved ticks by the same `alpha` the ball itself
    /// draws at, and its radius clamps to what the ball's own radius has
    /// left over its distance from the head, so a ghost still close to the
    /// ball never draws past its edge.
    fn draw_trail(&self, ctx: &mut FrameContext<'_, Breakout>, alpha: f32) {
        let head = self.ball_trail[1].lerp(self.ball_trail[0], alpha);
        for i in 0..TRAIL_LEN {
            let position = self.ball_trail[i + 1].lerp(self.ball_trail[i], alpha);
            let age = (i + 1) as f32 / TRAIL_LEN as f32;
            let fade = (1.0 - age).max(TRAIL_ALPHA_FLOOR);
            let radius = (BALL_RADIUS * TRAIL_SCALE_MIN.lerp(TRAIL_SCALE_MAX, fade))
                .min((BALL_RADIUS - head.distance(position)).max(0.0));
            let scale = Vec3::splat(radius * 2.0);
            ctx.draw(
                Sphere { subdivisions: 2 }
                    .at(Transform::from_scale_rotation_translation(
                        scale,
                        Quat::IDENTITY,
                        position,
                    ))
                    .material(
                        Material::color(BALL_GLOW.with_alpha(fade))
                            .emissive(BALL_EMISSIVE.dimmed(TRAIL_EMISSIVE_PEAK)),
                    ),
            );
        }
    }

    /// Draws one held ball for every life past the one in play, set in a
    /// row alongside the paddle's own path.
    fn draw_lives(&self, ctx: &mut FrameContext<'_, Breakout>) {
        let held_lives = self.lives.saturating_sub(1);
        for slot in 0..held_lives {
            let z = PADDLE_Z + (slot + 1) as f32 * LIFE_ROW_SPACING;
            ctx.draw(
                Sphere { subdivisions: 2 }
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::splat(BALL_RADIUS * 2.0),
                        Quat::IDENTITY,
                        Vec3::new(LIFE_ROW_X, BALL_RADIUS, z),
                    ))
                    .material(
                        Material::color(BALL_GLOW)
                            .emissive(BALL_EMISSIVE)
                            .additive(),
                    ),
            );
        }
    }

    fn overlay(&mut self, ctx: &mut FrameContext<'_, Breakout>) {
        let bricks_left = self
            .bricks
            .iter()
            .filter(|brick| brick.hits_remaining > 0)
            .count();
        // Read before `ctx.ui` so a rebind changes what the hint reads this
        // frame too.
        let move_hint = bindings_text(ctx.bindings(Move::Paddle));
        let pause_hint = bindings_text(ctx.bindings(Button::Pause));
        let serve_hint = bindings_text(ctx.bindings(Button::Serve));
        ctx.ui(|ui| {
            ui.horizontal(|ui| {
                ui.label(egui::RichText::new(format!("score {}", self.score)).size(32.0));
                ui.label(format!("{bricks_left} bricks left"));
            });
            ui.label(format!("move: {move_hint} · {pause_hint} to pause"));
            if self.phase == Phase::Serving {
                ui.label(format!("{serve_hint} to serve"));
            }
        });

        match self.phase {
            Phase::Serving | Phase::Playing if self.paused => self.menu(ctx, "paused", false),
            Phase::Won => self.menu(ctx, "you win", true),
            Phase::Lost => self.menu(ctx, "game over", true),
            _ => {}
        }
    }

    fn menu(&mut self, ctx: &mut FrameContext<'_, Breakout>, title: &str, over: bool) {
        let mut clicked = false;
        let mut quit = false;

        // `ctx.ui` cannot borrow `ctx`, so anything the controls list needs is
        // read first and applied after.
        let buttons: Vec<(Button, String)> = Button::all()
            .into_iter()
            .map(|action| (action, bindings_text(ctx.bindings(action))))
            .collect();
        let axes: Vec<(Move, String)> = Move::all()
            .into_iter()
            .map(|action| (action, bindings_text(ctx.bindings(action))))
            .collect();
        let listening = self.listening;
        let actuated_button = (!ctx.ui_wants_keyboard())
            .then(|| ctx.actuated_button())
            .flatten();
        let actuated_axis = (!ctx.ui_wants_keyboard())
            .then(|| ctx.actuated_axis())
            .flatten();
        let mut reset = None;

        ctx.ui(|ui| {
            egui::Window::new(title)
                .collapsible(false)
                .resizable(false)
                .anchor(egui::Align2::CENTER_CENTER, egui::Vec2::ZERO)
                .show(ui.ctx(), |ui| {
                    if over {
                        ui.label(format!("score {}", self.score));
                    }
                    if !over {
                        ui.add(
                            egui::Slider::new(&mut self.master_volume, 0.0..=1.0).text("volume"),
                        );
                        if ui.button("resume").clicked() {
                            self.paused = false;
                            clicked = true;
                        }
                        ui.separator();
                        ui.heading("controls");
                        for (action, text) in &buttons {
                            controls_row(
                                ui,
                                action.name(),
                                text,
                                listening == Some(Listening::Button(*action)),
                                &mut self.listening,
                                Listening::Button(*action),
                                &mut reset,
                            );
                        }
                        for (action, text) in &axes {
                            controls_row(
                                ui,
                                action.name(),
                                text,
                                listening == Some(Listening::Move(*action)),
                                &mut self.listening,
                                Listening::Move(*action),
                                &mut reset,
                            );
                        }
                    }
                    if ui.button("restart").clicked() {
                        self.restart();
                        clicked = true;
                    }
                    if ui.button("quit").clicked() {
                        quit = true;
                    }
                });
        });

        match (self.listening, actuated_button, actuated_axis) {
            (Some(Listening::Button(action)), Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Listening::Move(action)), _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
        match reset {
            Some(Listening::Button(action)) => ctx.rebind(action, action.bindings()),
            Some(Listening::Move(action)) => ctx.rebind(action, action.bindings()),
            None => {}
        }

        if clicked {
            ctx.play(Sound::Click);
        }
        if quit {
            ctx.close();
        }
    }

    /// Sustains both tracks every frame, and the gain goes to whichever the
    /// game calls for: gameplay music while a round is live, serving
    /// included, and menu music whenever a menu covers it.
    ///
    /// Each fades in over [`MUSIC_CROSSFADE`] and slides every later gain
    /// over it, which is the crossfade itself; the one at no gain costs no
    /// voice while its playback goes on under the other.
    fn sustain_music(&self, ctx: &mut FrameContext<'_, Breakout>) {
        let playing = !self.paused && matches!(self.phase, Phase::Serving | Phase::Playing);
        let gain = |wanted: bool| match wanted {
            true => MUSIC_GAIN,
            false => 0.0,
        };

        ctx.sustain(
            Sound::Music
                .gain(gain(playing))
                .fade(MUSIC_CROSSFADE)
                .glide(MUSIC_CROSSFADE)
                .loop_from(MUSIC_LOOP_FROM),
        );
        ctx.sustain(
            Sound::MenuMusic
                .gain(gain(!playing))
                .fade(MUSIC_CROSSFADE)
                .glide(MUSIC_CROSSFADE)
                .loop_from(MENU_MUSIC_LOOP_FROM),
        );
    }
}

/// One action's name, its live bindings, a rebind control that starts
/// listening for a new one, and a reset to its defaults; cancel is a
/// button rather than Escape, since Escape is itself a binding a listen
/// could capture.
fn controls_row(
    ui: &mut egui::Ui,
    name: &str,
    bindings: &str,
    listening: bool,
    target: &mut Option<Listening>,
    action: Listening,
    reset: &mut Option<Listening>,
) {
    ui.horizontal(|ui| {
        ui.label(format!("{name}: {bindings}"));
        if listening {
            ui.label("listening");
            if ui.button("cancel").clicked() {
                *target = None;
            }
        } else if ui.button("rebind").clicked() {
            *target = Some(action);
        }
        if ui.button("reset").clicked() {
            *reset = Some(action);
        }
    });
}

/// The controls-menu text for a live binding list: each alternative,
/// separated, in the order the player can use them.
fn bindings_text<B: Display>(bindings: Vec<B>) -> String {
    bindings
        .iter()
        .map(ToString::to_string)
        .collect::<Vec<_>>()
        .join(", ")
}

fn spawn_bricks() -> Vec<Brick> {
    let cell = BRICK_HALF_WIDTH * 2.0 + BRICK_GAP;
    let row_span = BRICK_HALF_DEPTH * 2.0 + BRICK_ROW_GAP;
    let grid_width = cell * BRICK_COLUMNS as f32 - BRICK_GAP;
    let start_x = -grid_width * 0.5 + BRICK_HALF_WIDTH;
    let start_z = -COURT_HALF_DEPTH + WALL_THICKNESS + BRICK_HALF_DEPTH + 0.6;

    (0..BRICK_ROWS)
        .flat_map(|row| {
            (0..BRICK_COLUMNS).map(move |column| Brick {
                row,
                position: Vec3::new(
                    start_x + column as f32 * cell,
                    BRICK_HALF_HEIGHT,
                    start_z + row as f32 * row_span,
                ),
                hits_remaining: BRICK_HITS,
            })
        })
        .collect()
}

impl Game for Breakout {
    type Meshes = Shape;
    type Sounds = Sound;
    type InputActions = Controls;
    type Skyboxes = NoSkyboxes;
    type SurfaceStyles = NoSurfaceStyles;
    type PostEffects = NoPostEffects;

    fn tick(&mut self, ctx: &mut TickContext<'_, Breakout>) {
        if self.paused {
            return;
        }

        let dt = ctx.dt().as_secs_f32();
        self.paddle_flash = (self.paddle_flash - dt).max(0.0);
        self.brick_flash = (self.brick_flash - dt).max(0.0);
        self.life_lost_flash = (self.life_lost_flash - dt).max(0.0);
        self.step_sparks(dt);

        // Decay runs before the end-screen return below, so the last pulse and
        // burst do not stay on screen.
        if matches!(self.phase, Phase::Won | Phase::Lost) {
            return;
        }

        let axis = if ctx.ui_wants_keyboard() {
            0.0
        } else {
            ctx.axis(Move::Paddle)
        };
        self.step_paddle(axis, dt);

        match self.phase {
            Phase::Serving => self.hold_ball(ctx),
            _ => self.step_ball(ctx, dt),
        }
    }

examples/sound-lab.rs (line 463)

    fn handle_walk(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        self.player_prev = self.player;
        if ctx.ui_wants_keyboard() {
            return;
        }
        let walk = ctx.axis2(Move::Walk);
        let world = Vec2::new(walk.x, -walk.y);
        self.player = (self.player + world * WALK_SPEED * ctx.dt().as_secs_f32())
            .clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
    }

examples/sprite-adventure.rs (line 1810)

    fn tick(&mut self, ctx: &mut TickContext<'_, Keep>) {
        self.previous = self.position;

        if self.reset_requested || ctx.pressed(Button::Reset) {
            self.reset_requested = false;
            self.reset(ctx);
            return;
        }

        let heading = if ctx.ui_wants_keyboard() {
            Vec2::ZERO
        } else {
            ctx.axis2(Move::Walk)
        };
        match Facing::from_heading(heading) {
            Some(facing) => {
                self.facing = facing;
                self.walk_ticks += 1;
            }
            None => self.walk_ticks = 0,
        }
        let stride = Vec3::new(heading.x, 0.0, -heading.y) * WALK_SPEED * ctx.dt().as_secs_f32();
        self.position += stride;
        self.simulated += ctx.dt();

        match self.area {
            Area::Overworld => self.tick_overworld(ctx),
            Area::Cave => self.tick_cave(ctx),
        }
    }

pub fn window_size(&self) -> UVec2

The window’s drawing area, in physical pixels; zero while minimized.

Examples found in repository

examples/ui-fonts.rs (line 637)

    fn handle_hail(&mut self, ctx: &mut TickContext<'_, Self>) {
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let Some(station) = hit_station(ray) else {
            return;
        };

        if self.hailed != Some(station) {
            self.hailed = Some(station);
            let look = station.look();
            self.dialogue = Some(Dialogue::start(look.name, look.lines.map(str::to_owned)));
            return;
        }
        let Some(dialogue) = &mut self.dialogue else {
            return;
        };
        if !dialogue.advance() {
            self.dialogue = None;
            self.hailed = None;
        }
    }

examples/sound-lab.rs (line 486)

    fn handle_drag(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        // Read before the check below for the UI's own claim on the
        // pointer, so a release over it still frees a source a drag moved
        // there.
        if ctx.released(Button::Select) {
            self.dragging = None;
        }
        if ctx.ui_wants_pointer() {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if ctx.pressed(Button::Select) {
            self.dragging = self.sources.iter().position(|source| {
                ray.hit_sphere(source.position, SOURCE_PICK_RADIUS)
                    .is_some()
            });
        }

        let Some(index) = self.dragging else {
            return;
        };
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let hit = ray.at(distance);
        let dropped =
            Vec2::new(hit.x, hit.z).clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
        self.sources[index].position = Vec3::new(dropped.x, SOURCE_HEIGHT, dropped.y);
    }

examples/isometric-board.rs (line 420)

    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

pub fn last_camera(&self) -> Camera

The camera the last drawn frame was viewed from; Camera::default before the first frame.

Required if you want a ray through a pixel: the player points at what was last drawn.

Examples found in repository

examples/ui-fonts.rs (line 636)

    fn handle_hail(&mut self, ctx: &mut TickContext<'_, Self>) {
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let Some(station) = hit_station(ray) else {
            return;
        };

        if self.hailed != Some(station) {
            self.hailed = Some(station);
            let look = station.look();
            self.dialogue = Some(Dialogue::start(look.name, look.lines.map(str::to_owned)));
            return;
        }
        let Some(dialogue) = &mut self.dialogue else {
            return;
        };
        if !dialogue.advance() {
            self.dialogue = None;
            self.hailed = None;
        }
    }

examples/sound-lab.rs (line 485)

    fn handle_drag(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        // Read before the check below for the UI's own claim on the
        // pointer, so a release over it still frees a source a drag moved
        // there.
        if ctx.released(Button::Select) {
            self.dragging = None;
        }
        if ctx.ui_wants_pointer() {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if ctx.pressed(Button::Select) {
            self.dragging = self.sources.iter().position(|source| {
                ray.hit_sphere(source.position, SOURCE_PICK_RADIUS)
                    .is_some()
            });
        }

        let Some(index) = self.dragging else {
            return;
        };
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let hit = ray.at(distance);
        let dropped =
            Vec2::new(hit.x, hit.z).clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
        self.sources[index].position = Vec3::new(dropped.x, SOURCE_HEIGHT, dropped.y);
    }

examples/isometric-board.rs (line 419)

    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

pub fn config(&self) -> &Config

The configuration the engine started with.