Struct FrameContext 

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

The work Game::frame may do.

Implementations

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

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

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

Whether action is held right now.

Examples found in repository

examples/ui-fonts.rs (line 779)

    fn steer(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Trigger::Hail) {
            self.orbit.turn(ctx.axis2(Turn::Look));
        }
        let wheel = ctx.axis(Zoom::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.orbit.zoom(ZOOM_STEP.powf(wheel));
        }
    }

examples/stress-preview.rs (line 365)

    fn handle_camera(&mut self, ctx: &mut FrameContext<'_, Self>, elapsed: f32) {
        if ctx.ui_wants_pointer() || ctx.ui_wants_keyboard() {
            return;
        }
        let pan = ctx.axis2(Motion::Pan);
        let wheel = ctx.axis(Height::Wheel);
        let look = if ctx.down(Drag::Turn) {
            ctx.axis2(Motion::Look)
        } else {
            Vec2::ZERO
        };
        if pan == Vec2::ZERO && wheel == 0.0 && look == Vec2::ZERO {
            return;
        }

        let player = self.player.get_or_insert_with(|| {
            let eye = Self::orbit_eye(elapsed);
            let forward = (Vec3::ZERO - eye).normalize();
            Player {
                eye,
                yaw: (-forward.x).atan2(-forward.z),
                pitch: forward.y.asin(),
            }
        });

        player.yaw -= look.x;
        player.pitch = (player.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);

        let forward = Vec3::new(-player.yaw.sin(), 0.0, -player.yaw.cos());
        let right = Vec3::new(player.yaw.cos(), 0.0, -player.yaw.sin());
        player.eye += (forward * pan.y + right * pan.x) * PAN_SPEED * ctx.dt().as_secs_f32();
        player.eye.y =
            (player.eye.y + wheel * WHEEL_STEP).clamp(MIN_CAMERA_HEIGHT, MAX_CAMERA_HEIGHT);
    }

examples/material-playground.rs (line 803)

    fn fly_camera(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Move::Look) {
            let look = ctx.axis2(Turn::Look);
            self.yaw -= look.x;
            self.pitch = (self.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);
        }

        let wheel = ctx.axis(Speed::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.speed_scale =
                (self.speed_scale * SPEED_STEP.powf(wheel)).clamp(MIN_SPEED_SCALE, MAX_SPEED_SCALE);
        }

        let forward = self.forward();
        let right = Vec3::new(self.yaw.cos(), 0.0, -self.yaw.sin());
        let mut move_by = Vec3::ZERO;
        if ctx.down(Move::Forward) {
            move_by += forward;
        }
        if ctx.down(Move::Back) {
            move_by -= forward;
        }
        if ctx.down(Move::Right) {
            move_by += right;
        }
        if ctx.down(Move::Left) {
            move_by -= right;
        }
        if ctx.down(Move::Up) {
            move_by += Vec3::Y;
        }
        if ctx.down(Move::Down) {
            move_by -= Vec3::Y;
        }
        if move_by.length_squared() > 1.0 {
            move_by = move_by.normalize();
        }

        self.eye += move_by * MOVE_SPEED * self.speed_scale * ctx.dt().as_secs_f32();
        self.eye.y = self.eye.y.max(MIN_EYE_HEIGHT);
    }

examples/input-lab.rs (line 247)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

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

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

Whether action went down during this frame.

Examples found in repository

examples/breakout-game.rs (line 996)

    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/input-lab.rs (line 248)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

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

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

Whether action came up during this frame.

Examples found in repository

examples/input-lab.rs (line 249)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

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

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

Presses of action in a row, counting this frame’s: 1 for a single click, 2 for a double, and 0 on a frame where action was not pressed.

A press counts with the one before it where the same control took both, no later than the double click interval after it — the platform’s own until Config::with_double_click_interval sets one. The engine counts one control at a time, so an action whose press lands in the same frame as another control’s reads 0 where the count is on that other one. A headless session counts against the clock its caller drives, so presses at one instant of it count together.

Examples found in repository

examples/input-lab.rs (line 250)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

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.

Examples found in repository

examples/animation.rs (line 683)

    fn steer_camera(&mut self, ctx: &mut FrameContext<'_, Scene>) {
        self.camera_yaw -= ctx.axis(Axis::CameraYaw);
        self.camera_pitch = (self.camera_pitch + ctx.axis(Axis::CameraPitch))
            .clamp(CAMERA_PITCH_RANGE.start, CAMERA_PITCH_RANGE.end);
    }

examples/ui-fonts.rs (line 782)

    fn steer(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Trigger::Hail) {
            self.orbit.turn(ctx.axis2(Turn::Look));
        }
        let wheel = ctx.axis(Zoom::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.orbit.zoom(ZOOM_STEP.powf(wheel));
        }
    }

examples/stress-preview.rs (line 364)

    fn handle_camera(&mut self, ctx: &mut FrameContext<'_, Self>, elapsed: f32) {
        if ctx.ui_wants_pointer() || ctx.ui_wants_keyboard() {
            return;
        }
        let pan = ctx.axis2(Motion::Pan);
        let wheel = ctx.axis(Height::Wheel);
        let look = if ctx.down(Drag::Turn) {
            ctx.axis2(Motion::Look)
        } else {
            Vec2::ZERO
        };
        if pan == Vec2::ZERO && wheel == 0.0 && look == Vec2::ZERO {
            return;
        }

        let player = self.player.get_or_insert_with(|| {
            let eye = Self::orbit_eye(elapsed);
            let forward = (Vec3::ZERO - eye).normalize();
            Player {
                eye,
                yaw: (-forward.x).atan2(-forward.z),
                pitch: forward.y.asin(),
            }
        });

        player.yaw -= look.x;
        player.pitch = (player.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);

        let forward = Vec3::new(-player.yaw.sin(), 0.0, -player.yaw.cos());
        let right = Vec3::new(player.yaw.cos(), 0.0, -player.yaw.sin());
        player.eye += (forward * pan.y + right * pan.x) * PAN_SPEED * ctx.dt().as_secs_f32();
        player.eye.y =
            (player.eye.y + wheel * WHEEL_STEP).clamp(MIN_CAMERA_HEIGHT, MAX_CAMERA_HEIGHT);
    }

examples/material-playground.rs (line 809)

    fn fly_camera(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Move::Look) {
            let look = ctx.axis2(Turn::Look);
            self.yaw -= look.x;
            self.pitch = (self.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);
        }

        let wheel = ctx.axis(Speed::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.speed_scale =
                (self.speed_scale * SPEED_STEP.powf(wheel)).clamp(MIN_SPEED_SCALE, MAX_SPEED_SCALE);
        }

        let forward = self.forward();
        let right = Vec3::new(self.yaw.cos(), 0.0, -self.yaw.sin());
        let mut move_by = Vec3::ZERO;
        if ctx.down(Move::Forward) {
            move_by += forward;
        }
        if ctx.down(Move::Back) {
            move_by -= forward;
        }
        if ctx.down(Move::Right) {
            move_by += right;
        }
        if ctx.down(Move::Left) {
            move_by -= right;
        }
        if ctx.down(Move::Up) {
            move_by += Vec3::Y;
        }
        if ctx.down(Move::Down) {
            move_by -= Vec3::Y;
        }
        if move_by.length_squared() > 1.0 {
            move_by = move_by.normalize();
        }

        self.eye += move_by * MOVE_SPEED * self.speed_scale * ctx.dt().as_secs_f32();
        self.eye.y = self.eye.y.max(MIN_EYE_HEIGHT);
    }

examples/input-lab.rs (line 260)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

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.

Examples found in repository

examples/ui-fonts.rs (line 780)

    fn steer(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Trigger::Hail) {
            self.orbit.turn(ctx.axis2(Turn::Look));
        }
        let wheel = ctx.axis(Zoom::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.orbit.zoom(ZOOM_STEP.powf(wheel));
        }
    }

examples/stress-preview.rs (line 363)

    fn handle_camera(&mut self, ctx: &mut FrameContext<'_, Self>, elapsed: f32) {
        if ctx.ui_wants_pointer() || ctx.ui_wants_keyboard() {
            return;
        }
        let pan = ctx.axis2(Motion::Pan);
        let wheel = ctx.axis(Height::Wheel);
        let look = if ctx.down(Drag::Turn) {
            ctx.axis2(Motion::Look)
        } else {
            Vec2::ZERO
        };
        if pan == Vec2::ZERO && wheel == 0.0 && look == Vec2::ZERO {
            return;
        }

        let player = self.player.get_or_insert_with(|| {
            let eye = Self::orbit_eye(elapsed);
            let forward = (Vec3::ZERO - eye).normalize();
            Player {
                eye,
                yaw: (-forward.x).atan2(-forward.z),
                pitch: forward.y.asin(),
            }
        });

        player.yaw -= look.x;
        player.pitch = (player.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);

        let forward = Vec3::new(-player.yaw.sin(), 0.0, -player.yaw.cos());
        let right = Vec3::new(player.yaw.cos(), 0.0, -player.yaw.sin());
        player.eye += (forward * pan.y + right * pan.x) * PAN_SPEED * ctx.dt().as_secs_f32();
        player.eye.y =
            (player.eye.y + wheel * WHEEL_STEP).clamp(MIN_CAMERA_HEIGHT, MAX_CAMERA_HEIGHT);
    }

examples/material-playground.rs (line 804)

    fn fly_camera(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Move::Look) {
            let look = ctx.axis2(Turn::Look);
            self.yaw -= look.x;
            self.pitch = (self.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);
        }

        let wheel = ctx.axis(Speed::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.speed_scale =
                (self.speed_scale * SPEED_STEP.powf(wheel)).clamp(MIN_SPEED_SCALE, MAX_SPEED_SCALE);
        }

        let forward = self.forward();
        let right = Vec3::new(self.yaw.cos(), 0.0, -self.yaw.sin());
        let mut move_by = Vec3::ZERO;
        if ctx.down(Move::Forward) {
            move_by += forward;
        }
        if ctx.down(Move::Back) {
            move_by -= forward;
        }
        if ctx.down(Move::Right) {
            move_by += right;
        }
        if ctx.down(Move::Left) {
            move_by -= right;
        }
        if ctx.down(Move::Up) {
            move_by += Vec3::Y;
        }
        if ctx.down(Move::Down) {
            move_by -= Vec3::Y;
        }
        if move_by.length_squared() > 1.0 {
            move_by = move_by.normalize();
        }

        self.eye += move_by * MOVE_SPEED * self.speed_scale * ctx.dt().as_secs_f32();
        self.eye.y = self.eye.y.max(MIN_EYE_HEIGHT);
    }

examples/input-lab.rs (line 270)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

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 772)

    fn hovered(ctx: &FrameContext<'_, Self>) -> Option<StationKind> {
        if ctx.ui_wants_pointer() {
            return None;
        }
        hit_station(
            ctx.last_camera()
                .ray_through(ctx.pointer(), ctx.window_size()),
        )
    }

examples/isometric-board.rs (line 465)

    fn hovered(&self, ctx: &FrameContext<'_, Board>) -> Hover {
        if ctx.ui_wants_pointer() {
            return Hover::None;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if self.current().target.is_none() {
            let (_, half) = unit_geometry(self.turn);
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                return Hover::CurrentUnit;
            }
        }
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return Hover::None;
        };
        match tile_at(ray.at(distance)) {
            Some(tile) => Hover::Tile(tile),
            None => Hover::None,
        }
    }

examples/input-lab.rs (line 288)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

pub fn set_cursor(&mut self, cursor: Cursor)

Draws the pointer as cursor this frame; the last call in a frame is the one it draws.

A frame that never calls this draws it as Cursor::Arrow. Where the UI sets a cursor of its own, the UI’s is drawn instead.

Cursor::Held holds the pointer in place, and the UI’s own cursor does not take Held over: pointer reads the place it was held at, a PointerDelta binding keeps reading how far it moves, and the first frame to set another cursor releases it. A browser takes the pointer lock only from inside a gesture of the player’s, so there the hold is taken on the player’s next press or touch. A window loses the hold as it loses focus, and takes it again on the first frame to set Held after the focus returns.

Examples found in repository

examples/ui-fonts.rs (line 840)

    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/animation.rs (lines 930-934)

    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 rebind<A: InputAction>(&mut self, action: A, bindings: Vec<A::Binding>)

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

Binds action to bindings for the rest of the run, and keeps it for the runs after that — written when the frame ends, and only when these bindings are not already what action is bound to.

The kind of binding follows the action, so a stick cannot be bound to a button.

Examples found in repository

examples/breakout-game.rs (line 842)

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

examples/input-lab.rs (line 379)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

pub fn bindings<A: InputAction>(&self, action: A) -> Vec<A::Binding>

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

The bindings action reads through right now, which a controls menu shows through each binding’s text.

Examples found in repository

examples/ui-fonts.rs (line 709)

    fn draw_prompts(
        &self,
        ctx: &mut FrameContext<'_, Self>,
        camera: Camera,
        hovered: Option<StationKind>,
    ) {
        let Some(binding) = ctx.bindings(Trigger::Hail).into_iter().next() else {
            return;
        };
        let hint = prompt(&binding);
        let glyph = ctx.text_layout(&hint.text(), egui::FontId::new(PROMPT_SIZE, hint.family()));
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();

        ctx.ui(|ui| {
            let painter = ui.painter();
            for station in StationKind::ALL {
                if Some(station) == hovered {
                    continue;
                }
                let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
                let Some(pixel) = camera.pixel_of(top, window_size) else {
                    continue;
                };
                let at = logical(pixel, pixels_per_point);
                let at = egui::pos2(at.x, at.y - PROMPT_LIFT);
                prompt_at(painter, at, glyph.clone());
            }
        });
    }

examples/breakout-game.rs (line 743)

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

examples/animation.rs (line 825)

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

examples/input-lab.rs (line 246)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

pub fn actuated_button(&self) -> Option<ButtonBinding>

The button control the player pressed this frame, for a controls menu listening for one to bind.

Nothing where the player pressed nothing new; polling is the whole mechanism, so a menu that stops calling this stops listening.

Examples found in repository

examples/breakout-game.rs (line 781)

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

examples/input-lab.rs (line 276)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

pub fn actuated_axis(&self) -> Option<AxisBinding>

The analog control the player pushed this frame, past the deadzone a binding starts with.

The pointer and the wheel are never returned: they would take the smallest nudge for a choice.

Examples found in repository

examples/breakout-game.rs (line 784)

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

examples/input-lab.rs (line 277)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

pub fn actuated_axis2(&self) -> Option<Axis2Binding>

The stick the player pushed this frame, past the deadzone a binding starts with.

Examples found in repository

examples/input-lab.rs (line 278)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

pub fn dt(&self) -> Duration

Duration of the previous frame: this frame’s own variable time step, distinct from the fixed one tick runs at.

Examples found in repository

examples/stress-preview.rs (line 389)

    fn handle_camera(&mut self, ctx: &mut FrameContext<'_, Self>, elapsed: f32) {
        if ctx.ui_wants_pointer() || ctx.ui_wants_keyboard() {
            return;
        }
        let pan = ctx.axis2(Motion::Pan);
        let wheel = ctx.axis(Height::Wheel);
        let look = if ctx.down(Drag::Turn) {
            ctx.axis2(Motion::Look)
        } else {
            Vec2::ZERO
        };
        if pan == Vec2::ZERO && wheel == 0.0 && look == Vec2::ZERO {
            return;
        }

        let player = self.player.get_or_insert_with(|| {
            let eye = Self::orbit_eye(elapsed);
            let forward = (Vec3::ZERO - eye).normalize();
            Player {
                eye,
                yaw: (-forward.x).atan2(-forward.z),
                pitch: forward.y.asin(),
            }
        });

        player.yaw -= look.x;
        player.pitch = (player.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);

        let forward = Vec3::new(-player.yaw.sin(), 0.0, -player.yaw.cos());
        let right = Vec3::new(player.yaw.cos(), 0.0, -player.yaw.sin());
        player.eye += (forward * pan.y + right * pan.x) * PAN_SPEED * ctx.dt().as_secs_f32();
        player.eye.y =
            (player.eye.y + wheel * WHEEL_STEP).clamp(MIN_CAMERA_HEIGHT, MAX_CAMERA_HEIGHT);
    }

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

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

    /// How many field items lie in the camera's view at `window_size`:
    /// every item where the field holds at most [`MAX_IN_VIEW_SAMPLES`],
    /// otherwise one item stepped at a time and the count scaled back up
    /// to the whole field; `true` in the second place where the count
    /// came from such a step.
    ///
    /// Each item is tested on the engine's own workers: a parallel iterator
    /// reaches them with nothing configured for it.
    fn count_in_view(&self, camera: &Camera, window_size: UVec2) -> (usize, bool) {
        let stride = (self.field.len() as u32 / MAX_IN_VIEW_SAMPLES).max(1) as usize;
        let tested = self.field.par_iter().step_by(stride);
        let tested_count = self.field.len().div_ceil(stride);
        let in_view = tested
            .filter(|entry| Self::in_view(camera, entry.position, window_size))
            .count();
        let estimate = in_view
            .checked_mul(self.field.len())
            .and_then(|scaled| scaled.checked_div(tested_count))
            .unwrap_or(in_view);
        (estimate, stride > 1)
    }

    /// Whether `position` draws inside `window_size`, the frame's own
    /// bound of what the camera's view holds.
    fn in_view(camera: &Camera, position: Vec3, window_size: UVec2) -> bool {
        camera.pixel_of(position, window_size).is_some_and(|pixel| {
            pixel.x >= 0.0
                && pixel.y >= 0.0
                && pixel.x < window_size.x as f32
                && pixel.y < window_size.y as f32
        })
    }

    /// The load controls, and this frame's own cost, reported below them.
    fn controls(&mut self, ctx: &mut FrameContext<'_, Self>, camera: &Camera) {
        let submitted = self.field.len();
        let seeds = self.applied_seed_count;
        let average_ms = self.frame_times.average_ms();
        let fps = if average_ms > 0.0 {
            1000.0 / average_ms
        } else {
            0.0
        };
        let elapsed = ctx.elapsed().as_secs_f32();
        let (in_view, sampled) = self.count_in_view(camera, ctx.window_size());

        ctx.ui(|ui| {
            egui::Frame::new()
                .fill(egui::Color32::from_gray(24))
                .inner_margin(PANEL_PADDING)
                .corner_radius(f32::from(PANEL_PADDING))
                .show(ui, |ui| {
                    ui.add(
                        egui::Slider::new(
                            &mut self.settings.instance_count,
                            MIN_INSTANCE_COUNT..=MAX_INSTANCE_COUNT,
                        )
                        .text("instance count"),
                    );
                    ui.add(
                        egui::Slider::new(
                            &mut self.settings.seed_count,
                            MIN_SEED_COUNT..=MAX_SEED_COUNT,
                        )
                        .text("distinct seeds"),
                    );
                    ui.checkbox(&mut self.settings.sun_shadow, "sun shadow");
                    ui.checkbox(&mut self.settings.moving, "moving fraction");
                    ui.separator();
                    ui.label(format!("instances submitted {submitted}"));
                    if sampled {
                        ui.label(format!("in view, sampled {in_view}"));
                    } else {
                        ui.label(format!("instances in view {in_view}"));
                    }
                    ui.label(format!("distinct seeds {seeds}"));
                    ui.label(format!("frame time {average_ms:.2}ms, {fps:.0} fps"));
                    ui.label(format!("elapsed {elapsed:.1}s"));
                });
        });
    }
}

/// `instance_count` field values, each drawing one of `seed_count`
/// distinct seed values in a cycle, and scattered from
/// [`FIELD_INNER_RADIUS`] out to [`FIELD_RADIUS`]; each built from an
/// integer-hash of its own index.
fn build_field(instance_count: u32, seed_count: u32) -> Vec<FieldEntry> {
    (0..instance_count)
        .map(|index| {
            let angle = hash_unit(index, 0) * core::f32::consts::TAU;
            let spread = hash_unit(index, 1).sqrt();
            let distance = FIELD_INNER_RADIUS + spread * (FIELD_RADIUS - FIELD_INNER_RADIUS);
            FieldEntry {
                seed: index % seed_count,
                position: Vec3::new(angle.cos() * distance, 0.0, angle.sin() * distance),
                phase: hash_unit(index, 2) * core::f32::consts::TAU,
                moving: index % MOVING_STRIDE == 0,
            }
        })
        .collect()
}

/// A rock built from `seed`: a cone of [`ROCK_SIDES`] sides, each base
/// corner and the apex height displaced by an integer-hash of `seed`.
fn build_rock(seed: u32) -> MeshData {
    let height = ROCK_HEIGHT * (1.0 + hash_signed(seed, ROCK_SIDES) * ROCK_HEIGHT_DISPLACEMENT);
    let apex = Vec3::Y * height;
    let base: Vec<Vec3> = (0..ROCK_SIDES)
        .map(|corner| {
            let angle = core::f32::consts::TAU * corner as f32 / ROCK_SIDES as f32;
            let radius =
                ROCK_BASE_RADIUS * (1.0 + hash_signed(seed, corner) * ROCK_RADIAL_DISPLACEMENT);
            Vec3::new(angle.cos() * radius, 0.0, angle.sin() * radius)
        })
        .collect();

    let mut vertices = Vec::with_capacity(base.len() * 6);
    let mut indices = Vec::with_capacity(base.len() * 6);
    for corner in 0..base.len() {
        let next = (corner + 1) % base.len();
        push_face(&mut vertices, &mut indices, base[corner], apex, base[next]);
        push_face(
            &mut vertices,
            &mut indices,
            base[corner],
            base[next],
            Vec3::ZERO,
        );
    }

    MeshData::new(vertices, indices).with_material(Material::lit(ROCK_COLOR))
}

/// One triangle, shaded flat, over `a`, `b`, `c`, in the order that faces
/// outward: counter-clockwise as seen from the side its own normal points
/// to.
fn push_face(vertices: &mut Vec<Vertex>, indices: &mut Vec<u32>, a: Vec3, b: Vec3, c: Vec3) {
    let normal = (b - a).cross(c - a).normalize();
    let uvs = [
        Vec2::new(0.0, 1.0),
        Vec2::new(0.5, 0.0),
        Vec2::new(1.0, 1.0),
    ];
    let base = vertices.len() as u32;
    for (point, uv) in [a, b, c].into_iter().zip(uvs) {
        vertices.push(Vertex::new(point, normal, uv));
    }
    indices.extend([base, base + 1, base + 2]);
}

/// An integer-hash of `seed` and `salt`.
fn hash(seed: u32, salt: u32) -> u32 {
    let mut x = seed ^ salt.wrapping_mul(0x9E37_79B9);
    x ^= x >> 16;
    x = x.wrapping_mul(0x7FEB_352D);
    x ^= x >> 15;
    x = x.wrapping_mul(0x846C_A68B);
    x ^= x >> 16;
    x
}

/// `hash`, scaled to `0.0..1.0`.
fn hash_unit(seed: u32, salt: u32) -> f32 {
    hash(seed, salt) as f32 / u32::MAX as f32
}

/// `hash`, scaled to `-1.0..1.0`.
fn hash_signed(seed: u32, salt: u32) -> f32 {
    hash_unit(seed, salt) * 2.0 - 1.0
}

impl Game for StressPreview {
    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<'_, Self>) {}

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.apply_settings();
        self.frame_times.record(ctx.dt());

        let elapsed = ctx.elapsed().as_secs_f32();
        self.handle_camera(ctx, elapsed);
        let camera = self.camera(elapsed);
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);

        let sun = Light::directional(SUN_DIRECTION, SUN_COLOR);
        ctx.light(if self.settings.sun_shadow {
            sun.shadow()
        } else {
            sun
        });

        Self::draw_ground(ctx);
        self.draw_field(ctx, elapsed);
        self.controls(ctx, &camera);
    }

examples/material-playground.rs (line 840)

    fn fly_camera(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Move::Look) {
            let look = ctx.axis2(Turn::Look);
            self.yaw -= look.x;
            self.pitch = (self.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);
        }

        let wheel = ctx.axis(Speed::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.speed_scale =
                (self.speed_scale * SPEED_STEP.powf(wheel)).clamp(MIN_SPEED_SCALE, MAX_SPEED_SCALE);
        }

        let forward = self.forward();
        let right = Vec3::new(self.yaw.cos(), 0.0, -self.yaw.sin());
        let mut move_by = Vec3::ZERO;
        if ctx.down(Move::Forward) {
            move_by += forward;
        }
        if ctx.down(Move::Back) {
            move_by -= forward;
        }
        if ctx.down(Move::Right) {
            move_by += right;
        }
        if ctx.down(Move::Left) {
            move_by -= right;
        }
        if ctx.down(Move::Up) {
            move_by += Vec3::Y;
        }
        if ctx.down(Move::Down) {
            move_by -= Vec3::Y;
        }
        if move_by.length_squared() > 1.0 {
            move_by = move_by.normalize();
        }

        self.eye += move_by * MOVE_SPEED * self.speed_scale * ctx.dt().as_secs_f32();
        self.eye.y = self.eye.y.max(MIN_EYE_HEIGHT);
    }

pub fn elapsed(&self) -> Duration

Duration the game has been running.

Examples found in repository

examples/flock-parallelism.rs (line 745)

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

        let center = Vec3::from(self.butterflies.center());
        let elapsed = ctx.elapsed().as_secs_f32();
        ctx.set_camera(Self::camera(center, self.world, elapsed));
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        Self::draw_ground(ctx);
        self.draw_butterflies(ctx);
        self.panel(ctx);
    }

examples/material-playground.rs (line 952)

    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/stress-preview.rs (line 463)

    fn controls(&mut self, ctx: &mut FrameContext<'_, Self>, camera: &Camera) {
        let submitted = self.field.len();
        let seeds = self.applied_seed_count;
        let average_ms = self.frame_times.average_ms();
        let fps = if average_ms > 0.0 {
            1000.0 / average_ms
        } else {
            0.0
        };
        let elapsed = ctx.elapsed().as_secs_f32();
        let (in_view, sampled) = self.count_in_view(camera, ctx.window_size());

        ctx.ui(|ui| {
            egui::Frame::new()
                .fill(egui::Color32::from_gray(24))
                .inner_margin(PANEL_PADDING)
                .corner_radius(f32::from(PANEL_PADDING))
                .show(ui, |ui| {
                    ui.add(
                        egui::Slider::new(
                            &mut self.settings.instance_count,
                            MIN_INSTANCE_COUNT..=MAX_INSTANCE_COUNT,
                        )
                        .text("instance count"),
                    );
                    ui.add(
                        egui::Slider::new(
                            &mut self.settings.seed_count,
                            MIN_SEED_COUNT..=MAX_SEED_COUNT,
                        )
                        .text("distinct seeds"),
                    );
                    ui.checkbox(&mut self.settings.sun_shadow, "sun shadow");
                    ui.checkbox(&mut self.settings.moving, "moving fraction");
                    ui.separator();
                    ui.label(format!("instances submitted {submitted}"));
                    if sampled {
                        ui.label(format!("in view, sampled {in_view}"));
                    } else {
                        ui.label(format!("instances in view {in_view}"));
                    }
                    ui.label(format!("distinct seeds {seeds}"));
                    ui.label(format!("frame time {average_ms:.2}ms, {fps:.0} fps"));
                    ui.label(format!("elapsed {elapsed:.1}s"));
                });
        });
    }
}

/// `instance_count` field values, each drawing one of `seed_count`
/// distinct seed values in a cycle, and scattered from
/// [`FIELD_INNER_RADIUS`] out to [`FIELD_RADIUS`]; each built from an
/// integer-hash of its own index.
fn build_field(instance_count: u32, seed_count: u32) -> Vec<FieldEntry> {
    (0..instance_count)
        .map(|index| {
            let angle = hash_unit(index, 0) * core::f32::consts::TAU;
            let spread = hash_unit(index, 1).sqrt();
            let distance = FIELD_INNER_RADIUS + spread * (FIELD_RADIUS - FIELD_INNER_RADIUS);
            FieldEntry {
                seed: index % seed_count,
                position: Vec3::new(angle.cos() * distance, 0.0, angle.sin() * distance),
                phase: hash_unit(index, 2) * core::f32::consts::TAU,
                moving: index % MOVING_STRIDE == 0,
            }
        })
        .collect()
}

/// A rock built from `seed`: a cone of [`ROCK_SIDES`] sides, each base
/// corner and the apex height displaced by an integer-hash of `seed`.
fn build_rock(seed: u32) -> MeshData {
    let height = ROCK_HEIGHT * (1.0 + hash_signed(seed, ROCK_SIDES) * ROCK_HEIGHT_DISPLACEMENT);
    let apex = Vec3::Y * height;
    let base: Vec<Vec3> = (0..ROCK_SIDES)
        .map(|corner| {
            let angle = core::f32::consts::TAU * corner as f32 / ROCK_SIDES as f32;
            let radius =
                ROCK_BASE_RADIUS * (1.0 + hash_signed(seed, corner) * ROCK_RADIAL_DISPLACEMENT);
            Vec3::new(angle.cos() * radius, 0.0, angle.sin() * radius)
        })
        .collect();

    let mut vertices = Vec::with_capacity(base.len() * 6);
    let mut indices = Vec::with_capacity(base.len() * 6);
    for corner in 0..base.len() {
        let next = (corner + 1) % base.len();
        push_face(&mut vertices, &mut indices, base[corner], apex, base[next]);
        push_face(
            &mut vertices,
            &mut indices,
            base[corner],
            base[next],
            Vec3::ZERO,
        );
    }

    MeshData::new(vertices, indices).with_material(Material::lit(ROCK_COLOR))
}

/// One triangle, shaded flat, over `a`, `b`, `c`, in the order that faces
/// outward: counter-clockwise as seen from the side its own normal points
/// to.
fn push_face(vertices: &mut Vec<Vertex>, indices: &mut Vec<u32>, a: Vec3, b: Vec3, c: Vec3) {
    let normal = (b - a).cross(c - a).normalize();
    let uvs = [
        Vec2::new(0.0, 1.0),
        Vec2::new(0.5, 0.0),
        Vec2::new(1.0, 1.0),
    ];
    let base = vertices.len() as u32;
    for (point, uv) in [a, b, c].into_iter().zip(uvs) {
        vertices.push(Vertex::new(point, normal, uv));
    }
    indices.extend([base, base + 1, base + 2]);
}

/// An integer-hash of `seed` and `salt`.
fn hash(seed: u32, salt: u32) -> u32 {
    let mut x = seed ^ salt.wrapping_mul(0x9E37_79B9);
    x ^= x >> 16;
    x = x.wrapping_mul(0x7FEB_352D);
    x ^= x >> 15;
    x = x.wrapping_mul(0x846C_A68B);
    x ^= x >> 16;
    x
}

/// `hash`, scaled to `0.0..1.0`.
fn hash_unit(seed: u32, salt: u32) -> f32 {
    hash(seed, salt) as f32 / u32::MAX as f32
}

/// `hash`, scaled to `-1.0..1.0`.
fn hash_signed(seed: u32, salt: u32) -> f32 {
    hash_unit(seed, salt) * 2.0 - 1.0
}

impl Game for StressPreview {
    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<'_, Self>) {}

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.apply_settings();
        self.frame_times.record(ctx.dt());

        let elapsed = ctx.elapsed().as_secs_f32();
        self.handle_camera(ctx, elapsed);
        let camera = self.camera(elapsed);
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);

        let sun = Light::directional(SUN_DIRECTION, SUN_COLOR);
        ctx.light(if self.settings.sun_shadow {
            sun.shadow()
        } else {
            sun
        });

        Self::draw_ground(ctx);
        self.draw_field(ctx, elapsed);
        self.controls(ctx, &camera);
    }

examples/animation.rs (line 926)

    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 alpha(&self) -> f32

This frame’s position into the next simulation step, a fraction in 0.0..1.0; used to draw between two tick states.

Examples found in repository

examples/sprite-adventure.rs (line 1723)

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

examples/isometric-board.rs (line 584)

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

examples/sound-lab.rs (line 981)

    fn frame(&mut self, ctx: &mut FrameContext<'_, SoundCheck>) {
        ctx.set_volume(self.master_volume);

        let player = self.player_prev.lerp(self.player, ctx.alpha());
        let ear = Vec3::new(player.x, EYE_HEIGHT, player.y);
        let listener = View::look_at(ear, ear + Vec3::NEG_Z);
        ctx.set_listener(listener);

        ctx.set_camera(Self::camera(player));
        ctx.set_skybox(Sky::Room);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(Vec3::new(-0.4, -1.0, -0.5), SUN_COLOR).shadow());

        self.draw_room(ctx);
        self.draw_sources(ctx);
        self.draw_listener(ctx, listener);
        self.draw_merge_markers(ctx);
        self.draw_ring(ctx);

        self.sustain_cues(ctx);
        for (index, source) in self.sources.iter().enumerate() {
            if source.enabled {
                ctx.sustain(source.cue().instance(index as u32));
            }
        }
        if self.merge_demo {
            ctx.sustain(Sound::Click.at(MERGE_POS_A).gain(MERGE_GAIN));
            ctx.sustain(Sound::Click.at(MERGE_POS_B).gain(MERGE_GAIN));
        }
        self.sustain_ring(ctx);

        self.side_panel(ctx);
        let (play_once, play_many) = self.one_shot_panel(ctx);

        if play_once {
            ctx.play(self.one_shot_cue());
        }
        if play_many {
            for _ in 0..32 {
                ctx.play(self.one_shot_cue());
            }
        }
    }

examples/breakout-game.rs (line 1014)

    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/animation.rs (line 923)

    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 set_tick_interval(&mut self, interval: Duration)

Sets the simulated time every later tick covers, from the next frame on; held to at least Duration::from_micros(1).

Required if you want to pace the simulation against something outside the engine, such as a program on another machine. The ticks a frame already runs keep the step they started with.

pub fn close(&mut self)

Ends the run once this frame is drawn: what the frame saved is written, and no tick or frame runs after it.

On the desktop the window closes and run returns. In the browser there is no program to end: the loop stops, and the canvas the engine created is dropped from the page, while one the game named through Config::with_canvas_id stays as the page left it.

Examples found in repository

examples/breakout-game.rs (line 861)

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

pub fn set_camera(&mut self, camera: Camera)

Views the rest of the frame from camera. A later call in the same frame replaces this one; without any, Camera::default is used.

Examples found in repository

examples/post-effects.rs (lines 157-160)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        ctx.set_camera(Camera::new(
            View::look_at(Vec3::new(0.0, 3.4, 4.6), Vec3::new(0.0, 0.2, 0.0)),
            Projection::perspective(45.0),
        ));
        ctx.set_bloom(SCENE_BLOOM);

        self.draw_scene(ctx);
        self.panel(ctx);
    }

examples/material-playground.rs (line 1153)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.fly_camera(ctx);
        ctx.set_camera(self.camera());
        ctx.set_skybox(self.sky);
        for light in self.lights() {
            ctx.light(light);
        }
        ctx.set_exposure(self.exposure);
        ctx.set_bloom(self.bloom);

        self.draw_scene(ctx);
        self.controls(ctx);
    }

examples/flock-parallelism.rs (line 746)

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

        let center = Vec3::from(self.butterflies.center());
        let elapsed = ctx.elapsed().as_secs_f32();
        ctx.set_camera(Self::camera(center, self.world, elapsed));
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        Self::draw_ground(ctx);
        self.draw_butterflies(ctx);
        self.panel(ctx);
    }

examples/sprite-adventure.rs (line 1724)

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

examples/isometric-board.rs (line 821)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Board>) {
        let camera = Self::camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(Vec3::new(-0.35, -1.0, -0.5), SUN_COLOR).shadow());
        ctx.set_bloom(BLOOM);

        let hover = self.hovered(ctx);
        self.draw_ground(ctx);
        self.draw_board(ctx, hover);
        self.draw_current_mark(ctx);
        self.draw_rocks(ctx);
        self.draw_sprite(ctx, hover);
        self.draw_block(ctx, hover);
        self.draw_prompt(ctx, camera, hover);

        self.overlay(ctx);
    }

examples/stress-preview.rs (line 609)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.apply_settings();
        self.frame_times.record(ctx.dt());

        let elapsed = ctx.elapsed().as_secs_f32();
        self.handle_camera(ctx, elapsed);
        let camera = self.camera(elapsed);
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);

        let sun = Light::directional(SUN_DIRECTION, SUN_COLOR);
        ctx.light(if self.settings.sun_shadow {
            sun.shadow()
        } else {
            sun
        });

        Self::draw_ground(ctx);
        self.draw_field(ctx, elapsed);
        self.controls(ctx, &camera);
    }

Additional examples can be found in:

• examples/ui-fonts.rs
• examples/sound-lab.rs
• examples/breakout-game.rs
• examples/animation.rs

pub fn draw<M>(&mut self, instance: Instance<M, G::SurfaceStyles>)

where G::Meshes: Holds<M>,

Draws instance this frame. The engine decides the order and which draws share GPU work.

Takes a draw of a mesh of Game::Meshes and no other.

Examples found in repository

examples/stress-preview.rs (lines 396-400)

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

    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 661-669)

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

    /// Every butterfly at its own scale, turned to face its velocity, posed
    /// by the flap machine of its own group and tinted its own color.
    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/sprite-adventure.rs (lines 1239-1247)

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

examples/ui-fonts.rs (lines 671-678)

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

    fn draw_bracket(&self, ctx: &mut FrameContext<'_, Self>, camera: Camera, station: StationKind) {
        let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
        let window_size = ctx.window_size();
        let Some(pixel) = camera.pixel_of(top, window_size) else {
            return;
        };
        let at = logical(pixel, ctx.pixels_per_point());

        let name = ctx.text_layout(station.look().name, egui::FontId::proportional(BODY_SIZE));
        let (reading_text, number_text) = station.reading(self.elapsed.as_secs_f32());
        let reading = ctx.text_layout(&reading_text, egui::FontId::monospace(BODY_SIZE));
        let number = ctx.text_layout(
            &number_text,
            egui::FontId::new(NUMBER_SIZE, egui::FontFamily::Name(DISPLAY_FAMILY.into())),
        );

        ctx.ui(|ui| bracket(ui.painter(), at, name, reading, number));
    }

    /// A `Prompt` for `Trigger::Hail`, above every `StationKind` but
    /// `hovered`: what a player presses to reach one, apart from a hover.
    fn draw_prompts(
        &self,
        ctx: &mut FrameContext<'_, Self>,
        camera: Camera,
        hovered: Option<StationKind>,
    ) {
        let Some(binding) = ctx.bindings(Trigger::Hail).into_iter().next() else {
            return;
        };
        let hint = prompt(&binding);
        let glyph = ctx.text_layout(&hint.text(), egui::FontId::new(PROMPT_SIZE, hint.family()));
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();

        ctx.ui(|ui| {
            let painter = ui.painter();
            for station in StationKind::ALL {
                if Some(station) == hovered {
                    continue;
                }
                let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
                let Some(pixel) = camera.pixel_of(top, window_size) else {
                    continue;
                };
                let at = logical(pixel, pixels_per_point);
                let at = egui::pos2(at.x, at.y - PROMPT_LIFT);
                prompt_at(painter, at, glyph.clone());
            }
        });
    }

    /// The title, a line and the reading, each in a font this game loaded
    /// rather than egui's own.
    fn panel(&self, ctx: &mut FrameContext<'_, Self>) {
        ctx.ui(|ui| {
            ui.label(styled(
                "a game's own fonts",
                egui::FontId::proportional(HEADING_SIZE),
            ));
            ui.label(styled(
                "drawn in Pixel Operator, the game's proportional font",
                egui::FontId::proportional(BODY_SIZE),
            ));
            ui.label(styled(
                "the readings above each station in Pixel Operator Mono",
                egui::FontId::monospace(BODY_SIZE),
            ));
        });
    }

    fn draw_dialogue(&self, ctx: &mut FrameContext<'_, Self>) {
        let Some(dialogue) = &self.dialogue else {
            return;
        };
        let whole = ctx.text_layout(
            dialogue.current_line(),
            egui::FontId::proportional(BODY_SIZE),
        );
        let size = whole.size();
        ctx.ui(|ui| dialogue.draw(ui, size));
    }

    /// The `StationKind` under the pointer, `None` while the UI holds it.
    fn hovered(ctx: &FrameContext<'_, Self>) -> Option<StationKind> {
        if ctx.ui_wants_pointer() {
            return None;
        }
        hit_station(
            ctx.last_camera()
                .ray_through(ctx.pointer(), ctx.window_size()),
        )
    }

    /// A held [`Trigger::Hail`] turns the camera by the pointer's own
    /// motion; the wheel zooms it.
    fn steer(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Trigger::Hail) {
            self.orbit.turn(ctx.axis2(Turn::Look));
        }
        let wheel = ctx.axis(Zoom::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.orbit.zoom(ZOOM_STEP.powf(wheel));
        }
    }
}

impl Game for WatchRoom {
    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<'_, 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);
        }
    }

    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/post-effects.rs (lines 93-101)

    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 605-613)

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

Additional examples can be found in:

• examples/isometric-board.rs
• examples/sound-lab.rs
• examples/material-playground.rs
• examples/animation.rs

pub fn set_surface_style<T: SurfaceStyle>(&mut self, style: T)

where G::SurfaceStyles: Holds<T>,

Passes the style T the values its WGSL reads this frame; the last call for a style is the one it reads.

A frame that never calls this for a style leaves it reading the default value of every field. Takes a style of Game::SurfaceStyles and no other.

Examples found in repository

examples/sprite-adventure.rs (lines 1833-1835)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Keep>) {
        ctx.set_surface_style(Water {
            time: self.simulated.as_secs_f32(),
        });

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

        self.overlay(ctx);
    }

examples/material-playground.rs (line 974)

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

pub fn set_post_effect<T: PostEffect>(&mut self, effect: T)

where G::PostEffects: Holds<T>,

Runs the post effect T over this frame with the values its WGSL reads; the last call for an effect is the one it runs with.

A frame that never calls this for an effect runs no pass for it. Takes an effect of Game::PostEffects and no other.

Examples found in repository

examples/post-effects.rs (lines 131-133)

    fn panel(&mut self, ctx: &mut FrameContext<'_, Self>) {
        ctx.ui(|ui| {
            ui.add(egui::Slider::new(&mut self.vignette, 0.0..=1.0).text("vignette"));
            ui.add(egui::Slider::new(&mut self.grain, 0.0..=1.0).text("grain"));
            ui.add(egui::Slider::new(&mut self.scanlines, 0.0..=1.0).text("scanlines"));
        });

        ctx.set_post_effect(Vignette {
            strength: self.vignette,
        });
        ctx.set_post_effect(Grain {
            strength: self.grain,
            seed: self.ticks,
        });
        ctx.set_post_effect(Scanlines {
            strength: self.scanlines,
        });
    }

pub fn set_skybox(&mut self, sky: G::Skyboxes)

Draws and lights this frame by sky: what it draws where nothing else was drawn, and the ambient — the light every surface takes from every direction.

Takes a value of Game::Skyboxes and no other; startup built every one of them. The last call in a frame is the one it draws, and a frame that never calls this draws and is lit by the default sky.

Examples found in repository

examples/material-playground.rs (line 1154)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.fly_camera(ctx);
        ctx.set_camera(self.camera());
        ctx.set_skybox(self.sky);
        for light in self.lights() {
            ctx.light(light);
        }
        ctx.set_exposure(self.exposure);
        ctx.set_bloom(self.bloom);

        self.draw_scene(ctx);
        self.controls(ctx);
    }

examples/flock-parallelism.rs (line 747)

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

        let center = Vec3::from(self.butterflies.center());
        let elapsed = ctx.elapsed().as_secs_f32();
        ctx.set_camera(Self::camera(center, self.world, elapsed));
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        Self::draw_ground(ctx);
        self.draw_butterflies(ctx);
        self.panel(ctx);
    }

examples/isometric-board.rs (line 822)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Board>) {
        let camera = Self::camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(Vec3::new(-0.35, -1.0, -0.5), SUN_COLOR).shadow());
        ctx.set_bloom(BLOOM);

        let hover = self.hovered(ctx);
        self.draw_ground(ctx);
        self.draw_board(ctx, hover);
        self.draw_current_mark(ctx);
        self.draw_rocks(ctx);
        self.draw_sprite(ctx, hover);
        self.draw_block(ctx, hover);
        self.draw_prompt(ctx, camera, hover);

        self.overlay(ctx);
    }

examples/stress-preview.rs (line 610)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.apply_settings();
        self.frame_times.record(ctx.dt());

        let elapsed = ctx.elapsed().as_secs_f32();
        self.handle_camera(ctx, elapsed);
        let camera = self.camera(elapsed);
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);

        let sun = Light::directional(SUN_DIRECTION, SUN_COLOR);
        ctx.light(if self.settings.sun_shadow {
            sun.shadow()
        } else {
            sun
        });

        Self::draw_ground(ctx);
        self.draw_field(ctx, elapsed);
        self.controls(ctx, &camera);
    }

examples/ui-fonts.rs (line 821)

    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/sound-lab.rs (line 987)

    fn frame(&mut self, ctx: &mut FrameContext<'_, SoundCheck>) {
        ctx.set_volume(self.master_volume);

        let player = self.player_prev.lerp(self.player, ctx.alpha());
        let ear = Vec3::new(player.x, EYE_HEIGHT, player.y);
        let listener = View::look_at(ear, ear + Vec3::NEG_Z);
        ctx.set_listener(listener);

        ctx.set_camera(Self::camera(player));
        ctx.set_skybox(Sky::Room);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(Vec3::new(-0.4, -1.0, -0.5), SUN_COLOR).shadow());

        self.draw_room(ctx);
        self.draw_sources(ctx);
        self.draw_listener(ctx, listener);
        self.draw_merge_markers(ctx);
        self.draw_ring(ctx);

        self.sustain_cues(ctx);
        for (index, source) in self.sources.iter().enumerate() {
            if source.enabled {
                ctx.sustain(source.cue().instance(index as u32));
            }
        }
        if self.merge_demo {
            ctx.sustain(Sound::Click.at(MERGE_POS_A).gain(MERGE_GAIN));
            ctx.sustain(Sound::Click.at(MERGE_POS_B).gain(MERGE_GAIN));
        }
        self.sustain_ring(ctx);

        self.side_panel(ctx);
        let (play_once, play_many) = self.one_shot_panel(ctx);

        if play_once {
            ctx.play(self.one_shot_cue());
        }
        if play_many {
            for _ in 0..32 {
                ctx.play(self.one_shot_cue());
            }
        }
    }

Additional examples can be found in:

• examples/animation.rs

pub fn light(&mut self, light: Light)

Lights the frame with light, in addition to any already submitted.

The first call replaces the default environment’s light; past MAX_LIGHTS, excess is ignored — warned the first frame, a debug log after.

Examples found in repository

examples/material-playground.rs (line 1156)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.fly_camera(ctx);
        ctx.set_camera(self.camera());
        ctx.set_skybox(self.sky);
        for light in self.lights() {
            ctx.light(light);
        }
        ctx.set_exposure(self.exposure);
        ctx.set_bloom(self.bloom);

        self.draw_scene(ctx);
        self.controls(ctx);
    }

examples/flock-parallelism.rs (line 748)

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

        let center = Vec3::from(self.butterflies.center());
        let elapsed = ctx.elapsed().as_secs_f32();
        ctx.set_camera(Self::camera(center, self.world, elapsed));
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        Self::draw_ground(ctx);
        self.draw_butterflies(ctx);
        self.panel(ctx);
    }

examples/isometric-board.rs (line 823)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Board>) {
        let camera = Self::camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(Vec3::new(-0.35, -1.0, -0.5), SUN_COLOR).shadow());
        ctx.set_bloom(BLOOM);

        let hover = self.hovered(ctx);
        self.draw_ground(ctx);
        self.draw_board(ctx, hover);
        self.draw_current_mark(ctx);
        self.draw_rocks(ctx);
        self.draw_sprite(ctx, hover);
        self.draw_block(ctx, hover);
        self.draw_prompt(ctx, camera, hover);

        self.overlay(ctx);
    }

examples/stress-preview.rs (lines 613-617)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.apply_settings();
        self.frame_times.record(ctx.dt());

        let elapsed = ctx.elapsed().as_secs_f32();
        self.handle_camera(ctx, elapsed);
        let camera = self.camera(elapsed);
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);

        let sun = Light::directional(SUN_DIRECTION, SUN_COLOR);
        ctx.light(if self.settings.sun_shadow {
            sun.shadow()
        } else {
            sun
        });

        Self::draw_ground(ctx);
        self.draw_field(ctx, elapsed);
        self.controls(ctx, &camera);
    }

examples/post-effects.rs (line 91)

    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 (line 822)

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

Additional examples can be found in:

• examples/sound-lab.rs
• examples/sprite-adventure.rs
• examples/breakout-game.rs
• examples/animation.rs

pub fn set_exposure(&mut self, exposure: f32)

Scales the frame’s light before the curve, as a fraction of it; a value under 0.0 is clamped to it, and 1.0 is used where a frame never calls this.

The last call in a frame replaces the rest.

Examples found in repository

examples/material-playground.rs (line 1158)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.fly_camera(ctx);
        ctx.set_camera(self.camera());
        ctx.set_skybox(self.sky);
        for light in self.lights() {
            ctx.light(light);
        }
        ctx.set_exposure(self.exposure);
        ctx.set_bloom(self.bloom);

        self.draw_scene(ctx);
        self.controls(ctx);
    }

examples/breakout-game.rs (line 1009)

    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/animation.rs (line 936)

    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 set_bloom(&mut self, amount: f32)

Spreads the frame’s brightest light over what is around it; the value is clamped into 0.0..=1.0, and 0.0 is used where a frame never calls this.

The value is the fraction of the frame the spread replaces, and 0.0 is no work at all. The last call in a frame replaces the rest.

Examples found in repository

examples/post-effects.rs (line 161)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        ctx.set_camera(Camera::new(
            View::look_at(Vec3::new(0.0, 3.4, 4.6), Vec3::new(0.0, 0.2, 0.0)),
            Projection::perspective(45.0),
        ));
        ctx.set_bloom(SCENE_BLOOM);

        self.draw_scene(ctx);
        self.panel(ctx);
    }

examples/material-playground.rs (line 1159)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.fly_camera(ctx);
        ctx.set_camera(self.camera());
        ctx.set_skybox(self.sky);
        for light in self.lights() {
            ctx.light(light);
        }
        ctx.set_exposure(self.exposure);
        ctx.set_bloom(self.bloom);

        self.draw_scene(ctx);
        self.controls(ctx);
    }

examples/isometric-board.rs (line 824)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Board>) {
        let camera = Self::camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(Vec3::new(-0.35, -1.0, -0.5), SUN_COLOR).shadow());
        ctx.set_bloom(BLOOM);

        let hover = self.hovered(ctx);
        self.draw_ground(ctx);
        self.draw_board(ctx, hover);
        self.draw_current_mark(ctx);
        self.draw_rocks(ctx);
        self.draw_sprite(ctx, hover);
        self.draw_block(ctx, hover);
        self.draw_prompt(ctx, camera, hover);

        self.overlay(ctx);
    }

examples/sound-lab.rs (line 988)

    fn frame(&mut self, ctx: &mut FrameContext<'_, SoundCheck>) {
        ctx.set_volume(self.master_volume);

        let player = self.player_prev.lerp(self.player, ctx.alpha());
        let ear = Vec3::new(player.x, EYE_HEIGHT, player.y);
        let listener = View::look_at(ear, ear + Vec3::NEG_Z);
        ctx.set_listener(listener);

        ctx.set_camera(Self::camera(player));
        ctx.set_skybox(Sky::Room);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(Vec3::new(-0.4, -1.0, -0.5), SUN_COLOR).shadow());

        self.draw_room(ctx);
        self.draw_sources(ctx);
        self.draw_listener(ctx, listener);
        self.draw_merge_markers(ctx);
        self.draw_ring(ctx);

        self.sustain_cues(ctx);
        for (index, source) in self.sources.iter().enumerate() {
            if source.enabled {
                ctx.sustain(source.cue().instance(index as u32));
            }
        }
        if self.merge_demo {
            ctx.sustain(Sound::Click.at(MERGE_POS_A).gain(MERGE_GAIN));
            ctx.sustain(Sound::Click.at(MERGE_POS_B).gain(MERGE_GAIN));
        }
        self.sustain_ring(ctx);

        self.side_panel(ctx);
        let (play_once, play_many) = self.one_shot_panel(ctx);

        if play_once {
            ctx.play(self.one_shot_cue());
        }
        if play_many {
            for _ in 0..32 {
                ctx.play(self.one_shot_cue());
            }
        }
    }

examples/breakout-game.rs (line 1006)

    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/animation.rs (line 937)

    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 play(&mut self, sound: impl Into<SoundCue<G::Sounds>>)

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

Every call is a voice of its own, so the same sound twice over is heard twice.

Examples found in repository

examples/sound-lab.rs (line 1013)

    fn frame(&mut self, ctx: &mut FrameContext<'_, SoundCheck>) {
        ctx.set_volume(self.master_volume);

        let player = self.player_prev.lerp(self.player, ctx.alpha());
        let ear = Vec3::new(player.x, EYE_HEIGHT, player.y);
        let listener = View::look_at(ear, ear + Vec3::NEG_Z);
        ctx.set_listener(listener);

        ctx.set_camera(Self::camera(player));
        ctx.set_skybox(Sky::Room);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(Vec3::new(-0.4, -1.0, -0.5), SUN_COLOR).shadow());

        self.draw_room(ctx);
        self.draw_sources(ctx);
        self.draw_listener(ctx, listener);
        self.draw_merge_markers(ctx);
        self.draw_ring(ctx);

        self.sustain_cues(ctx);
        for (index, source) in self.sources.iter().enumerate() {
            if source.enabled {
                ctx.sustain(source.cue().instance(index as u32));
            }
        }
        if self.merge_demo {
            ctx.sustain(Sound::Click.at(MERGE_POS_A).gain(MERGE_GAIN));
            ctx.sustain(Sound::Click.at(MERGE_POS_B).gain(MERGE_GAIN));
        }
        self.sustain_ring(ctx);

        self.side_panel(ctx);
        let (play_once, play_many) = self.one_shot_panel(ctx);

        if play_once {
            ctx.play(self.one_shot_cue());
        }
        if play_many {
            for _ in 0..32 {
                ctx.play(self.one_shot_cue());
            }
        }
    }

examples/breakout-game.rs (line 858)

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

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

Keeps sound playing while frames go on declaring it, and fades it out over its fade once one does not.

What a frame declares is the whole of what it wants sounding. One voice per value, whose knobs follow what each frame declares; the last call for a value in a frame is the one that counts. A value a frame stops declaring is dropped once it has faded, so declaring it again after that starts it at its window start.

Examples found in repository

examples/sound-lab.rs (lines 842-849)

    fn sustain_ring(&self, ctx: &mut FrameContext<'_, SoundCheck>) {
        if !self.ring_demo {
            return;
        }
        for nth in 0..RING_COUNT {
            let gain = RING_GAIN * (1.0 - nth as f32 / RING_COUNT as f32);
            ctx.sustain(
                Sound::Pulse
                    .at(ring_place(nth))
                    .gain(gain)
                    .reference(RING_REFERENCE)
                    .range(RING_RADIUS * 3.0)
                    .instance(nth + 1),
            );
        }
    }

    fn sustain_cues(&self, ctx: &mut FrameContext<'_, SoundCheck>) {
        let fade = Duration::from_secs_f32(self.cue_fade);
        if self.theme_on {
            ctx.sustain(Sound::Theme.gain(0.5).fade(fade));
        }
        if self.menu_on {
            ctx.sustain(Sound::MenuTheme.gain(0.5).fade(fade));
        }
        if self.pulse_on {
            ctx.sustain(Sound::Pulse.gain(0.3).fade(fade));
        }
    }
}

/// Where the `nth` sustain of the ring stands: around the room, starting
/// behind the listener's back.
fn ring_place(nth: u32) -> Vec3 {
    let turn = TAU * nth as f32 / RING_COUNT as f32;

    Vec3::new(
        turn.sin() * RING_RADIUS,
        SOURCE_HEIGHT,
        turn.cos() * RING_RADIUS,
    )
}

/// The direction the ear pair is offset along — the same side the
/// engine's own pan reads.
fn listener_right(view: View) -> Vec3 {
    (view.target() - view.eye())
        .normalize_or_zero()
        .cross(view.up())
}

/// The clip's duration, with two trim handles and a loop marker, each moved
/// by the pointer's own place rather than by a moving total.
fn duration_bar(
    ui: &mut egui::Ui,
    duration: f32,
    trim_start: &mut f32,
    trim_end: &mut f32,
    loop_from: &mut f32,
) {
    let size = egui::vec2(ui.available_width().min(420.0), 28.0);
    let (rect, _response) = ui.allocate_exact_size(size, egui::Sense::hover());
    let painter = ui.painter();
    painter.rect_filled(rect, 3.0, egui::Color32::from_gray(35));

    let x_of = |seconds: f32| rect.left() + (seconds / duration).clamp(0.0, 1.0) * rect.width();
    let seconds_of = |x: f32| ((x - rect.left()) / rect.width()).clamp(0.0, 1.0) * duration;

    let span = egui::Rect::from_min_max(
        egui::pos2(x_of(*trim_start), rect.top()),
        egui::pos2(x_of(*trim_end), rect.bottom()),
    );
    painter.rect_filled(span, 3.0, egui::Color32::from_rgb(70, 120, 95));

    let start_x = x_of(*trim_start);
    if let Some(x) = drag_handle(
        ui,
        rect,
        "trim-start",
        start_x,
        egui::Color32::from_rgb(230, 200, 80),
    ) {
        *trim_start = seconds_of(x).min(*trim_end);
    }
    let end_x = x_of(*trim_end);
    if let Some(x) = drag_handle(
        ui,
        rect,
        "trim-end",
        end_x,
        egui::Color32::from_rgb(230, 200, 80),
    ) {
        *trim_end = seconds_of(x).max(*trim_start);
    }
    let loop_x = x_of(*loop_from);
    if let Some(x) = drag_handle(
        ui,
        rect,
        "loop-from",
        loop_x,
        egui::Color32::from_rgb(90, 170, 230),
    ) {
        *loop_from = seconds_of(x).clamp(*trim_start, *trim_end);
    }
}

/// One round handle at `x`. Returns the pointer's `x` while a drag holds
/// it.
fn drag_handle(
    ui: &mut egui::Ui,
    bar: egui::Rect,
    salt: &str,
    x: f32,
    color: egui::Color32,
) -> Option<f32> {
    let radius = 6.0;
    let center = egui::pos2(x, bar.center().y);
    let sense_rect = egui::Rect::from_center_size(center, egui::Vec2::splat(radius * 2.5));
    let id = ui.id().with(salt);
    let response = ui.interact(sense_rect, id, egui::Sense::drag());
    ui.painter().circle_filled(center, radius, color);

    response
        .dragged()
        .then(|| response.interact_pointer_pos())
        .flatten()
        .map(|pos| pos.x)
}

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

    fn tick(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        self.handle_walk(ctx);
        self.handle_drag(ctx);
    }

    fn frame(&mut self, ctx: &mut FrameContext<'_, SoundCheck>) {
        ctx.set_volume(self.master_volume);

        let player = self.player_prev.lerp(self.player, ctx.alpha());
        let ear = Vec3::new(player.x, EYE_HEIGHT, player.y);
        let listener = View::look_at(ear, ear + Vec3::NEG_Z);
        ctx.set_listener(listener);

        ctx.set_camera(Self::camera(player));
        ctx.set_skybox(Sky::Room);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(Vec3::new(-0.4, -1.0, -0.5), SUN_COLOR).shadow());

        self.draw_room(ctx);
        self.draw_sources(ctx);
        self.draw_listener(ctx, listener);
        self.draw_merge_markers(ctx);
        self.draw_ring(ctx);

        self.sustain_cues(ctx);
        for (index, source) in self.sources.iter().enumerate() {
            if source.enabled {
                ctx.sustain(source.cue().instance(index as u32));
            }
        }
        if self.merge_demo {
            ctx.sustain(Sound::Click.at(MERGE_POS_A).gain(MERGE_GAIN));
            ctx.sustain(Sound::Click.at(MERGE_POS_B).gain(MERGE_GAIN));
        }
        self.sustain_ring(ctx);

        self.side_panel(ctx);
        let (play_once, play_many) = self.one_shot_panel(ctx);

        if play_once {
            ctx.play(self.one_shot_cue());
        }
        if play_many {
            for _ in 0..32 {
                ctx.play(self.one_shot_cue());
            }
        }
    }

examples/breakout-game.rs (lines 879-885)

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

pub fn set_listener(&mut self, listener: View)

Hears the frame from listener, in place of the frame’s camera.

Examples found in repository

examples/sound-lab.rs (line 984)

    fn frame(&mut self, ctx: &mut FrameContext<'_, SoundCheck>) {
        ctx.set_volume(self.master_volume);

        let player = self.player_prev.lerp(self.player, ctx.alpha());
        let ear = Vec3::new(player.x, EYE_HEIGHT, player.y);
        let listener = View::look_at(ear, ear + Vec3::NEG_Z);
        ctx.set_listener(listener);

        ctx.set_camera(Self::camera(player));
        ctx.set_skybox(Sky::Room);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(Vec3::new(-0.4, -1.0, -0.5), SUN_COLOR).shadow());

        self.draw_room(ctx);
        self.draw_sources(ctx);
        self.draw_listener(ctx, listener);
        self.draw_merge_markers(ctx);
        self.draw_ring(ctx);

        self.sustain_cues(ctx);
        for (index, source) in self.sources.iter().enumerate() {
            if source.enabled {
                ctx.sustain(source.cue().instance(index as u32));
            }
        }
        if self.merge_demo {
            ctx.sustain(Sound::Click.at(MERGE_POS_A).gain(MERGE_GAIN));
            ctx.sustain(Sound::Click.at(MERGE_POS_B).gain(MERGE_GAIN));
        }
        self.sustain_ring(ctx);

        self.side_panel(ctx);
        let (play_once, play_many) = self.one_shot_panel(ctx);

        if play_once {
            ctx.play(self.one_shot_cue());
        }
        if play_many {
            for _ in 0..32 {
                ctx.play(self.one_shot_cue());
            }
        }
    }

pub fn set_volume(&mut self, volume: f32)

Plays everything this frame at volume, the fraction of each sound’s own gain it multiplies; 1.0 where a frame never calls this.

The mix slides to it over SoundCue::DEFAULT_GLIDE, so a slider a player moves never steps the sound.

Examples found in repository

examples/sound-lab.rs (line 979)

    fn frame(&mut self, ctx: &mut FrameContext<'_, SoundCheck>) {
        ctx.set_volume(self.master_volume);

        let player = self.player_prev.lerp(self.player, ctx.alpha());
        let ear = Vec3::new(player.x, EYE_HEIGHT, player.y);
        let listener = View::look_at(ear, ear + Vec3::NEG_Z);
        ctx.set_listener(listener);

        ctx.set_camera(Self::camera(player));
        ctx.set_skybox(Sky::Room);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(Vec3::new(-0.4, -1.0, -0.5), SUN_COLOR).shadow());

        self.draw_room(ctx);
        self.draw_sources(ctx);
        self.draw_listener(ctx, listener);
        self.draw_merge_markers(ctx);
        self.draw_ring(ctx);

        self.sustain_cues(ctx);
        for (index, source) in self.sources.iter().enumerate() {
            if source.enabled {
                ctx.sustain(source.cue().instance(index as u32));
            }
        }
        if self.merge_demo {
            ctx.sustain(Sound::Click.at(MERGE_POS_A).gain(MERGE_GAIN));
            ctx.sustain(Sound::Click.at(MERGE_POS_B).gain(MERGE_GAIN));
        }
        self.sustain_ring(ctx);

        self.side_panel(ctx);
        let (play_once, play_many) = self.one_shot_panel(ctx);

        if play_once {
            ctx.play(self.one_shot_cue());
        }
        if play_many {
            for _ in 0..32 {
                ctx.play(self.one_shot_cue());
            }
        }
    }

examples/breakout-game.rs (line 1000)

    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 sound_unlocked(&self) -> bool

Whether the platform allows sound to start right now.

True from the first frame on the desktop, with or without an audio device: what holds it false is the browser, which plays nothing until the player has done something. A one-shot played while it is false is dropped; a sustain declared then starts when it turns true.

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 is drawn, and only where a value changed, so saving every frame costs nothing.

pub fn ui(&mut self, build: impl FnOnce(&mut Ui))

Builds this frame’s UI, drawn over the scene.

Calls append to one layer, which is placed 8 points clear of the window’s edges; floating windows go through ui.ctx(), and egui::Panel::left and the three beside it hold a panel against one side of that layer, shown in the ui this call takes.

Examples found in repository

examples/isometric-board.rs (lines 644-654)

    fn overlay(&self, ctx: &mut FrameContext<'_, Board>) {
        ctx.ui(|ui| {
            ui.label(match self.turn {
                Turn::Sprite => "the sprite unit's turn",
                Turn::Block => "the block unit's turn",
            });
            ui.label(if self.selected {
                "click a marked tile to order the move"
            } else {
                "click the glowing unit to select it"
            });
        });
    }

    /// What a click at `hover` does, named for the player; `None` where a
    /// click has no effect.
    fn click_effect(&self, hover: Hover) -> Option<&'static str> {
        match hover {
            Hover::CurrentUnit if self.selected => Some("deselect"),
            Hover::CurrentUnit => Some("select"),
            Hover::Tile(tile) if self.selected && self.reachable(tile) => Some("move here"),
            Hover::Tile(_) if self.selected => Some("occupied"),
            _ => None,
        }
    }

    /// A prompt beside the pointer's target, naming what its click does;
    /// absent where [`Self::click_effect`] reads no effect.
    fn draw_prompt(&self, ctx: &mut FrameContext<'_, Board>, camera: Camera, hover: Hover) {
        let Some(text) = self.click_effect(hover) else {
            return;
        };
        let point = match hover {
            Hover::CurrentUnit => {
                let (lift, _) = unit_geometry(self.turn);
                self.current().position + Vec3::Y * (lift * 2.0 + PROMPT_UNIT_LIFT)
            }
            Hover::Tile(tile) => tile_center(tile) + Vec3::Y * PROMPT_TILE_LIFT,
            Hover::None => return,
        };
        let galley = ctx.text_layout(text, egui::FontId::proportional(PROMPT_SIZE));
        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;
        };
        let at = logical(pixel, pixels_per_point);
        ctx.ui(|ui| {
            let painter = ui.painter();
            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(PROMPT_BACKDROP),
            );
            painter.galley(pos, galley, PROMPT_TEXT_COLOR);
        });
    }

examples/post-effects.rs (lines 125-129)

    fn panel(&mut self, ctx: &mut FrameContext<'_, Self>) {
        ctx.ui(|ui| {
            ui.add(egui::Slider::new(&mut self.vignette, 0.0..=1.0).text("vignette"));
            ui.add(egui::Slider::new(&mut self.grain, 0.0..=1.0).text("grain"));
            ui.add(egui::Slider::new(&mut self.scanlines, 0.0..=1.0).text("scanlines"));
        });

        ctx.set_post_effect(Vignette {
            strength: self.vignette,
        });
        ctx.set_post_effect(Grain {
            strength: self.grain,
            seed: self.ticks,
        });
        ctx.set_post_effect(Scanlines {
            strength: self.scanlines,
        });
    }

examples/ui-fonts.rs (line 698)

    fn draw_bracket(&self, ctx: &mut FrameContext<'_, Self>, camera: Camera, station: StationKind) {
        let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
        let window_size = ctx.window_size();
        let Some(pixel) = camera.pixel_of(top, window_size) else {
            return;
        };
        let at = logical(pixel, ctx.pixels_per_point());

        let name = ctx.text_layout(station.look().name, egui::FontId::proportional(BODY_SIZE));
        let (reading_text, number_text) = station.reading(self.elapsed.as_secs_f32());
        let reading = ctx.text_layout(&reading_text, egui::FontId::monospace(BODY_SIZE));
        let number = ctx.text_layout(
            &number_text,
            egui::FontId::new(NUMBER_SIZE, egui::FontFamily::Name(DISPLAY_FAMILY.into())),
        );

        ctx.ui(|ui| bracket(ui.painter(), at, name, reading, number));
    }

    /// A `Prompt` for `Trigger::Hail`, above every `StationKind` but
    /// `hovered`: what a player presses to reach one, apart from a hover.
    fn draw_prompts(
        &self,
        ctx: &mut FrameContext<'_, Self>,
        camera: Camera,
        hovered: Option<StationKind>,
    ) {
        let Some(binding) = ctx.bindings(Trigger::Hail).into_iter().next() else {
            return;
        };
        let hint = prompt(&binding);
        let glyph = ctx.text_layout(&hint.text(), egui::FontId::new(PROMPT_SIZE, hint.family()));
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();

        ctx.ui(|ui| {
            let painter = ui.painter();
            for station in StationKind::ALL {
                if Some(station) == hovered {
                    continue;
                }
                let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
                let Some(pixel) = camera.pixel_of(top, window_size) else {
                    continue;
                };
                let at = logical(pixel, pixels_per_point);
                let at = egui::pos2(at.x, at.y - PROMPT_LIFT);
                prompt_at(painter, at, glyph.clone());
            }
        });
    }

    /// The title, a line and the reading, each in a font this game loaded
    /// rather than egui's own.
    fn panel(&self, ctx: &mut FrameContext<'_, Self>) {
        ctx.ui(|ui| {
            ui.label(styled(
                "a game's own fonts",
                egui::FontId::proportional(HEADING_SIZE),
            ));
            ui.label(styled(
                "drawn in Pixel Operator, the game's proportional font",
                egui::FontId::proportional(BODY_SIZE),
            ));
            ui.label(styled(
                "the readings above each station in Pixel Operator Mono",
                egui::FontId::monospace(BODY_SIZE),
            ));
        });
    }

    fn draw_dialogue(&self, ctx: &mut FrameContext<'_, Self>) {
        let Some(dialogue) = &self.dialogue else {
            return;
        };
        let whole = ctx.text_layout(
            dialogue.current_line(),
            egui::FontId::proportional(BODY_SIZE),
        );
        let size = whole.size();
        ctx.ui(|ui| dialogue.draw(ui, size));
    }

    /// The `StationKind` under the pointer, `None` while the UI holds it.
    fn hovered(ctx: &FrameContext<'_, Self>) -> Option<StationKind> {
        if ctx.ui_wants_pointer() {
            return None;
        }
        hit_station(
            ctx.last_camera()
                .ray_through(ctx.pointer(), ctx.window_size()),
        )
    }

    /// A held [`Trigger::Hail`] turns the camera by the pointer's own
    /// motion; the wheel zooms it.
    fn steer(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Trigger::Hail) {
            self.orbit.turn(ctx.axis2(Turn::Look));
        }
        let wheel = ctx.axis(Zoom::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.orbit.zoom(ZOOM_STEP.powf(wheel));
        }
    }
}

impl Game for WatchRoom {
    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<'_, 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);
        }
    }

    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/flock-parallelism.rs (lines 696-716)

    fn panel(&mut self, ctx: &mut FrameContext<'_, Self>) {
        let workers = rayon::current_num_threads();
        let tick_ms = self.last_tick_ms;

        ctx.ui(|ui| {
            egui::Frame::new()
                .fill(egui::Color32::from_gray(24))
                .inner_margin(PANEL_PADDING)
                .corner_radius(f32::from(PANEL_PADDING))
                .show(ui, |ui| {
                    ui.label(format!("workers {workers}"));
                    ui.horizontal(|ui| {
                        for size in FLOCK_SIZES {
                            ui.radio_value(
                                &mut self.settings.flock_size,
                                size,
                                format!("{size} butterflies"),
                            );
                        }
                    });
                    ui.checkbox(&mut self.settings.sequential, "sequential update");
                    ui.separator();
                    ui.label(format!("tick time {tick_ms:.2}ms"));
                });
        });
    }

examples/breakout-game.rs (lines 746-755)

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

examples/sprite-adventure.rs (lines 1657-1672)

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

Additional examples can be found in:

• examples/material-playground.rs
• examples/animation.rs
• examples/stress-preview.rs
• examples/sound-lab.rs
• examples/input-lab.rs

pub fn pixels_per_point(&self) -> f32

Physical pixels per logical point of the UI this frame, a fraction over 1.0 on a dense screen: what a pixel Camera::pixel_of returns is divided by before the UI draws at it.

Examples found in repository

examples/ui-fonts.rs (line 688)

    fn draw_bracket(&self, ctx: &mut FrameContext<'_, Self>, camera: Camera, station: StationKind) {
        let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
        let window_size = ctx.window_size();
        let Some(pixel) = camera.pixel_of(top, window_size) else {
            return;
        };
        let at = logical(pixel, ctx.pixels_per_point());

        let name = ctx.text_layout(station.look().name, egui::FontId::proportional(BODY_SIZE));
        let (reading_text, number_text) = station.reading(self.elapsed.as_secs_f32());
        let reading = ctx.text_layout(&reading_text, egui::FontId::monospace(BODY_SIZE));
        let number = ctx.text_layout(
            &number_text,
            egui::FontId::new(NUMBER_SIZE, egui::FontFamily::Name(DISPLAY_FAMILY.into())),
        );

        ctx.ui(|ui| bracket(ui.painter(), at, name, reading, number));
    }

    /// A `Prompt` for `Trigger::Hail`, above every `StationKind` but
    /// `hovered`: what a player presses to reach one, apart from a hover.
    fn draw_prompts(
        &self,
        ctx: &mut FrameContext<'_, Self>,
        camera: Camera,
        hovered: Option<StationKind>,
    ) {
        let Some(binding) = ctx.bindings(Trigger::Hail).into_iter().next() else {
            return;
        };
        let hint = prompt(&binding);
        let glyph = ctx.text_layout(&hint.text(), egui::FontId::new(PROMPT_SIZE, hint.family()));
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();

        ctx.ui(|ui| {
            let painter = ui.painter();
            for station in StationKind::ALL {
                if Some(station) == hovered {
                    continue;
                }
                let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
                let Some(pixel) = camera.pixel_of(top, window_size) else {
                    continue;
                };
                let at = logical(pixel, pixels_per_point);
                let at = egui::pos2(at.x, at.y - PROMPT_LIFT);
                prompt_at(painter, at, glyph.clone());
            }
        });
    }

examples/sprite-adventure.rs (line 1652)

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

examples/isometric-board.rs (line 685)

    fn draw_prompt(&self, ctx: &mut FrameContext<'_, Board>, camera: Camera, hover: Hover) {
        let Some(text) = self.click_effect(hover) else {
            return;
        };
        let point = match hover {
            Hover::CurrentUnit => {
                let (lift, _) = unit_geometry(self.turn);
                self.current().position + Vec3::Y * (lift * 2.0 + PROMPT_UNIT_LIFT)
            }
            Hover::Tile(tile) => tile_center(tile) + Vec3::Y * PROMPT_TILE_LIFT,
            Hover::None => return,
        };
        let galley = ctx.text_layout(text, egui::FontId::proportional(PROMPT_SIZE));
        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;
        };
        let at = logical(pixel, pixels_per_point);
        ctx.ui(|ui| {
            let painter = ui.painter();
            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(PROMPT_BACKDROP),
            );
            painter.galley(pos, galley, PROMPT_TEXT_COLOR);
        });
    }

examples/animation.rs (line 849)

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

pub fn text_layout(&self, text: &str, font: FontId) -> Arc<Galley>

text laid out in font at no width, so a row ends only where a \n starts the next one.

Required if you want to size or place what you draw against text: a box a name has to fit in, a line as wide as the word over it. Its size() is the width and the height the text takes, in logical points. One kept past a change of pixels_per_point still reports the size the frame that laid it out measured. The ui feature’s own.

Examples found in repository

examples/ui-fonts.rs (line 690)

    fn draw_bracket(&self, ctx: &mut FrameContext<'_, Self>, camera: Camera, station: StationKind) {
        let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
        let window_size = ctx.window_size();
        let Some(pixel) = camera.pixel_of(top, window_size) else {
            return;
        };
        let at = logical(pixel, ctx.pixels_per_point());

        let name = ctx.text_layout(station.look().name, egui::FontId::proportional(BODY_SIZE));
        let (reading_text, number_text) = station.reading(self.elapsed.as_secs_f32());
        let reading = ctx.text_layout(&reading_text, egui::FontId::monospace(BODY_SIZE));
        let number = ctx.text_layout(
            &number_text,
            egui::FontId::new(NUMBER_SIZE, egui::FontFamily::Name(DISPLAY_FAMILY.into())),
        );

        ctx.ui(|ui| bracket(ui.painter(), at, name, reading, number));
    }

    /// A `Prompt` for `Trigger::Hail`, above every `StationKind` but
    /// `hovered`: what a player presses to reach one, apart from a hover.
    fn draw_prompts(
        &self,
        ctx: &mut FrameContext<'_, Self>,
        camera: Camera,
        hovered: Option<StationKind>,
    ) {
        let Some(binding) = ctx.bindings(Trigger::Hail).into_iter().next() else {
            return;
        };
        let hint = prompt(&binding);
        let glyph = ctx.text_layout(&hint.text(), egui::FontId::new(PROMPT_SIZE, hint.family()));
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();

        ctx.ui(|ui| {
            let painter = ui.painter();
            for station in StationKind::ALL {
                if Some(station) == hovered {
                    continue;
                }
                let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
                let Some(pixel) = camera.pixel_of(top, window_size) else {
                    continue;
                };
                let at = logical(pixel, pixels_per_point);
                let at = egui::pos2(at.x, at.y - PROMPT_LIFT);
                prompt_at(painter, at, glyph.clone());
            }
        });
    }

    /// The title, a line and the reading, each in a font this game loaded
    /// rather than egui's own.
    fn panel(&self, ctx: &mut FrameContext<'_, Self>) {
        ctx.ui(|ui| {
            ui.label(styled(
                "a game's own fonts",
                egui::FontId::proportional(HEADING_SIZE),
            ));
            ui.label(styled(
                "drawn in Pixel Operator, the game's proportional font",
                egui::FontId::proportional(BODY_SIZE),
            ));
            ui.label(styled(
                "the readings above each station in Pixel Operator Mono",
                egui::FontId::monospace(BODY_SIZE),
            ));
        });
    }

    fn draw_dialogue(&self, ctx: &mut FrameContext<'_, Self>) {
        let Some(dialogue) = &self.dialogue else {
            return;
        };
        let whole = ctx.text_layout(
            dialogue.current_line(),
            egui::FontId::proportional(BODY_SIZE),
        );
        let size = whole.size();
        ctx.ui(|ui| dialogue.draw(ui, size));
    }

examples/sprite-adventure.rs (line 1649)

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

examples/isometric-board.rs (line 683)

    fn draw_prompt(&self, ctx: &mut FrameContext<'_, Board>, camera: Camera, hover: Hover) {
        let Some(text) = self.click_effect(hover) else {
            return;
        };
        let point = match hover {
            Hover::CurrentUnit => {
                let (lift, _) = unit_geometry(self.turn);
                self.current().position + Vec3::Y * (lift * 2.0 + PROMPT_UNIT_LIFT)
            }
            Hover::Tile(tile) => tile_center(tile) + Vec3::Y * PROMPT_TILE_LIFT,
            Hover::None => return,
        };
        let galley = ctx.text_layout(text, egui::FontId::proportional(PROMPT_SIZE));
        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;
        };
        let at = logical(pixel, pixels_per_point);
        ctx.ui(|ui| {
            let painter = ui.painter();
            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(PROMPT_BACKDROP),
            );
            painter.galley(pos, galley, PROMPT_TEXT_COLOR);
        });
    }

examples/animation.rs (lines 829-832)

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

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 767)

    fn hovered(ctx: &FrameContext<'_, Self>) -> Option<StationKind> {
        if ctx.ui_wants_pointer() {
            return None;
        }
        hit_station(
            ctx.last_camera()
                .ray_through(ctx.pointer(), ctx.window_size()),
        )
    }

    /// A held [`Trigger::Hail`] turns the camera by the pointer's own
    /// motion; the wheel zooms it.
    fn steer(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Trigger::Hail) {
            self.orbit.turn(ctx.axis2(Turn::Look));
        }
        let wheel = ctx.axis(Zoom::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.orbit.zoom(ZOOM_STEP.powf(wheel));
        }
    }

examples/isometric-board.rs (line 460)

    fn hovered(&self, ctx: &FrameContext<'_, Board>) -> Hover {
        if ctx.ui_wants_pointer() {
            return Hover::None;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if self.current().target.is_none() {
            let (_, half) = unit_geometry(self.turn);
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                return Hover::CurrentUnit;
            }
        }
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return Hover::None;
        };
        match tile_at(ray.at(distance)) {
            Some(tile) => Hover::Tile(tile),
            None => Hover::None,
        }
    }

examples/stress-preview.rs (line 360)

    fn handle_camera(&mut self, ctx: &mut FrameContext<'_, Self>, elapsed: f32) {
        if ctx.ui_wants_pointer() || ctx.ui_wants_keyboard() {
            return;
        }
        let pan = ctx.axis2(Motion::Pan);
        let wheel = ctx.axis(Height::Wheel);
        let look = if ctx.down(Drag::Turn) {
            ctx.axis2(Motion::Look)
        } else {
            Vec2::ZERO
        };
        if pan == Vec2::ZERO && wheel == 0.0 && look == Vec2::ZERO {
            return;
        }

        let player = self.player.get_or_insert_with(|| {
            let eye = Self::orbit_eye(elapsed);
            let forward = (Vec3::ZERO - eye).normalize();
            Player {
                eye,
                yaw: (-forward.x).atan2(-forward.z),
                pitch: forward.y.asin(),
            }
        });

        player.yaw -= look.x;
        player.pitch = (player.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);

        let forward = Vec3::new(-player.yaw.sin(), 0.0, -player.yaw.cos());
        let right = Vec3::new(player.yaw.cos(), 0.0, -player.yaw.sin());
        player.eye += (forward * pan.y + right * pan.x) * PAN_SPEED * ctx.dt().as_secs_f32();
        player.eye.y =
            (player.eye.y + wheel * WHEEL_STEP).clamp(MIN_CAMERA_HEIGHT, MAX_CAMERA_HEIGHT);
    }

examples/material-playground.rs (line 803)

    fn fly_camera(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Move::Look) {
            let look = ctx.axis2(Turn::Look);
            self.yaw -= look.x;
            self.pitch = (self.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);
        }

        let wheel = ctx.axis(Speed::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.speed_scale =
                (self.speed_scale * SPEED_STEP.powf(wheel)).clamp(MIN_SPEED_SCALE, MAX_SPEED_SCALE);
        }

        let forward = self.forward();
        let right = Vec3::new(self.yaw.cos(), 0.0, -self.yaw.sin());
        let mut move_by = Vec3::ZERO;
        if ctx.down(Move::Forward) {
            move_by += forward;
        }
        if ctx.down(Move::Back) {
            move_by -= forward;
        }
        if ctx.down(Move::Right) {
            move_by += right;
        }
        if ctx.down(Move::Left) {
            move_by -= right;
        }
        if ctx.down(Move::Up) {
            move_by += Vec3::Y;
        }
        if ctx.down(Move::Down) {
            move_by -= Vec3::Y;
        }
        if move_by.length_squared() > 1.0 {
            move_by = move_by.normalize();
        }

        self.eye += move_by * MOVE_SPEED * self.speed_scale * ctx.dt().as_secs_f32();
        self.eye.y = self.eye.y.max(MIN_EYE_HEIGHT);
    }

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/stress-preview.rs (line 360)

    fn handle_camera(&mut self, ctx: &mut FrameContext<'_, Self>, elapsed: f32) {
        if ctx.ui_wants_pointer() || ctx.ui_wants_keyboard() {
            return;
        }
        let pan = ctx.axis2(Motion::Pan);
        let wheel = ctx.axis(Height::Wheel);
        let look = if ctx.down(Drag::Turn) {
            ctx.axis2(Motion::Look)
        } else {
            Vec2::ZERO
        };
        if pan == Vec2::ZERO && wheel == 0.0 && look == Vec2::ZERO {
            return;
        }

        let player = self.player.get_or_insert_with(|| {
            let eye = Self::orbit_eye(elapsed);
            let forward = (Vec3::ZERO - eye).normalize();
            Player {
                eye,
                yaw: (-forward.x).atan2(-forward.z),
                pitch: forward.y.asin(),
            }
        });

        player.yaw -= look.x;
        player.pitch = (player.pitch + look.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);

        let forward = Vec3::new(-player.yaw.sin(), 0.0, -player.yaw.cos());
        let right = Vec3::new(player.yaw.cos(), 0.0, -player.yaw.sin());
        player.eye += (forward * pan.y + right * pan.x) * PAN_SPEED * ctx.dt().as_secs_f32();
        player.eye.y =
            (player.eye.y + wheel * WHEEL_STEP).clamp(MIN_CAMERA_HEIGHT, MAX_CAMERA_HEIGHT);
    }

examples/breakout-game.rs (line 780)

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

examples/input-lab.rs (line 275)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        // `ctx.ui` cannot borrow `ctx`, so every reading and capture query
        // is taken first, and `rebind` is applied once the closure returns.
        let buttons: Vec<_> = ButtonAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.down(action),
                    ctx.pressed(action),
                    ctx.released(action),
                    ctx.clicks(action),
                )
            })
            .collect();
        let axes: Vec<_> = AxisAction::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis(action),
                )
            })
            .collect();
        let axes2: Vec<_> = Axis2Action::all()
            .into_iter()
            .map(|action| {
                (
                    action,
                    bindings_text(ctx.bindings(action)),
                    ctx.axis2(action),
                )
            })
            .collect();

        let capturing = !ctx.ui_wants_keyboard();
        let actuated_button = capturing.then(|| ctx.actuated_button()).flatten();
        let actuated_axis = capturing.then(|| ctx.actuated_axis()).flatten();
        let actuated_axis2 = capturing.then(|| ctx.actuated_axis2()).flatten();
        if actuated_button.is_some() {
            self.last_button = actuated_button;
        }
        if actuated_axis.is_some() {
            self.last_axis = actuated_axis;
        }
        if actuated_axis2.is_some() {
            self.last_axis2 = actuated_axis2;
        }
        let pointer = ctx.pointer();
        let mut edits = RowEdits {
            listening: self.listening,
            start_listening: None,
            cancel: false,
            reset: None,
        };

        ctx.ui(|ui| {
            egui::CentralPanel::default().show(ui, |ui| {
                ui.spacing_mut().item_spacing = egui::vec2(6.0, 2.0);
                ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
                ui.label("rebinds persist across runs");
                ui.label(format!(
                    "last captured: button {}, pad axis {}, pad stick {}",
                    text_of(self.last_button),
                    text_of(self.last_axis),
                    text_of(self.last_axis2),
                ));
                ui.label(format!("pointer {:.0}, {:.0}", pointer.x, pointer.y));
                ui.separator();

                ui.horizontal(|ui| {
                    ui.vertical(|ui| {
                        ui.heading("buttons");
                        egui::Grid::new("buttons-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                for (action, bindings, down, pressed, released, clicks) in &buttons
                                {
                                    let control = Control::Button(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    ui.horizontal(|ui| {
                                        mark(ui, "down", *down);
                                        mark(ui, "pressed", *pressed);
                                        mark(ui, "released", *released);
                                        ui.label(format!("clicks {clicks}"));
                                    });
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });

                    ui.separator();

                    ui.vertical(|ui| {
                        egui::Grid::new("axes-grid")
                            .num_columns(5)
                            .spacing([6.0, 2.0])
                            .show(ui, |ui| {
                                ui.heading("axes");
                                ui.end_row();
                                for (action, bindings, value) in &axes {
                                    let control = Control::Axis(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis_bar(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }

                                ui.heading("vectors");
                                ui.end_row();
                                for (action, bindings, value) in &axes2 {
                                    let control = Control::Axis2(*action);
                                    ui.label(action.name());
                                    ui.label(bindings);
                                    axis2_dot(ui, *value);
                                    rebind_cell(ui, control, &mut edits);
                                    reset_cell(ui, control, &mut edits);
                                    ui.end_row();
                                }
                            });
                    });
                });
            });
        });

        if edits.cancel {
            self.listening = None;
        }
        if let Some(control) = edits.start_listening {
            self.listening = Some(control);
        }
        if let Some(control) = edits.reset {
            match control {
                Control::Button(action) => ctx.rebind(action, action.bindings()),
                Control::Axis(action) => ctx.rebind(action, action.bindings()),
                Control::Axis2(action) => ctx.rebind(action, action.bindings()),
            }
        }
        match (
            self.listening,
            actuated_button,
            actuated_axis,
            actuated_axis2,
        ) {
            (Some(Control::Button(action)), Some(binding), _, _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis(action)), _, Some(binding), _) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            (Some(Control::Axis2(action)), _, _, Some(binding)) => {
                ctx.rebind(action, vec![binding]);
                self.listening = None;
            }
            _ => {}
        }
    }

pub fn window_size(&self) -> UVec2

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

Examples found in repository

examples/isometric-board.rs (line 465)

    fn hovered(&self, ctx: &FrameContext<'_, Board>) -> Hover {
        if ctx.ui_wants_pointer() {
            return Hover::None;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if self.current().target.is_none() {
            let (_, half) = unit_geometry(self.turn);
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                return Hover::CurrentUnit;
            }
        }
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return Hover::None;
        };
        match tile_at(ray.at(distance)) {
            Some(tile) => Hover::Tile(tile),
            None => Hover::None,
        }
    }

    /// Whether a selected unit could move to `tile`: on the board, and
    /// standing under neither unit.
    fn reachable(&self, tile: (i32, i32)) -> bool {
        tile != self.current().tile && tile != self.other().tile
    }

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

    /// Whose turn it is, and what a click does next.
    fn overlay(&self, ctx: &mut FrameContext<'_, Board>) {
        ctx.ui(|ui| {
            ui.label(match self.turn {
                Turn::Sprite => "the sprite unit's turn",
                Turn::Block => "the block unit's turn",
            });
            ui.label(if self.selected {
                "click a marked tile to order the move"
            } else {
                "click the glowing unit to select it"
            });
        });
    }

    /// What a click at `hover` does, named for the player; `None` where a
    /// click has no effect.
    fn click_effect(&self, hover: Hover) -> Option<&'static str> {
        match hover {
            Hover::CurrentUnit if self.selected => Some("deselect"),
            Hover::CurrentUnit => Some("select"),
            Hover::Tile(tile) if self.selected && self.reachable(tile) => Some("move here"),
            Hover::Tile(_) if self.selected => Some("occupied"),
            _ => None,
        }
    }

    /// A prompt beside the pointer's target, naming what its click does;
    /// absent where [`Self::click_effect`] reads no effect.
    fn draw_prompt(&self, ctx: &mut FrameContext<'_, Board>, camera: Camera, hover: Hover) {
        let Some(text) = self.click_effect(hover) else {
            return;
        };
        let point = match hover {
            Hover::CurrentUnit => {
                let (lift, _) = unit_geometry(self.turn);
                self.current().position + Vec3::Y * (lift * 2.0 + PROMPT_UNIT_LIFT)
            }
            Hover::Tile(tile) => tile_center(tile) + Vec3::Y * PROMPT_TILE_LIFT,
            Hover::None => return,
        };
        let galley = ctx.text_layout(text, egui::FontId::proportional(PROMPT_SIZE));
        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;
        };
        let at = logical(pixel, pixels_per_point);
        ctx.ui(|ui| {
            let painter = ui.painter();
            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(PROMPT_BACKDROP),
            );
            painter.galley(pos, galley, PROMPT_TEXT_COLOR);
        });
    }

examples/ui-fonts.rs (line 684)

    fn draw_bracket(&self, ctx: &mut FrameContext<'_, Self>, camera: Camera, station: StationKind) {
        let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
        let window_size = ctx.window_size();
        let Some(pixel) = camera.pixel_of(top, window_size) else {
            return;
        };
        let at = logical(pixel, ctx.pixels_per_point());

        let name = ctx.text_layout(station.look().name, egui::FontId::proportional(BODY_SIZE));
        let (reading_text, number_text) = station.reading(self.elapsed.as_secs_f32());
        let reading = ctx.text_layout(&reading_text, egui::FontId::monospace(BODY_SIZE));
        let number = ctx.text_layout(
            &number_text,
            egui::FontId::new(NUMBER_SIZE, egui::FontFamily::Name(DISPLAY_FAMILY.into())),
        );

        ctx.ui(|ui| bracket(ui.painter(), at, name, reading, number));
    }

    /// A `Prompt` for `Trigger::Hail`, above every `StationKind` but
    /// `hovered`: what a player presses to reach one, apart from a hover.
    fn draw_prompts(
        &self,
        ctx: &mut FrameContext<'_, Self>,
        camera: Camera,
        hovered: Option<StationKind>,
    ) {
        let Some(binding) = ctx.bindings(Trigger::Hail).into_iter().next() else {
            return;
        };
        let hint = prompt(&binding);
        let glyph = ctx.text_layout(&hint.text(), egui::FontId::new(PROMPT_SIZE, hint.family()));
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();

        ctx.ui(|ui| {
            let painter = ui.painter();
            for station in StationKind::ALL {
                if Some(station) == hovered {
                    continue;
                }
                let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
                let Some(pixel) = camera.pixel_of(top, window_size) else {
                    continue;
                };
                let at = logical(pixel, pixels_per_point);
                let at = egui::pos2(at.x, at.y - PROMPT_LIFT);
                prompt_at(painter, at, glyph.clone());
            }
        });
    }

    /// The title, a line and the reading, each in a font this game loaded
    /// rather than egui's own.
    fn panel(&self, ctx: &mut FrameContext<'_, Self>) {
        ctx.ui(|ui| {
            ui.label(styled(
                "a game's own fonts",
                egui::FontId::proportional(HEADING_SIZE),
            ));
            ui.label(styled(
                "drawn in Pixel Operator, the game's proportional font",
                egui::FontId::proportional(BODY_SIZE),
            ));
            ui.label(styled(
                "the readings above each station in Pixel Operator Mono",
                egui::FontId::monospace(BODY_SIZE),
            ));
        });
    }

    fn draw_dialogue(&self, ctx: &mut FrameContext<'_, Self>) {
        let Some(dialogue) = &self.dialogue else {
            return;
        };
        let whole = ctx.text_layout(
            dialogue.current_line(),
            egui::FontId::proportional(BODY_SIZE),
        );
        let size = whole.size();
        ctx.ui(|ui| dialogue.draw(ui, size));
    }

    /// The `StationKind` under the pointer, `None` while the UI holds it.
    fn hovered(ctx: &FrameContext<'_, Self>) -> Option<StationKind> {
        if ctx.ui_wants_pointer() {
            return None;
        }
        hit_station(
            ctx.last_camera()
                .ray_through(ctx.pointer(), ctx.window_size()),
        )
    }

examples/sprite-adventure.rs (line 1651)

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

examples/animation.rs (line 848)

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

examples/stress-preview.rs (line 464)

    fn controls(&mut self, ctx: &mut FrameContext<'_, Self>, camera: &Camera) {
        let submitted = self.field.len();
        let seeds = self.applied_seed_count;
        let average_ms = self.frame_times.average_ms();
        let fps = if average_ms > 0.0 {
            1000.0 / average_ms
        } else {
            0.0
        };
        let elapsed = ctx.elapsed().as_secs_f32();
        let (in_view, sampled) = self.count_in_view(camera, ctx.window_size());

        ctx.ui(|ui| {
            egui::Frame::new()
                .fill(egui::Color32::from_gray(24))
                .inner_margin(PANEL_PADDING)
                .corner_radius(f32::from(PANEL_PADDING))
                .show(ui, |ui| {
                    ui.add(
                        egui::Slider::new(
                            &mut self.settings.instance_count,
                            MIN_INSTANCE_COUNT..=MAX_INSTANCE_COUNT,
                        )
                        .text("instance count"),
                    );
                    ui.add(
                        egui::Slider::new(
                            &mut self.settings.seed_count,
                            MIN_SEED_COUNT..=MAX_SEED_COUNT,
                        )
                        .text("distinct seeds"),
                    );
                    ui.checkbox(&mut self.settings.sun_shadow, "sun shadow");
                    ui.checkbox(&mut self.settings.moving, "moving fraction");
                    ui.separator();
                    ui.label(format!("instances submitted {submitted}"));
                    if sampled {
                        ui.label(format!("in view, sampled {in_view}"));
                    } else {
                        ui.label(format!("instances in view {in_view}"));
                    }
                    ui.label(format!("distinct seeds {seeds}"));
                    ui.label(format!("frame time {average_ms:.2}ms, {fps:.0} fps"));
                    ui.label(format!("elapsed {elapsed:.1}s"));
                });
        });
    }

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, not at what this frame has set since.

Examples found in repository

examples/ui-fonts.rs (line 771)

    fn hovered(ctx: &FrameContext<'_, Self>) -> Option<StationKind> {
        if ctx.ui_wants_pointer() {
            return None;
        }
        hit_station(
            ctx.last_camera()
                .ray_through(ctx.pointer(), ctx.window_size()),
        )
    }

examples/isometric-board.rs (line 464)

    fn hovered(&self, ctx: &FrameContext<'_, Board>) -> Hover {
        if ctx.ui_wants_pointer() {
            return Hover::None;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if self.current().target.is_none() {
            let (_, half) = unit_geometry(self.turn);
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                return Hover::CurrentUnit;
            }
        }
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return Hover::None;
        };
        match tile_at(ray.at(distance)) {
            Some(tile) => Hover::Tile(tile),
            None => Hover::None,
        }
    }

pub fn config(&self) -> &Config

The configuration the engine started with.

Examples found in repository

examples/material-playground.rs (line 1038)

    fn controls(&mut self, ctx: &mut FrameContext<'_, Self>) {
        let tonemap = ctx.config().tonemap();
        let antialiasing = ctx.config().antialiasing();
        let shadow_resolution = ctx.config().shadow_resolution();

        ctx.ui(|ui| {
            egui::Panel::right("controls")
                .resizable(false)
                .default_size(300.0)
                .show(ui, |ui| {
                    egui::ScrollArea::vertical().show(ui, |ui| {
                        ui.label(
                            "right mouse button to look, W/A/S/D to move, \
                             space/shift up and down, wheel to scale speed",
                        );
                        ui.separator();
                        self.lighting_controls(ui);
                        ui.separator();
                        self.light_controls(ui);
                        ui.separator();
                        self.material_controls(ui);
                        ui.separator();
                        ui.label(format!(
                            "tone map {tonemap:?} \u{b7} antialiasing {antialiasing} \u{b7} \
                             shadow {shadow_resolution}px: set at startup, not live"
                        ));
                        ui.add(egui::Slider::new(&mut self.exposure, 0.1..=3.0).text("exposure"));
                        ui.add(egui::Slider::new(&mut self.bloom, 0.0..=1.0).text("bloom"));
                    });
                });
        });
    }

pub fn prepare<M>(&mut self, mesh: M)

where G::Meshes: Holds<M>,

Builds and uploads mesh now, instead of on its first draw; the copy is then held like any drawn mesh’s under Config::with_mesh_memory, and no longer than that.

Takes a mesh of Game::Meshes and no other.