Struct Transform 

pub struct Transform(/* private fields */);

A draw’s position, turn, and size.

Implementations

impl Transform

pub const IDENTITY: Self

No position, turn, or size change.

pub fn from_translation(translation: Vec3) -> Self

At translation, in meters.

Examples found in repository

examples/material-playground.rs (line 977)

    fn draw_outpost(&self, ctx: &mut FrameContext<'_, Self>) {
        let clock = ctx.elapsed().as_secs_f32();

        for &(position, scale) in &PILLARS {
            ctx.draw(
                Cube.at(Transform::from_scale_rotation_translation(
                    scale,
                    Quat::IDENTITY,
                    OUTPOST + position,
                ))
                .material(Material::lit(Color::rgb(0.55, 0.5, 0.45))),
            );
        }

        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                POLE_SCALE,
                Quat::IDENTITY,
                OUTPOST + POLE_POSITION,
            ))
            .material(Material::lit(Color::rgb(0.3, 0.24, 0.18))),
        );

        ctx.set_surface_style(Banner { time: clock });
        ctx.draw(
            BannerCloth
                .at(Transform::from_translation(OUTPOST + BANNER_MOUNT))
                .material(Material::lit(Color::rgb(0.75, 0.12, 0.12)))
                .surface_style::<Banner>(),
        );

        ctx.set_surface_style(Field {
            tint: Color::rgb(0.25, 0.75, 1.0),
            time: clock,
        });
        ctx.draw(
            Sphere { subdivisions: 2 }
                .at(Transform::from_scale_rotation_translation(
                    Vec3::splat(FIELD_ORB_SCALE),
                    Quat::IDENTITY,
                    OUTPOST + FIELD_ORB_POSITION,
                ))
                .material(Material::color(Color::BLACK))
                .surface_style::<Field>(),
        );
    }

examples/breakout-game.rs (lines 1029-1033)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Breakout>) {
        if matches!(self.phase, Phase::Serving | Phase::Playing) && ctx.pressed(Button::Pause) {
            self.paused = !self.paused;
        }

        ctx.set_volume(self.master_volume);
        self.sustain_music(ctx);

        ctx.set_camera(Self::camera());

        let brick_pulse = (self.brick_flash / BRICK_FLASH).clamp(0.0, 1.0);
        ctx.set_bloom((BLOOM_BASE + brick_pulse * BLOOM_PULSE_PEAK).clamp(0.0, 1.0));

        let life_lost_t = (self.life_lost_flash / LIFE_LOST_FLASH).clamp(0.0, 1.0);
        ctx.set_exposure((1.0 - life_lost_t * EXPOSURE_DIP_DEPTH).clamp(0.0, 1.0));

        // The tick moves nothing behind a menu, so a frame there draws the last
        // step whole rather than interpolating from the one before.
        let alpha = match self.phase {
            Phase::Serving | Phase::Playing if !self.paused => ctx.alpha(),
            _ => 1.0,
        };
        let paddle_x = self.paddle_prev_x.lerp(self.paddle_x, alpha);
        let ball_pos = self.ball_prev.lerp(self.ball_pos, alpha);

        ctx.light(Light::point(ball_pos, BALL_GLOW, BALL_LIGHT_RANGE).shadow());

        self.draw_court(ctx);
        self.draw_bricks(ctx);
        self.draw_sparks(ctx);
        self.draw_lives(ctx);

        ctx.draw(
            Paddle
                .at(Transform::from_translation(Vec3::new(
                    paddle_x,
                    PADDLE_HALF_HEIGHT,
                    PADDLE_Z,
                )))
                .material_of(PaddlePart::Face, self.paddle_face_material()),
        );

        self.draw_trail(ctx, alpha);
        ctx.draw(
            Sphere { subdivisions: 2 }
                .at(Transform::from_scale_rotation_translation(
                    Vec3::splat(BALL_RADIUS * 2.0),
                    Quat::IDENTITY,
                    ball_pos,
                ))
                .material(
                    Material::color(BALL_GLOW)
                        .emissive(BALL_EMISSIVE)
                        .additive(),
                ),
        );

        self.overlay(ctx);
    }

pub fn from_rotation(rotation: Quat) -> Self

Turned about the origin.

pub fn from_scale(scale: Vec3) -> Self

Sized about the origin, per axis.

Examples found in repository

examples/stress-preview.rs (line 398)

    fn draw_ground(ctx: &mut FrameContext<'_, Self>) {
        let side = (FIELD_RADIUS + FIELD_INNER_RADIUS) * 2.2;
        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(side, 1.0, side)))
                .material(Material::lit(GROUND_COLOR).roughness(0.9)),
        );
    }

examples/flock-parallelism.rs (lines 663-667)

    fn draw_ground(ctx: &mut FrameContext<'_, Self>) {
        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    GROUND_SIZE,
                    1.0,
                    GROUND_SIZE,
                )))
                .material(Material::lit(GROUND_COLOR).roughness(0.9)),
        );
    }

examples/post-effects.rs (lines 95-99)

    fn draw_scene(&self, ctx: &mut FrameContext<'_, Self>) {
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    GROUND_SIZE,
                    1.0,
                    GROUND_SIZE,
                )))
                .material(Material::lit(GROUND_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(GLOW_SIZE),
                Quat::IDENTITY,
                GLOW_POSITION,
            ))
            .material(Material::color(Color::BLACK).emissive(GLOW_COLOR)),
        );
        for position in SPHERE_POSITIONS {
            ctx.draw(
                Sphere {
                    subdivisions: SPHERE_SUBDIVISIONS,
                }
                .at(position)
                .material(Material::lit(SPHERE_COLOR)),
            );
        }
    }

examples/ui-fonts.rs (lines 826-830)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.steer(ctx);

        let camera = self.orbit.camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Dusk);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    PLATFORM_SIZE,
                    1.0,
                    PLATFORM_SIZE,
                )))
                .material(Material::lit(PLATFORM_COLOR)),
        );
        for station in StationKind::ALL {
            self.draw_station(ctx, station);
        }

        let hovered = Self::hovered(ctx);
        if !self.sheet_open {
            if let Some(station) = hovered {
                ctx.set_cursor(Cursor::Pointer);
                self.draw_bracket(ctx, camera, station);
            }
            self.draw_prompts(ctx, camera, hovered);
        }
        if self.dialogue.is_some() {
            self.draw_dialogue(ctx);
        }
        if self.sheet_open {
            ctx.ui(sheet);
        }
        self.panel(ctx);
    }

examples/breakout-game.rs (lines 607-611)

    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)),
        );
    }

examples/sound-lab.rs (lines 513-517)

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

        let side_half = Vec3::new(WALL_THICKNESS * 0.5, WALL_HEIGHT * 0.5, ROOM_HALF);
        for side in [-1.0, 1.0] {
            let x = side * (ROOM_HALF - 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 end_half = Vec3::new(ROOM_HALF, WALL_HEIGHT * 0.5, WALL_THICKNESS * 0.5);
        for side in [-1.0, 1.0] {
            let z = side * (ROOM_HALF - WALL_THICKNESS * 0.5);
            ctx.draw(
                Cube.at(Transform::from_scale_rotation_translation(
                    end_half * 2.0,
                    Quat::IDENTITY,
                    Vec3::new(0.0, end_half.y, z),
                ))
                .material(Material::lit(WALL_COLOR)),
            );
        }
    }

Additional examples can be found in:

• examples/material-playground.rs
• examples/animation.rs

pub fn from_rotation_translation(rotation: Quat, translation: Vec3) -> Self

Turned about the origin, then moved.

Examples found in repository

examples/sprite-adventure.rs (line 1581)

    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),
        );
    }

examples/animation.rs (lines 1016-1019)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Scene>) {
        self.steer_camera(ctx);

        let alpha = ctx.alpha();
        let elf_pos = self.elf_prev.lerp(self.elf_pos, alpha);
        let elf_height = self.elf_height_prev + (self.elf_height - self.elf_height_prev) * alpha;
        let (butterfly_pos, butterfly_yaw) = butterfly_pose(ctx.elapsed().as_secs_f32());

        let camera = orbit_camera(elf_pos, self.camera_yaw, self.camera_pitch);
        ctx.set_camera(camera);
        ctx.set_cursor(if self.holding {
            Cursor::Held
        } else {
            Cursor::Arrow
        });
        ctx.set_skybox(Sky::Day);
        ctx.set_exposure(3.0);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());
        ctx.light(
            Light::point(
                LAMP_POST_POSITION + Vec3::Y * (LAMP_POST_HEIGHT + LAMP_HEAD_GAP * 0.5),
                LAMP_LIGHT_COLOR,
                LAMP_LIGHT_RANGE,
            )
            .shadow(),
        );
        ctx.light(
            Light::spot(Spot {
                position: SPOT_POSITION,
                direction: SPOT_DIRECTION,
                color: SPOT_COLOR,
                range: SPOT_RANGE,
                angle: SPOT_ANGLE,
            })
            .shadow(),
        );
        ctx.light(
            Light::point(butterfly_pos, BUTTERFLY_LIGHT_COLOR, BUTTERFLY_LIGHT_RANGE).shadow(),
        );

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    GROUND_SIZE,
                    1.0,
                    GROUND_SIZE,
                )))
                .material(Material::lit(GROUND_COLOR)),
        );
        for patch in HURT_PATCHES {
            ctx.draw(
                Plane
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::splat(HURT_RADIUS * 2.0),
                        Quat::IDENTITY,
                        patch,
                    ))
                    .material(Material::lit(HURT_COLOR)),
            );
        }
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::new(SEAT_FOOTPRINT, SEAT_HEIGHT, SEAT_FOOTPRINT),
                Quat::IDENTITY,
                SEAT_POSITION + Vec3::Y * SEAT_HEIGHT * 0.5,
            ))
            .material(Material::lit(SEAT_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::new(LAMP_POST_THICKNESS, LAMP_POST_HEIGHT, LAMP_POST_THICKNESS),
                Quat::IDENTITY,
                LAMP_POST_POSITION + Vec3::Y * LAMP_POST_HEIGHT * 0.5,
            ))
            .material(Material::lit(LAMP_POST_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(LAMP_HEAD_SIZE),
                Quat::IDENTITY,
                LAMP_POST_POSITION
                    + Vec3::Y * (LAMP_POST_HEIGHT + LAMP_HEAD_GAP + LAMP_HEAD_SIZE * 0.5),
            ))
            .material(Material::color(Color::BLACK).emissive(LAMP_LIGHT_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(SPOT_FIXTURE_SIZE),
                Quat::IDENTITY,
                SPOT_POSITION + Vec3::Y * SPOT_FIXTURE_SIZE * 0.5,
            ))
            .material(Material::lit(SPOT_FIXTURE_COLOR)),
        );

        ctx.draw(
            Elf.at(Transform::from_rotation_translation(
                Quat::from_rotation_y(self.elf_yaw),
                elf_pos + Vec3::Y * elf_height,
            ))
            .posed(&self.elf_animator),
        );
        ctx.draw(
            Elf.at(Transform::from_rotation_translation(
                Quat::from_rotation_y(core::f32::consts::PI),
                SCRUBBED_ELF_POSITION,
            ))
            .posed(&self.scrubbed_animator),
        );
        ctx.draw(
            Butterfly
                .at(Transform::from_rotation_translation(
                    Quat::from_rotation_y(butterfly_yaw),
                    butterfly_pos,
                ))
                .posed(&self.butterfly_animator)
                .material(Material::lit(Color::WHITE).emissive(BUTTERFLY_EMISSIVE)),
        );

        self.draw_prompts(ctx, camera);
        self.panel(ctx);
    }

pub fn from_scale_rotation_translation( scale: Vec3, rotation: Quat, translation: Vec3, ) -> Self

Sized, then turned, then moved.

Examples found in repository

examples/stress-preview.rs (lines 411-415)

    fn draw_field(&self, ctx: &mut FrameContext<'_, Self>, elapsed: f32) {
        for entry in &self.field {
            let yaw = if self.settings.moving && entry.moving {
                entry.phase + elapsed * MOVING_SPEED
            } else {
                entry.phase
            };
            ctx.draw(
                Rock { seed: entry.seed }.at(Transform::from_scale_rotation_translation(
                    Vec3::ONE,
                    Quat::from_rotation_y(yaw),
                    entry.position,
                )),
            );
        }
    }

examples/flock-parallelism.rs (lines 679-683)

    fn draw_butterflies(&self, ctx: &mut FrameContext<'_, Self>) {
        for (position, velocity, kind) in self.butterflies.each() {
            let rotation = Quat::from_rotation_arc(Vec3::Z, Vec3::from(velocity).normalize());
            ctx.draw(
                Butterfly
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::splat(BUTTERFLY_SCALE),
                        rotation,
                        Vec3::from(position),
                    ))
                    .posed(&self.flaps[usize::from(kind.flap)])
                    .material(Material::lit(TINTS[usize::from(kind.tint)])),
            );
        }
    }

examples/ui-fonts.rs (lines 672-676)

    fn draw_station(&self, ctx: &mut FrameContext<'_, Self>, station: StationKind) {
        let look = station.look();
        let center = station.center();
        let front_offset =
            STATION_SIZE.z * 0.5 - STATION_FRONT_SIZE.z * 0.5 + STATION_FRONT_OUTWARD;
        let front = center - Vec3::new(0.0, 0.0, front_offset);
        for (size, position, material) in [
            (STATION_SIZE, center, Material::lit(look.color)),
            (
                STATION_FRONT_SIZE,
                front,
                Material::color(Color::BLACK).emissive(look.glow),
            ),
        ] {
            ctx.draw(
                Cube.at(Transform::from_scale_rotation_translation(
                    size,
                    Quat::IDENTITY,
                    position,
                ))
                .material(material),
            );
        }
    }

examples/post-effects.rs (lines 103-107)

    fn draw_scene(&self, ctx: &mut FrameContext<'_, Self>) {
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    GROUND_SIZE,
                    1.0,
                    GROUND_SIZE,
                )))
                .material(Material::lit(GROUND_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(GLOW_SIZE),
                Quat::IDENTITY,
                GLOW_POSITION,
            ))
            .material(Material::color(Color::BLACK).emissive(GLOW_COLOR)),
        );
        for position in SPHERE_POSITIONS {
            ctx.draw(
                Sphere {
                    subdivisions: SPHERE_SUBDIVISIONS,
                }
                .at(position)
                .material(Material::lit(SPHERE_COLOR)),
            );
        }
    }

examples/breakout-game.rs (lines 619-623)

    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),
        }
    }

    fn frame(&mut self, ctx: &mut FrameContext<'_, Breakout>) {
        if matches!(self.phase, Phase::Serving | Phase::Playing) && ctx.pressed(Button::Pause) {
            self.paused = !self.paused;
        }

        ctx.set_volume(self.master_volume);
        self.sustain_music(ctx);

        ctx.set_camera(Self::camera());

        let brick_pulse = (self.brick_flash / BRICK_FLASH).clamp(0.0, 1.0);
        ctx.set_bloom((BLOOM_BASE + brick_pulse * BLOOM_PULSE_PEAK).clamp(0.0, 1.0));

        let life_lost_t = (self.life_lost_flash / LIFE_LOST_FLASH).clamp(0.0, 1.0);
        ctx.set_exposure((1.0 - life_lost_t * EXPOSURE_DIP_DEPTH).clamp(0.0, 1.0));

        // The tick moves nothing behind a menu, so a frame there draws the last
        // step whole rather than interpolating from the one before.
        let alpha = match self.phase {
            Phase::Serving | Phase::Playing if !self.paused => ctx.alpha(),
            _ => 1.0,
        };
        let paddle_x = self.paddle_prev_x.lerp(self.paddle_x, alpha);
        let ball_pos = self.ball_prev.lerp(self.ball_pos, alpha);

        ctx.light(Light::point(ball_pos, BALL_GLOW, BALL_LIGHT_RANGE).shadow());

        self.draw_court(ctx);
        self.draw_bricks(ctx);
        self.draw_sparks(ctx);
        self.draw_lives(ctx);

        ctx.draw(
            Paddle
                .at(Transform::from_translation(Vec3::new(
                    paddle_x,
                    PADDLE_HALF_HEIGHT,
                    PADDLE_Z,
                )))
                .material_of(PaddlePart::Face, self.paddle_face_material()),
        );

        self.draw_trail(ctx, alpha);
        ctx.draw(
            Sphere { subdivisions: 2 }
                .at(Transform::from_scale_rotation_translation(
                    Vec3::splat(BALL_RADIUS * 2.0),
                    Quat::IDENTITY,
                    ball_pos,
                ))
                .material(
                    Material::color(BALL_GLOW)
                        .emissive(BALL_EMISSIVE)
                        .additive(),
                ),
        );

        self.overlay(ctx);
    }

examples/isometric-board.rs (lines 512-516)

    fn draw_board(&self, ctx: &mut FrameContext<'_, Board>, hover: Hover) {
        let scale = Vec3::new(TILE_SIZE - TILE_GAP, TILE_THICKNESS, TILE_SIZE - TILE_GAP);
        for col in 0..BOARD_TILES {
            for row in 0..BOARD_TILES {
                let tile = (col, row);
                let center = tile_center(tile) - Vec3::Y * (TILE_THICKNESS * 0.5);
                let reachable = self.selected && self.reachable(tile);
                let hovered = self.selected && hover == Hover::Tile(tile);
                let color = if hovered {
                    if reachable {
                        HOVER_REACHABLE_TILE
                    } else {
                        HOVER_BLOCKED_TILE
                    }
                } else if (col + row) % 2 == 0 {
                    LIGHT_TILE
                } else {
                    DARK_TILE
                };
                ctx.draw(
                    Cube.at(Transform::from_scale_rotation_translation(
                        scale,
                        Quat::IDENTITY,
                        center,
                    ))
                    .material(Material::lit(color)),
                );
                if reachable && !hovered {
                    self.draw_reachable_mark(ctx, tile);
                }
            }
        }
    }

    /// A mark over a reachable tile, its own tone apart from the
    /// checker's tone and the hover tone, so the checker still reads
    /// under it.
    fn draw_reachable_mark(&self, ctx: &mut FrameContext<'_, Board>, tile: (i32, i32)) {
        let center = tile_center(tile) + Vec3::Y * REACHABLE_MARK_LIFT;
        ctx.draw(
            Plane
                .at(Transform::from_scale_rotation_translation(
                    Vec3::new(
                        TILE_SIZE * REACHABLE_MARK_SCALE,
                        1.0,
                        TILE_SIZE * REACHABLE_MARK_SCALE,
                    ),
                    Quat::IDENTITY,
                    center,
                ))
                .material(Material::color(REACHABLE_MARK)),
        );
    }

    /// A mark bright enough to read past the sprite's own tint under the
    /// selected unit, or a smaller, dim one under the unit whose turn it
    /// is while nothing is selected — so the current unit reads from the
    /// ground alone.
    fn draw_current_mark(&self, ctx: &mut FrameContext<'_, Board>) {
        let (color, scale) = if self.selected {
            (CURRENT_MARK, CURRENT_MARK_SCALE)
        } else {
            (TURN_MARK, TURN_MARK_SCALE)
        };
        let center = tile_center(self.current().tile) + Vec3::Y * REACHABLE_MARK_LIFT;
        ctx.draw(
            Plane
                .at(Transform::from_scale_rotation_translation(
                    Vec3::new(TILE_SIZE * scale, 1.0, TILE_SIZE * scale),
                    Quat::IDENTITY,
                    center,
                ))
                .material(Material::color(color)),
        );
    }

    fn draw_rocks(&self, ctx: &mut FrameContext<'_, Board>) {
        for &(x, z, seed, scale) in &ROCKS {
            let angle = hash_signed(seed, 99) * core::f32::consts::PI;
            ctx.draw(
                Rock { seed }
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::splat(scale),
                        Quat::from_rotation_y(angle),
                        Vec3::new(x, 0.5 * scale, z),
                    ))
                    .material(Material::lit(ROCK_COLOR)),
            );
        }
    }

    fn draw_sprite(&self, ctx: &mut FrameContext<'_, Board>, hover: Hover) {
        let position = self.sprite.previous.lerp(self.sprite.position, ctx.alpha());
        let current = self.turn == Turn::Sprite;
        let (tint, glow) = if current && self.selected {
            (SELECTED_TINT, SELECTED_GLOW)
        } else if current && hover == Hover::CurrentUnit {
            (HOVER_TINT, HOVER_GLOW)
        } else if current {
            (TURN_TINT, TURN_GLOW)
        } else {
            (Color::WHITE, Color::BLACK)
        };
        ctx.draw(
            Sprite
                .at(Transform::from_scale_rotation_translation(
                    Vec3::new(SPRITE_WIDTH, SPRITE_HEIGHT, 1.0),
                    Quat::IDENTITY,
                    position,
                ))
                .upright()
                .frame(sprite_frame(self.sprite.facing_right))
                .material(Material::lit(tint).cutout().emissive(glow)),
        );
    }

    fn draw_block(&self, ctx: &mut FrameContext<'_, Board>, hover: Hover) {
        let position = self.block.previous.lerp(self.block.position, ctx.alpha());
        let current = self.turn == Turn::Block;
        let (color, glow) = if current && self.selected {
            (SELECTED_TINT, SELECTED_GLOW)
        } else if current && hover == Hover::CurrentUnit {
            (HOVER_TINT, HOVER_GLOW)
        } else if current {
            (BLOCK_TURN, TURN_GLOW)
        } else {
            (BLOCK_IDLE, Color::BLACK)
        };
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(BLOCK_SIZE),
                Quat::IDENTITY,
                position,
            ))
            .material(Material::lit(color).emissive(glow)),
        );
    }

    fn draw_ground(&self, ctx: &mut FrameContext<'_, Board>) {
        ctx.draw(
            Plane
                .at(Transform::from_scale_rotation_translation(
                    Vec3::new(GROUND_HALF * 2.0, 1.0, GROUND_HALF * 2.0),
                    Quat::IDENTITY,
                    Vec3::new(0.0, GROUND_Y, 0.0),
                ))
                .material(Material::lit(GROUND_COLOR)),
        );
    }

Additional examples can be found in:

• examples/sound-lab.rs
• examples/material-playground.rs
• examples/sprite-adventure.rs
• examples/animation.rs

pub const fn matrix(self) -> Mat4

The matrix that takes mesh space to world space.

Trait Implementations

impl Clone for Transform

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Transform

impl Debug for Transform

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Self

Transform::IDENTITY.

impl From<Mat4> for Transform

fn from(matrix: Mat4) -> Self

A matrix a game built itself; only its affine part is kept.

impl From<Vec3> for Transform

fn from(translation: Vec3) -> Self

A position.

impl Mul for Transform

fn mul(self, after: Self) -> Self

This transform applied over after — matrix order, so base * track.at(elapsed) places the animation within base.

type Output = Transform

The resulting type after applying the * operator.

impl PartialEq for Transform

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Pod for Transform

impl StructuralPartialEq for Transform

impl Zeroable for Transform

fn zeroed() -> Self

Calls zeroed.