Struct Vec3 

pub struct Vec3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

A 3-component f32 vector used for points, directions, and linear colors.

Fields

x: f32

X component (red when used as a color).

y: f32

Y component (green when used as a color).

z: f32

Z component (blue when used as a color).

Implementations

impl Vec3

pub const ONE: Self

The vector with every component set to one.

pub const ZERO: Self

The zero vector.

pub const fn splat(value: f32) -> Self

Creates a vector with every component set to value.

pub const fn rgb(red: u8, green: u8, blue: u8) -> Self

Decodes an sRGB byte triple into linear-light components.

Examples found in repository

examples/chat/welcome.rs (line 129)

const DISK_STOPS: [Vec3; 4] = [
	Vec3::rgb(56, 189, 248),
	Vec3::rgb(129, 140, 248),
	Vec3::rgb(192, 132, 252),
	Vec3::rgb(56, 189, 248),
];
const BACKGROUND: Vec3 = Vec3::rgb(11, 14, 21);
const WHITE: Vec3 = Vec3::rgb(248, 250, 252);
const INK: Vec3 = Vec3::rgb(3, 4, 7);

type LogoGrid = [[Option<(char, Color)>; LOGO_COLS]; LOGO_ROWS];

/// The animated welcome screen: a retained full-viewport frame, the
/// pre-built title chip, and the pointer-orbit camera. [`crate::run_welcome`]
/// drives it until the user resumes into the chat demo.
pub struct Welcome {
	frame:          Frame,
	title:          Str,
	/// Detected glyph tier for the card chrome.
	charset:        Charset,
	camera:         (f32, f32),
	camera_target:  (f32, f32),
	last_elapsed:   f32,
	/// Top-left cell of the logo as last drawn; anchors pointer mapping.
	logo_origin:    (u16, u16),
	logo:           LogoGrid,
	logo_at:        Option<Duration>,
	backdrop_frame: Frame,
	backdrop_at:    Option<Duration>,
	/// Eclipse backdrop program and its reusable half-block render target.
	backdrop:       Eclipse,
	surface:        Surface,
	/// Last pointer cell reported by the host loop.
	pointer:        Option<(u16, u16)>,
	/// Eased hover amount driving the border glow.
	hover:          Tween<f32>,
}

impl Welcome {
	pub fn new(charset: Charset) -> Self {
		Self {
			charset,
			frame: Frame::new(Size::new(0, 0)),
			title: fmts!(" {} omp v{} ", charset.icon(Icon::Omp), env!("CARGO_PKG_VERSION")),
			camera: (0.0, 0.0),
			camera_target: (0.0, 0.0),
			last_elapsed: 0.0,
			logo_origin: (0, 0),
			logo: [[None; LOGO_COLS]; LOGO_ROWS],
			logo_at: None,
			backdrop_frame: Frame::new(Size::new(0, 0)),
			backdrop_at: None,
			backdrop: Eclipse::default(),
			surface: Surface::new(),
			pointer: None,
			hover: Tween::settled(0.0),
		}
	}

	/// Records the pointer (0-based cells) for the hover zone and retargets
	/// the camera: the pointer's offset from the logo center maps to camera
	/// lift and a full half-turn of yaw in each direction, matching the
	/// prototype.
	pub fn point_at(&mut self, column: u16, row: u16) {
		self.pointer = Some((column, row));
		self.logo_at = None;
		let center_x = f32::from(self.logo_origin.0) + LOGO_COLS as f32 / 2.0;
		let center_y = f32::from(self.logo_origin.1) + LOGO_ROWS as f32 / 2.0;
		let horizontal = ((f32::from(column) - center_x) / (LOGO_COLS as f32 / 2.0)).clamp(-1.0, 1.0);
		let vertical = ((f32::from(row) - center_y) / (LOGO_ROWS as f32 / 2.0)).clamp(-1.0, 1.0);
		self.camera_target = (-vertical * 0.42, -horizontal * PI);
	}

	/// Paints the card centered in `viewport` at `elapsed` since boot and
	/// returns the full-viewport frame (no stable rows, everything damaged).
	pub fn render(&mut self, viewport: Size, elapsed: Duration) -> &Frame {
		if self.frame.size() != viewport {
			self.frame = Frame::new(viewport);
			self.backdrop_frame = Frame::new(viewport);
			self.backdrop_at = None;
		}
		let clock = elapsed;
		let elapsed = elapsed.as_secs_f32();
		// Exponential pointer chase, frame-rate independent (~100ms lag).
		let delta = (elapsed - self.last_elapsed).max(0.0);
		self.last_elapsed = elapsed;
		let response = 1.0 - (-delta * 10.0).exp();
		self.camera.0 += (self.camera_target.0 - self.camera.0) * response;
		self.camera.1 += (self.camera_target.1 - self.camera.1) * response;
		self.draw_backdrop(viewport, clock, elapsed);

		let logo_interval = ambient_interval(clock, LOGO_IDLE_INTERVAL);
		if self
			.logo_at
			.is_none_or(|rendered_at| clock.saturating_sub(rendered_at) >= logo_interval)
		{
			self.logo = logo_cells(elapsed, self.camera);
			self.logo_at = Some(clock);
		}
		let cols = if viewport.width >= CARD_COLS && viewport.height >= CARD_ROWS {
			Some(CARD_COLS)
		} else if viewport.width >= SMOL_COLS && viewport.height >= CARD_ROWS {
			Some(SMOL_COLS)
		} else {
			None
		};
		let Some(cols) = cols else {
			let left = viewport.width.saturating_sub(LOGO_COLS as u16) / 2;
			let top = viewport.height.saturating_sub(LOGO_ROWS as u16) / 2;
			self.logo_origin = (left, top);
			blit_logo(&mut self.frame, &self.logo, left, top, PLATE);
			return &self.frame;
		};

		let left = (viewport.width - cols) / 2;
		let top = (viewport.height - CARD_ROWS) / 2;
		let hovered = self.pointer.is_some_and(|(x, y)| {
			(left..left + cols).contains(&x) && (top..top + CARD_ROWS).contains(&y)
		});
		self
			.hover
			.retarget(clock, if hovered { 1.0 } else { 0.0 }, HOVER_EASE, Easing::EaseOut);
		let hover = self.hover.sample(clock).clamp(0.0, 1.0);
		self.draw_card(cols, left, top, elapsed, hover);
		&self.frame
	}

	/// Paints the eclipse across the whole viewport, resolving out of
	/// black over the first [`BACKDROP_FADE`] seconds of boot.
	fn draw_backdrop(&mut self, viewport: Size, clock: Duration, elapsed: f32) {
		let interval = ambient_interval(clock, BACKDROP_IDLE_INTERVAL);
		if self
			.backdrop_at
			.is_none_or(|rendered_at| clock.saturating_sub(rendered_at) >= interval)
		{
			let fade = smooth((elapsed / BACKDROP_FADE).clamp(0.0, 1.0));
			self
				.backdrop_frame
				.fill(Rect::new(0, 0, viewport.width, viewport.height), Style::default());
			let frame = &mut self.backdrop_frame;
			let mut buffer = [0_u8; 4];
			let dim = |color: Color| Color::Rgb(0, 0, 0).lerp(color, fade);
			self.surface.render(
				&mut self.backdrop,
				clock,
				viewport.width,
				viewport.height,
				|x, y, glyph, fg, bg| {
					let style = Style::new().fg(dim(fg));
					let style = match bg {
						Some(bg) => style.bg(dim(bg)),
						None => style,
					};
					frame.put(x, y, glyph.encode_utf8(&mut buffer), style);
				},
			);
			self.backdrop_at = Some(clock);
		}
		self.frame.clone_from(&self.backdrop_frame);
	}

	fn draw_card(&mut self, cols: u16, left: u16, top: u16, elapsed: f32, hover: f32) {
		let full = cols == CARD_COLS;
		let logo_left = if full {
			left + 3
		} else {
			left + (cols - LOGO_COLS as u16) / 2
		};
		self.logo_origin = (logo_left, top + 2);
		// Pointer-tracking border glow: the brand gradient sampled by angle
		// around the card center (the disk's own palette), strongest near
		// the pointer, scaled by the eased hover amount.
		let pointer = self.pointer;
		let center =
			(f32::from(left) + f32::from(cols) / 2.0, f32::from(top) + f32::from(CARD_ROWS) / 2.0);
		let edge_at = move |x: u16, y: u16| -> Style {
			let Some((px, py)) = pointer.filter(|_| hover > 0.02) else {
				return on_card(CARD_BORDER);
			};
			let dx = (f32::from(x) - f32::from(px)) * 0.5;
			let dy = f32::from(y) - f32::from(py);
			let glow = hover * (-(dx * dx + dy * dy) / 34.0).exp();
			if glow < 0.02 {
				return on_card(CARD_BORDER);
			}
			let angle = (f32::from(y) - center.1).atan2((f32::from(x) - center.0) * 0.5);
			let brand = vec3_color(gradient(angle - elapsed * 0.5));
			on_card(CARD_BORDER.lerp(brand, glow))
		};
		let frame = &mut self.frame;
		frame.fill(Rect::new(left, top, cols, CARD_ROWS), on_card(TEXT));

		let right = left + cols - 1;
		let bottom = top + CARD_ROWS - 1;
		let divider = bottom - 2;
		let (tl, tr, bl, br, horizontal, vertical) = self.charset.border(Border::Round);
		let grid = self.charset.grid();
		let mut glyph = [0_u8; 4];
		frame.put(left, top, tl.encode_utf8(&mut glyph), edge_at(left, top));
		frame.put(right, top, tr.encode_utf8(&mut glyph), edge_at(right, top));
		frame.put(left, divider, grid.middle.0.encode_utf8(&mut glyph), edge_at(left, divider));
		frame.put(right, divider, grid.middle.2.encode_utf8(&mut glyph), edge_at(right, divider));
		frame.put(left, bottom, bl.encode_utf8(&mut glyph), edge_at(left, bottom));
		frame.put(right, bottom, br.encode_utf8(&mut glyph), edge_at(right, bottom));
		for x in left + 1..right {
			frame.put(x, top, horizontal.encode_utf8(&mut glyph), edge_at(x, top));
			frame.put(x, divider, horizontal.encode_utf8(&mut glyph), edge_at(x, divider));
			frame.put(x, bottom, horizontal.encode_utf8(&mut glyph), edge_at(x, bottom));
		}
		for y in top + 1..bottom {
			if y != divider {
				frame.put(left, y, vertical.encode_utf8(&mut glyph), edge_at(left, y));
				frame.put(right, y, vertical.encode_utf8(&mut glyph), edge_at(right, y));
			}
		}

		frame.put(left + 2, top, self.title.as_str(), on_card(TEXT_STRONG));
		if full {
			frame.put(left + 34, top, " SESSION ORBIT ", on_card(FAINT));
			draw_dust(frame, left, top, elapsed);
			draw_sessions(frame, left, top, self.charset);
			draw_beam(frame, left, top, elapsed);
		}

		blit_logo(frame, &self.logo, logo_left, top + 2, CARD_BG);

		let footer = divider + 1;
		frame.fill(Rect::new(left + 1, footer, cols - 2, 1), on_footer(TEXT));
		if full {
			frame.put(left + 3, divider, " SHORTCUTS ", on_card(FAINT));
			let dot = fmts!(" {} ", self.charset.icon(Icon::Enabled));
			let x = frame.put(left + cols - 21, top, &dot, on_card(GREEN));
			frame.put(x, top, "rust-analyzer ", on_card(MUTED));
			draw_full_hints(frame, left, footer);
		} else {
			draw_smol_hints(frame, left, cols, footer);
		}
	}
}

impl Default for Welcome {
	fn default() -> Self {
		Self::new(Charset::NerdFont)
	}
}

fn draw_dust(frame: &mut Frame, left: u16, top: u16, elapsed: f32) {
	for &(x, y, offset) in &DUST {
		let pulse = 0.5 + 0.5 * (elapsed * 1.4 + offset).sin();
		let color = FAINT.lerp(CYAN, pulse * 0.28);
		frame.put(left + x, top + y, "·", on_card(color));
	}
	frame.put(left + 1, top + 7, HORIZON, on_card(FAINT.lerp(INDIGO, 0.16)));
	frame.put(left + 14, top + 1, "+Z", on_card(FAINT));
}

fn draw_beam(frame: &mut Frame, left: u16, top: u16, elapsed: f32) {
	let phase = (elapsed * 9.0) as usize % BEAM.len();
	for (index, &(x, y, glyph)) in BEAM.iter().enumerate() {
		let direct = index.abs_diff(phase);
		let distance = direct.min(BEAM.len() - direct);
		let color = match distance {
			0 => TEXT_STRONG,
			1 => CYAN,
			_ => FAINT.lerp(INDIGO, 0.34),
		};
		frame.put(left + x, top + y, glyph, on_card(color));
	}
}

fn draw_sessions(frame: &mut Frame, left: u16, top: u16, charset: Charset) {
	let (_, _, _, _, _, vertical) = charset.border(Border::Round);
	let mut glyph = [0_u8; 4];
	let panel_x = left + 36;
	frame.put(panel_x, top + 2, "RECENT SESSIONS", on_card(MUTED));
	frame.put(left + CARD_COLS - 14, top + 2, "4 / LOCAL", on_card(FAINT));
	for y in top + 4..=top + 10 {
		frame.put(panel_x, y, vertical.encode_utf8(&mut glyph), on_card(FAINT.lerp(INDIGO, 0.18)));
	}
	for (index, (label, age)) in SESSIONS.iter().enumerate() {
		let y = top + 4 + index as u16 * 2;
		if index == 0 {
			frame.fill(Rect::new(panel_x - 2, y, CARD_COLS - 35, 1), on_selected(TEXT));
			frame.put(panel_x - 2, y, charset.rail(), on_selected(GREEN));
			frame.put(panel_x, y, charset.radio(true), on_selected(GREEN));
			frame.put(panel_x + 2, y, age, on_selected(GREEN));
			frame.put(panel_x + 7, y, label, on_selected(TEXT_STRONG));
		} else {
			frame.put(panel_x, y, charset.radio(false), on_card(FAINT));
			frame.put(panel_x + 2, y, age, on_card(FAINT));
			frame.put(panel_x + 7, y, label, on_card(MUTED));
		}
	}
}

fn draw_full_hints(frame: &mut Frame, left: u16, y: u16) {
	frame.put(left + 3, y, "#", on_footer(CYAN));
	frame.put(left + 5, y, "actions", on_footer(MUTED));
	frame.put(left + 14, y, "/", on_footer(GREEN));
	frame.put(left + 16, y, "commands", on_footer(MUTED));
	frame.put(left + 27, y, "!", on_footer(AMBER));
	frame.put(left + 29, y, "shell", on_footer(MUTED));
	frame.put(left + 37, y, "$", on_footer(VIOLET));
	frame.put(left + 39, y, "python", on_footer(MUTED));
	frame.put(left + CARD_COLS - 23, y, "↑↓ move", on_footer(FAINT));
	frame.put(left + CARD_COLS - 13, y, "↵ resume", on_footer(TEXT_STRONG));
}

fn draw_smol_hints(frame: &mut Frame, left: u16, cols: u16, y: u16) {
	frame.put(left + 3, y, "#", on_footer(CYAN).bold());
	frame.put(left + 5, y, "/", on_footer(CYAN).bold());
	frame.put(left + 7, y, "!", on_footer(AMBER).bold());
	frame.put(left + 9, y, "$", on_footer(GREEN).bold());
	frame.put(left + cols - 14, y, "enter", on_footer(FAINT));
	frame.put(left + cols - 8, y, "resume", on_footer(TEXT_STRONG).bold());
}

fn blit_logo(frame: &mut Frame, logo: &LogoGrid, left: u16, top: u16, background: Color) {
	let mut buffer = [0_u8; 4];
	for (row, cells) in logo.iter().enumerate() {
		for (column, cell) in cells.iter().enumerate() {
			let Some((glyph, color)) = cell else { continue };
			let style = Style::new().fg(*color).bg(background);
			frame.put(left + column as u16, top + row as u16, glyph.encode_utf8(&mut buffer), style);
		}
	}
}

const fn on_card(fg: Color) -> Style {
	Style::new().fg(fg).bg(CARD_BG)
}

const fn on_footer(fg: Color) -> Style {
	Style::new().fg(fg).bg(FOOTER_BG)
}

const fn on_selected(fg: Color) -> Style {
	Style::new().fg(fg).bg(SELECTED_BG)
}

// ── raytraced logo ───────────────────────────────────────────────────────────

fn smooth(edge: f32) -> f32 {
	edge * edge * (3.0 - 2.0 * edge)
}

fn ease_in(progress: f32) -> f32 {
	let clamped = progress.clamp(0.0, 1.0);
	clamped * clamped
}

/// Opaque platter → glass blend, driven by boot time.
fn color_mix(elapsed: f32) -> f32 {
	ease_in((elapsed - 0.18) / 0.58)
}

/// One decaying full camera orbit as the logo reveals.
fn reveal_orbit(elapsed: f32) -> f32 {
	let progress = ((elapsed - 0.18) / 0.64).clamp(0.0, 1.0);
	TAU * (1.0 - (1.0 - progress).powi(3))
}

/// Disk spin: quadratic ramp into a constant angular speed.
fn disk_rotation(elapsed: f32) -> f32 {
	let spinning = (elapsed - 0.18).max(0.0);
	let ramp = 0.40;
	let angular_speed = TAU / 2.4;
	if spinning < ramp {
		angular_speed * spinning * spinning / (2.0 * ramp)
	} else {
		angular_speed * (spinning - ramp / 2.0)
	}
}

/// Samples the brand gradient by angle around the disk.
fn gradient(angle: f32) -> Vec3 {
	let position = (angle / TAU + 0.5).rem_euclid(1.0) * 3.0;
	let index = (position as usize).min(2);
	DISK_STOPS[index].lerp(DISK_STOPS[index + 1], position - index as f32)
}

/// Encodes a linear-light color for the terminal.
fn vec3_color(color: Vec3) -> Color {
	Color::from(color)
}

/// Three soft light shafts crossing the stage in the sun's plane.
fn sun_rays(x: f32, z: f32) -> f32 {
	let length = 0.55_f32.hypot(0.38);
	let (hx, hz) = (-0.55 / length, 0.38 / length);
	let across = x * -hz + z * hx;
	let along = x * hx + z * hz;
	let rays = (-((across + 0.56) / 0.075).powi(2)).exp()
		+ (-((across + 0.04) / 0.055).powi(2)).exp()
		+ (-((across - 0.47) / 0.09).powi(2)).exp();
	let envelope = (-((along + 0.20) / 2.45).powi(4)).exp();
	(rays * envelope).clamp(0.0, 1.0)
}

fn sphere_depth(origin: Vec3, direction: Vec3, center: Vec3, radius: f32) -> f32 {
	let offset = origin - center;
	let projection = offset.dot(direction);
	let discriminant = projection * projection - (offset.dot(offset) - radius * radius);
	let root = -projection - discriminant.max(0.0).sqrt();
	if discriminant >= 0.0 && root > 0.0 {
		root
	} else {
		f32::INFINITY
	}
}

/// Central axis: a capped cylinder with a slightly bulged top sphere.
fn axis_hit(origin: Vec3, direction: Vec3) -> (f32, bool, Vec3) {
	let quadratic = direction.x * direction.x + direction.z * direction.z;
	let linear = 2.0 * (origin.x * direction.x + origin.z * direction.z);
	let constant = origin.x * origin.x + origin.z * origin.z - AXIS_RADIUS * AXIS_RADIUS;
	let discriminant = linear * linear - 4.0 * quadratic * constant;
	let root = (-linear - discriminant.max(0.0).sqrt()) / (2.0 * quadratic).max(1e-8);
	let hit_y = origin.y + direction.y * root;
	let cylinder = if discriminant >= 0.0 && root > 0.0 && (AXIS_BOTTOM..=AXIS_TOP).contains(&hit_y)
	{
		root
	} else {
		f32::INFINITY
	};
	let cap_center = vec3(0.0, AXIS_TOP, 0.0);
	let cap = sphere_depth(origin, direction, cap_center, AXIS_RADIUS * 1.75);
	let depth = cylinder.min(cap);
	if !depth.is_finite() {
		return (f32::INFINITY, false, vec3(0.0, 1.0, 0.0));
	}
	let point = origin + direction * depth;
	let normal = if cap < cylinder {
		(point - cap_center).normalize()
	} else {
		vec3(point.x, 0.0, point.z).normalize()
	};
	(depth, true, normal)
}

/// Terminal display lift in linear light so braille remains legible on the
/// dark card.
fn tone(color: Vec3) -> Vec3 {
	color * 1.28 + Vec3::rgb(4, 4, 4)
}

pub fn dot(self, other: Self) -> f32

Dot product.

Examples found in repository

examples/chat/welcome.rs (line 529)

fn sphere_depth(origin: Vec3, direction: Vec3, center: Vec3, radius: f32) -> f32 {
	let offset = origin - center;
	let projection = offset.dot(direction);
	let discriminant = projection * projection - (offset.dot(offset) - radius * radius);
	let root = -projection - discriminant.max(0.0).sqrt();
	if discriminant >= 0.0 && root > 0.0 {
		root
	} else {
		f32::INFINITY
	}
}

/// Central axis: a capped cylinder with a slightly bulged top sphere.
fn axis_hit(origin: Vec3, direction: Vec3) -> (f32, bool, Vec3) {
	let quadratic = direction.x * direction.x + direction.z * direction.z;
	let linear = 2.0 * (origin.x * direction.x + origin.z * direction.z);
	let constant = origin.x * origin.x + origin.z * origin.z - AXIS_RADIUS * AXIS_RADIUS;
	let discriminant = linear * linear - 4.0 * quadratic * constant;
	let root = (-linear - discriminant.max(0.0).sqrt()) / (2.0 * quadratic).max(1e-8);
	let hit_y = origin.y + direction.y * root;
	let cylinder = if discriminant >= 0.0 && root > 0.0 && (AXIS_BOTTOM..=AXIS_TOP).contains(&hit_y)
	{
		root
	} else {
		f32::INFINITY
	};
	let cap_center = vec3(0.0, AXIS_TOP, 0.0);
	let cap = sphere_depth(origin, direction, cap_center, AXIS_RADIUS * 1.75);
	let depth = cylinder.min(cap);
	if !depth.is_finite() {
		return (f32::INFINITY, false, vec3(0.0, 1.0, 0.0));
	}
	let point = origin + direction * depth;
	let normal = if cap < cylinder {
		(point - cap_center).normalize()
	} else {
		vec3(point.x, 0.0, point.z).normalize()
	};
	(depth, true, normal)
}

/// Terminal display lift in linear light so braille remains legible on the
/// dark card.
fn tone(color: Vec3) -> Vec3 {
	color * 1.28 + Vec3::rgb(4, 4, 4)
}

/// Per-frame scene state shared by every ray: sun direction, disk spin,
/// glass transition, and the pointer camera offsets.
struct Platter {
	sun:        Vec3,
	angle:      f32,
	transition: f32,
	/// Smoothed pointer camera from [`Welcome`]: (lift, yaw).
	pointer:    (f32, f32),
}

impl Platter {
	fn new(pointer: (f32, f32)) -> Self {
		Self { sun: vec3(-0.55, 1.0, 0.38).normalize(), angle: 0.0, transition: 0.0, pointer }
	}

	/// Floor glow: light shafts, the disk's shadow, tinted transmission
	/// through the glass, and a soft rim reflection.
	fn ground(&self, origin: Vec3, direction: Vec3) -> (Vec3, f32) {
		if direction.y >= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let depth = (FLOOR_Y - origin.y) / direction.y;
		if depth <= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let floor = origin + direction * depth;
		let stage =
			(-0.42 * ((floor.x.abs() / 2.30).powi(4) + ((floor.z + 0.15).abs() / 1.70).powi(4))).exp();

		let sun_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / self.sun.y;
		let sunlit = floor + self.sun * sun_depth;
		let shadow_radius = sunlit.x.hypot(sunlit.z);
		let occlusion = smooth(((DISK_RADIUS + 0.08 - shadow_radius) / 0.16).clamp(0.0, 1.0));
		let rays = sun_rays(floor.x, floor.z);

		let neutral_alpha = stage * rays * (1.0 - occlusion) * 0.36;
		let neutral = (BACKGROUND + vec3(0.36, 0.33, 0.27) * (stage * rays)).clamp01();
		let mut color = neutral * neutral_alpha + BACKGROUND * (1.0 - neutral_alpha);
		let mut alpha = neutral_alpha;

		let transmission_alpha =
			stage * sun_rays(sunlit.x, sunlit.z) * occlusion * self.transition * 0.64;
		let transmission =
			(BACKGROUND + gradient(sunlit.z.atan2(sunlit.x) - self.angle) * 0.86).clamp01();
		color = transmission * transmission_alpha + color * (1.0 - transmission_alpha);
		alpha = transmission_alpha + alpha * (1.0 - transmission_alpha);

		let mirrored = vec3(direction.x, -direction.y, direction.z);
		let reflected_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / mirrored.y.max(1e-6);
		let reflected = floor + mirrored * reflected_depth;
		let reflected_radius = reflected.x.hypot(reflected.z);
		if reflected_radius <= DISK_RADIUS {
			let edge = smooth(((DISK_RADIUS - reflected_radius) / 0.13).clamp(0.0, 1.0));
			let grazing = (1.0 + direction.y).clamp(0.0, 1.0);
			let reflection_alpha = self.transition * edge * (0.22 + 0.28 * grazing);
			let reflection = gradient(reflected.z.atan2(reflected.x) - self.angle);
			color = reflection * reflection_alpha + color * (1.0 - reflection_alpha);
			alpha = reflection_alpha + alpha * (1.0 - reflection_alpha);
		}
		(color, alpha)
	}
}

impl Trace for Platter {
	fn advance(&mut self, now: Duration) -> Camera {
		let elapsed = now.as_secs_f32();
		self.angle = disk_rotation(elapsed);
		self.transition = color_mix(elapsed);
		Camera {
			target:   vec3(0.0, 0.08, 0.0),
			yaw:      self.pointer.1 + reveal_orbit(elapsed) + (elapsed * 0.31).sin() * 0.018,
			pitch:    CAMERA_PITCH,
			distance: CAMERA_DISTANCE,
			lift:     self.pointer.0.clamp(-0.42, 0.42) + (elapsed * 0.55).sin() * 0.014,
			focal:    CAMERA_FOCAL,
		}
	}

	/// Shades one sample: returns the color composited over the card
	/// background and the coverage used for braille dot thresholds.
	fn shade(&self, ray: Ray) -> (Vec3, f32) {
		let Ray { origin, dir: direction } = ray;

		// Top surface of the disk.
		let mut disk_depth = f32::INFINITY;
		let mut disk_point = Vec3::ZERO;
		let mut disk_radial = 0.0;
		if direction.y < 0.0 {
			let depth = (DISK_Y + DISK_HALF_THICKNESS - origin.y) / direction.y;
			if depth > 0.0 {
				let point = origin + direction * depth;
				let radial = point.x.hypot(point.z);
				if radial <= DISK_RADIUS {
					disk_depth = depth;
					disk_point = point;
					disk_radial = radial;
				}
			}
		}
		let disk_visible = disk_depth.is_finite();
		let (axis_depth, axis_visible, axis_normal) = axis_hit(origin, direction);

		let (ground_color, ground_alpha) = self.ground(origin, direction);
		let mut color = ground_color * ground_alpha + BACKGROUND * (1.0 - ground_alpha);
		let mut alpha = ground_alpha;

		let view = direction * -1.0;
		let halfway = if disk_visible || axis_visible {
			(self.sun + view).normalize()
		} else {
			Vec3::ZERO
		};
		let axis_color = if axis_visible {
			let diffuse = axis_normal.dot(self.sun).max(0.0);
			let specular = axis_normal.dot(halfway).max(0.0).powi(44);
			(WHITE * (0.32 + 0.68 * diffuse + 0.48 * specular)).clamp01()
		} else {
			Vec3::ZERO
		};

		if axis_visible && axis_depth > disk_depth {
			color = axis_color;
			alpha = 1.0;
		}

		if disk_visible {
			let diffuse = self.sun.y.max(0.0);
			let specular = halfway.y.max(0.0).powi(72);
			let fresnel = (1.0 - view.y.max(0.0)).powi(4);
			let material_angle = disk_point.z.atan2(disk_point.x) - self.angle;
			let rim = smooth(((disk_radial - (DISK_RADIUS - 0.075)) / 0.055).clamp(0.0, 1.0));
			let streak_angle = (material_angle - 0.32 + PI).rem_euclid(TAU) - PI;
			let streak = (-(streak_angle / 0.19).powi(2)).exp();
			let incident = sun_rays(disk_point.x, disk_point.z);

			let opaque =
				(WHITE * (0.30 + 0.27 * diffuse + 0.36 * incident + 0.20 * specular)).clamp01();
			let glass = (gradient(material_angle) * (0.34 + 0.70 * diffuse)
				+ WHITE * (0.72 * specular + 0.16 * fresnel + 0.20 * streak))
				.clamp01();
			let border_strength = rim * self.transition;
			let mut disk_color = opaque
				.lerp(glass, self.transition)
				.lerp(WHITE, border_strength);

			// Orbiting index marker punched into the surface.
			let marker_x = 0.52 * self.angle.cos();
			let marker_z = 0.52 * self.angle.sin();
			let marker_distance = (disk_point.x - marker_x).hypot(disk_point.z - marker_z);
			let marker = smooth(((0.10 - marker_distance) / 0.035).clamp(0.0, 1.0));
			disk_color = disk_color.lerp(INK, marker);

			let disk_alpha = (1.0 - self.transition * (1.0 - DISK_GLASS_OPACITY))
				.max(border_strength * 0.96)
				.max(marker * 0.98);
			color = disk_color * disk_alpha + color * (1.0 - disk_alpha);
			alpha = disk_alpha + alpha * (1.0 - disk_alpha);
		}

		if axis_visible && axis_depth <= disk_depth {
			color = axis_color;
			alpha = 1.0;
		}
		(tone(color), alpha)
	}

pub fn length_squared(self) -> f32

Squared vector length.

pub fn length(self) -> f32

Vector length.

pub fn cross(self, other: Self) -> Self

Cross product.

pub fn normalize(self) -> Self

Unit-length copy; near-zero vectors stay finite.

Examples found in repository

examples/chat/welcome.rs (line 561)

fn axis_hit(origin: Vec3, direction: Vec3) -> (f32, bool, Vec3) {
	let quadratic = direction.x * direction.x + direction.z * direction.z;
	let linear = 2.0 * (origin.x * direction.x + origin.z * direction.z);
	let constant = origin.x * origin.x + origin.z * origin.z - AXIS_RADIUS * AXIS_RADIUS;
	let discriminant = linear * linear - 4.0 * quadratic * constant;
	let root = (-linear - discriminant.max(0.0).sqrt()) / (2.0 * quadratic).max(1e-8);
	let hit_y = origin.y + direction.y * root;
	let cylinder = if discriminant >= 0.0 && root > 0.0 && (AXIS_BOTTOM..=AXIS_TOP).contains(&hit_y)
	{
		root
	} else {
		f32::INFINITY
	};
	let cap_center = vec3(0.0, AXIS_TOP, 0.0);
	let cap = sphere_depth(origin, direction, cap_center, AXIS_RADIUS * 1.75);
	let depth = cylinder.min(cap);
	if !depth.is_finite() {
		return (f32::INFINITY, false, vec3(0.0, 1.0, 0.0));
	}
	let point = origin + direction * depth;
	let normal = if cap < cylinder {
		(point - cap_center).normalize()
	} else {
		vec3(point.x, 0.0, point.z).normalize()
	};
	(depth, true, normal)
}

/// Terminal display lift in linear light so braille remains legible on the
/// dark card.
fn tone(color: Vec3) -> Vec3 {
	color * 1.28 + Vec3::rgb(4, 4, 4)
}

/// Per-frame scene state shared by every ray: sun direction, disk spin,
/// glass transition, and the pointer camera offsets.
struct Platter {
	sun:        Vec3,
	angle:      f32,
	transition: f32,
	/// Smoothed pointer camera from [`Welcome`]: (lift, yaw).
	pointer:    (f32, f32),
}

impl Platter {
	fn new(pointer: (f32, f32)) -> Self {
		Self { sun: vec3(-0.55, 1.0, 0.38).normalize(), angle: 0.0, transition: 0.0, pointer }
	}

	/// Floor glow: light shafts, the disk's shadow, tinted transmission
	/// through the glass, and a soft rim reflection.
	fn ground(&self, origin: Vec3, direction: Vec3) -> (Vec3, f32) {
		if direction.y >= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let depth = (FLOOR_Y - origin.y) / direction.y;
		if depth <= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let floor = origin + direction * depth;
		let stage =
			(-0.42 * ((floor.x.abs() / 2.30).powi(4) + ((floor.z + 0.15).abs() / 1.70).powi(4))).exp();

		let sun_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / self.sun.y;
		let sunlit = floor + self.sun * sun_depth;
		let shadow_radius = sunlit.x.hypot(sunlit.z);
		let occlusion = smooth(((DISK_RADIUS + 0.08 - shadow_radius) / 0.16).clamp(0.0, 1.0));
		let rays = sun_rays(floor.x, floor.z);

		let neutral_alpha = stage * rays * (1.0 - occlusion) * 0.36;
		let neutral = (BACKGROUND + vec3(0.36, 0.33, 0.27) * (stage * rays)).clamp01();
		let mut color = neutral * neutral_alpha + BACKGROUND * (1.0 - neutral_alpha);
		let mut alpha = neutral_alpha;

		let transmission_alpha =
			stage * sun_rays(sunlit.x, sunlit.z) * occlusion * self.transition * 0.64;
		let transmission =
			(BACKGROUND + gradient(sunlit.z.atan2(sunlit.x) - self.angle) * 0.86).clamp01();
		color = transmission * transmission_alpha + color * (1.0 - transmission_alpha);
		alpha = transmission_alpha + alpha * (1.0 - transmission_alpha);

		let mirrored = vec3(direction.x, -direction.y, direction.z);
		let reflected_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / mirrored.y.max(1e-6);
		let reflected = floor + mirrored * reflected_depth;
		let reflected_radius = reflected.x.hypot(reflected.z);
		if reflected_radius <= DISK_RADIUS {
			let edge = smooth(((DISK_RADIUS - reflected_radius) / 0.13).clamp(0.0, 1.0));
			let grazing = (1.0 + direction.y).clamp(0.0, 1.0);
			let reflection_alpha = self.transition * edge * (0.22 + 0.28 * grazing);
			let reflection = gradient(reflected.z.atan2(reflected.x) - self.angle);
			color = reflection * reflection_alpha + color * (1.0 - reflection_alpha);
			alpha = reflection_alpha + alpha * (1.0 - reflection_alpha);
		}
		(color, alpha)
	}
}

impl Trace for Platter {
	fn advance(&mut self, now: Duration) -> Camera {
		let elapsed = now.as_secs_f32();
		self.angle = disk_rotation(elapsed);
		self.transition = color_mix(elapsed);
		Camera {
			target:   vec3(0.0, 0.08, 0.0),
			yaw:      self.pointer.1 + reveal_orbit(elapsed) + (elapsed * 0.31).sin() * 0.018,
			pitch:    CAMERA_PITCH,
			distance: CAMERA_DISTANCE,
			lift:     self.pointer.0.clamp(-0.42, 0.42) + (elapsed * 0.55).sin() * 0.014,
			focal:    CAMERA_FOCAL,
		}
	}

	/// Shades one sample: returns the color composited over the card
	/// background and the coverage used for braille dot thresholds.
	fn shade(&self, ray: Ray) -> (Vec3, f32) {
		let Ray { origin, dir: direction } = ray;

		// Top surface of the disk.
		let mut disk_depth = f32::INFINITY;
		let mut disk_point = Vec3::ZERO;
		let mut disk_radial = 0.0;
		if direction.y < 0.0 {
			let depth = (DISK_Y + DISK_HALF_THICKNESS - origin.y) / direction.y;
			if depth > 0.0 {
				let point = origin + direction * depth;
				let radial = point.x.hypot(point.z);
				if radial <= DISK_RADIUS {
					disk_depth = depth;
					disk_point = point;
					disk_radial = radial;
				}
			}
		}
		let disk_visible = disk_depth.is_finite();
		let (axis_depth, axis_visible, axis_normal) = axis_hit(origin, direction);

		let (ground_color, ground_alpha) = self.ground(origin, direction);
		let mut color = ground_color * ground_alpha + BACKGROUND * (1.0 - ground_alpha);
		let mut alpha = ground_alpha;

		let view = direction * -1.0;
		let halfway = if disk_visible || axis_visible {
			(self.sun + view).normalize()
		} else {
			Vec3::ZERO
		};
		let axis_color = if axis_visible {
			let diffuse = axis_normal.dot(self.sun).max(0.0);
			let specular = axis_normal.dot(halfway).max(0.0).powi(44);
			(WHITE * (0.32 + 0.68 * diffuse + 0.48 * specular)).clamp01()
		} else {
			Vec3::ZERO
		};

		if axis_visible && axis_depth > disk_depth {
			color = axis_color;
			alpha = 1.0;
		}

		if disk_visible {
			let diffuse = self.sun.y.max(0.0);
			let specular = halfway.y.max(0.0).powi(72);
			let fresnel = (1.0 - view.y.max(0.0)).powi(4);
			let material_angle = disk_point.z.atan2(disk_point.x) - self.angle;
			let rim = smooth(((disk_radial - (DISK_RADIUS - 0.075)) / 0.055).clamp(0.0, 1.0));
			let streak_angle = (material_angle - 0.32 + PI).rem_euclid(TAU) - PI;
			let streak = (-(streak_angle / 0.19).powi(2)).exp();
			let incident = sun_rays(disk_point.x, disk_point.z);

			let opaque =
				(WHITE * (0.30 + 0.27 * diffuse + 0.36 * incident + 0.20 * specular)).clamp01();
			let glass = (gradient(material_angle) * (0.34 + 0.70 * diffuse)
				+ WHITE * (0.72 * specular + 0.16 * fresnel + 0.20 * streak))
				.clamp01();
			let border_strength = rim * self.transition;
			let mut disk_color = opaque
				.lerp(glass, self.transition)
				.lerp(WHITE, border_strength);

			// Orbiting index marker punched into the surface.
			let marker_x = 0.52 * self.angle.cos();
			let marker_z = 0.52 * self.angle.sin();
			let marker_distance = (disk_point.x - marker_x).hypot(disk_point.z - marker_z);
			let marker = smooth(((0.10 - marker_distance) / 0.035).clamp(0.0, 1.0));
			disk_color = disk_color.lerp(INK, marker);

			let disk_alpha = (1.0 - self.transition * (1.0 - DISK_GLASS_OPACITY))
				.max(border_strength * 0.96)
				.max(marker * 0.98);
			color = disk_color * disk_alpha + color * (1.0 - disk_alpha);
			alpha = disk_alpha + alpha * (1.0 - disk_alpha);
		}

		if axis_visible && axis_depth <= disk_depth {
			color = axis_color;
			alpha = 1.0;
		}
		(tone(color), alpha)
	}

pub fn reflect(self, normal: Self) -> Self

Reflection of this direction around normal.

pub fn refract(self, normal: Self, eta: f32) -> Option<Self>

Refraction through normal at the incident/transmitted IOR ratio.

Returns None when total internal reflection prevents transmission.

pub const fn max_component(self) -> f32

Largest component.

pub const fn is_finite(self) -> bool

Whether every component is finite.

pub const fn clamp01(self) -> Self

Componentwise clamp to 0..=1.

Examples found in repository

examples/chat/welcome.rs (line 610)

	fn ground(&self, origin: Vec3, direction: Vec3) -> (Vec3, f32) {
		if direction.y >= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let depth = (FLOOR_Y - origin.y) / direction.y;
		if depth <= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let floor = origin + direction * depth;
		let stage =
			(-0.42 * ((floor.x.abs() / 2.30).powi(4) + ((floor.z + 0.15).abs() / 1.70).powi(4))).exp();

		let sun_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / self.sun.y;
		let sunlit = floor + self.sun * sun_depth;
		let shadow_radius = sunlit.x.hypot(sunlit.z);
		let occlusion = smooth(((DISK_RADIUS + 0.08 - shadow_radius) / 0.16).clamp(0.0, 1.0));
		let rays = sun_rays(floor.x, floor.z);

		let neutral_alpha = stage * rays * (1.0 - occlusion) * 0.36;
		let neutral = (BACKGROUND + vec3(0.36, 0.33, 0.27) * (stage * rays)).clamp01();
		let mut color = neutral * neutral_alpha + BACKGROUND * (1.0 - neutral_alpha);
		let mut alpha = neutral_alpha;

		let transmission_alpha =
			stage * sun_rays(sunlit.x, sunlit.z) * occlusion * self.transition * 0.64;
		let transmission =
			(BACKGROUND + gradient(sunlit.z.atan2(sunlit.x) - self.angle) * 0.86).clamp01();
		color = transmission * transmission_alpha + color * (1.0 - transmission_alpha);
		alpha = transmission_alpha + alpha * (1.0 - transmission_alpha);

		let mirrored = vec3(direction.x, -direction.y, direction.z);
		let reflected_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / mirrored.y.max(1e-6);
		let reflected = floor + mirrored * reflected_depth;
		let reflected_radius = reflected.x.hypot(reflected.z);
		if reflected_radius <= DISK_RADIUS {
			let edge = smooth(((DISK_RADIUS - reflected_radius) / 0.13).clamp(0.0, 1.0));
			let grazing = (1.0 + direction.y).clamp(0.0, 1.0);
			let reflection_alpha = self.transition * edge * (0.22 + 0.28 * grazing);
			let reflection = gradient(reflected.z.atan2(reflected.x) - self.angle);
			color = reflection * reflection_alpha + color * (1.0 - reflection_alpha);
			alpha = reflection_alpha + alpha * (1.0 - reflection_alpha);
		}
		(color, alpha)
	}
}

impl Trace for Platter {
	fn advance(&mut self, now: Duration) -> Camera {
		let elapsed = now.as_secs_f32();
		self.angle = disk_rotation(elapsed);
		self.transition = color_mix(elapsed);
		Camera {
			target:   vec3(0.0, 0.08, 0.0),
			yaw:      self.pointer.1 + reveal_orbit(elapsed) + (elapsed * 0.31).sin() * 0.018,
			pitch:    CAMERA_PITCH,
			distance: CAMERA_DISTANCE,
			lift:     self.pointer.0.clamp(-0.42, 0.42) + (elapsed * 0.55).sin() * 0.014,
			focal:    CAMERA_FOCAL,
		}
	}

	/// Shades one sample: returns the color composited over the card
	/// background and the coverage used for braille dot thresholds.
	fn shade(&self, ray: Ray) -> (Vec3, f32) {
		let Ray { origin, dir: direction } = ray;

		// Top surface of the disk.
		let mut disk_depth = f32::INFINITY;
		let mut disk_point = Vec3::ZERO;
		let mut disk_radial = 0.0;
		if direction.y < 0.0 {
			let depth = (DISK_Y + DISK_HALF_THICKNESS - origin.y) / direction.y;
			if depth > 0.0 {
				let point = origin + direction * depth;
				let radial = point.x.hypot(point.z);
				if radial <= DISK_RADIUS {
					disk_depth = depth;
					disk_point = point;
					disk_radial = radial;
				}
			}
		}
		let disk_visible = disk_depth.is_finite();
		let (axis_depth, axis_visible, axis_normal) = axis_hit(origin, direction);

		let (ground_color, ground_alpha) = self.ground(origin, direction);
		let mut color = ground_color * ground_alpha + BACKGROUND * (1.0 - ground_alpha);
		let mut alpha = ground_alpha;

		let view = direction * -1.0;
		let halfway = if disk_visible || axis_visible {
			(self.sun + view).normalize()
		} else {
			Vec3::ZERO
		};
		let axis_color = if axis_visible {
			let diffuse = axis_normal.dot(self.sun).max(0.0);
			let specular = axis_normal.dot(halfway).max(0.0).powi(44);
			(WHITE * (0.32 + 0.68 * diffuse + 0.48 * specular)).clamp01()
		} else {
			Vec3::ZERO
		};

		if axis_visible && axis_depth > disk_depth {
			color = axis_color;
			alpha = 1.0;
		}

		if disk_visible {
			let diffuse = self.sun.y.max(0.0);
			let specular = halfway.y.max(0.0).powi(72);
			let fresnel = (1.0 - view.y.max(0.0)).powi(4);
			let material_angle = disk_point.z.atan2(disk_point.x) - self.angle;
			let rim = smooth(((disk_radial - (DISK_RADIUS - 0.075)) / 0.055).clamp(0.0, 1.0));
			let streak_angle = (material_angle - 0.32 + PI).rem_euclid(TAU) - PI;
			let streak = (-(streak_angle / 0.19).powi(2)).exp();
			let incident = sun_rays(disk_point.x, disk_point.z);

			let opaque =
				(WHITE * (0.30 + 0.27 * diffuse + 0.36 * incident + 0.20 * specular)).clamp01();
			let glass = (gradient(material_angle) * (0.34 + 0.70 * diffuse)
				+ WHITE * (0.72 * specular + 0.16 * fresnel + 0.20 * streak))
				.clamp01();
			let border_strength = rim * self.transition;
			let mut disk_color = opaque
				.lerp(glass, self.transition)
				.lerp(WHITE, border_strength);

			// Orbiting index marker punched into the surface.
			let marker_x = 0.52 * self.angle.cos();
			let marker_z = 0.52 * self.angle.sin();
			let marker_distance = (disk_point.x - marker_x).hypot(disk_point.z - marker_z);
			let marker = smooth(((0.10 - marker_distance) / 0.035).clamp(0.0, 1.0));
			disk_color = disk_color.lerp(INK, marker);

			let disk_alpha = (1.0 - self.transition * (1.0 - DISK_GLASS_OPACITY))
				.max(border_strength * 0.96)
				.max(marker * 0.98);
			color = disk_color * disk_alpha + color * (1.0 - disk_alpha);
			alpha = disk_alpha + alpha * (1.0 - disk_alpha);
		}

		if axis_visible && axis_depth <= disk_depth {
			color = axis_color;
			alpha = 1.0;
		}
		(tone(color), alpha)
	}

pub fn lerp(self, to: Self, mix: f32) -> Self

Linear interpolation toward to by mix (0 = self, 1 = to).

Examples found in repository

examples/chat/welcome.rs (line 506)

fn gradient(angle: f32) -> Vec3 {
	let position = (angle / TAU + 0.5).rem_euclid(1.0) * 3.0;
	let index = (position as usize).min(2);
	DISK_STOPS[index].lerp(DISK_STOPS[index + 1], position - index as f32)
}

/// Encodes a linear-light color for the terminal.
fn vec3_color(color: Vec3) -> Color {
	Color::from(color)
}

/// Three soft light shafts crossing the stage in the sun's plane.
fn sun_rays(x: f32, z: f32) -> f32 {
	let length = 0.55_f32.hypot(0.38);
	let (hx, hz) = (-0.55 / length, 0.38 / length);
	let across = x * -hz + z * hx;
	let along = x * hx + z * hz;
	let rays = (-((across + 0.56) / 0.075).powi(2)).exp()
		+ (-((across + 0.04) / 0.055).powi(2)).exp()
		+ (-((across - 0.47) / 0.09).powi(2)).exp();
	let envelope = (-((along + 0.20) / 2.45).powi(4)).exp();
	(rays * envelope).clamp(0.0, 1.0)
}

fn sphere_depth(origin: Vec3, direction: Vec3, center: Vec3, radius: f32) -> f32 {
	let offset = origin - center;
	let projection = offset.dot(direction);
	let discriminant = projection * projection - (offset.dot(offset) - radius * radius);
	let root = -projection - discriminant.max(0.0).sqrt();
	if discriminant >= 0.0 && root > 0.0 {
		root
	} else {
		f32::INFINITY
	}
}

/// Central axis: a capped cylinder with a slightly bulged top sphere.
fn axis_hit(origin: Vec3, direction: Vec3) -> (f32, bool, Vec3) {
	let quadratic = direction.x * direction.x + direction.z * direction.z;
	let linear = 2.0 * (origin.x * direction.x + origin.z * direction.z);
	let constant = origin.x * origin.x + origin.z * origin.z - AXIS_RADIUS * AXIS_RADIUS;
	let discriminant = linear * linear - 4.0 * quadratic * constant;
	let root = (-linear - discriminant.max(0.0).sqrt()) / (2.0 * quadratic).max(1e-8);
	let hit_y = origin.y + direction.y * root;
	let cylinder = if discriminant >= 0.0 && root > 0.0 && (AXIS_BOTTOM..=AXIS_TOP).contains(&hit_y)
	{
		root
	} else {
		f32::INFINITY
	};
	let cap_center = vec3(0.0, AXIS_TOP, 0.0);
	let cap = sphere_depth(origin, direction, cap_center, AXIS_RADIUS * 1.75);
	let depth = cylinder.min(cap);
	if !depth.is_finite() {
		return (f32::INFINITY, false, vec3(0.0, 1.0, 0.0));
	}
	let point = origin + direction * depth;
	let normal = if cap < cylinder {
		(point - cap_center).normalize()
	} else {
		vec3(point.x, 0.0, point.z).normalize()
	};
	(depth, true, normal)
}

/// Terminal display lift in linear light so braille remains legible on the
/// dark card.
fn tone(color: Vec3) -> Vec3 {
	color * 1.28 + Vec3::rgb(4, 4, 4)
}

/// Per-frame scene state shared by every ray: sun direction, disk spin,
/// glass transition, and the pointer camera offsets.
struct Platter {
	sun:        Vec3,
	angle:      f32,
	transition: f32,
	/// Smoothed pointer camera from [`Welcome`]: (lift, yaw).
	pointer:    (f32, f32),
}

impl Platter {
	fn new(pointer: (f32, f32)) -> Self {
		Self { sun: vec3(-0.55, 1.0, 0.38).normalize(), angle: 0.0, transition: 0.0, pointer }
	}

	/// Floor glow: light shafts, the disk's shadow, tinted transmission
	/// through the glass, and a soft rim reflection.
	fn ground(&self, origin: Vec3, direction: Vec3) -> (Vec3, f32) {
		if direction.y >= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let depth = (FLOOR_Y - origin.y) / direction.y;
		if depth <= 0.0 {
			return (BACKGROUND, 0.0);
		}
		let floor = origin + direction * depth;
		let stage =
			(-0.42 * ((floor.x.abs() / 2.30).powi(4) + ((floor.z + 0.15).abs() / 1.70).powi(4))).exp();

		let sun_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / self.sun.y;
		let sunlit = floor + self.sun * sun_depth;
		let shadow_radius = sunlit.x.hypot(sunlit.z);
		let occlusion = smooth(((DISK_RADIUS + 0.08 - shadow_radius) / 0.16).clamp(0.0, 1.0));
		let rays = sun_rays(floor.x, floor.z);

		let neutral_alpha = stage * rays * (1.0 - occlusion) * 0.36;
		let neutral = (BACKGROUND + vec3(0.36, 0.33, 0.27) * (stage * rays)).clamp01();
		let mut color = neutral * neutral_alpha + BACKGROUND * (1.0 - neutral_alpha);
		let mut alpha = neutral_alpha;

		let transmission_alpha =
			stage * sun_rays(sunlit.x, sunlit.z) * occlusion * self.transition * 0.64;
		let transmission =
			(BACKGROUND + gradient(sunlit.z.atan2(sunlit.x) - self.angle) * 0.86).clamp01();
		color = transmission * transmission_alpha + color * (1.0 - transmission_alpha);
		alpha = transmission_alpha + alpha * (1.0 - transmission_alpha);

		let mirrored = vec3(direction.x, -direction.y, direction.z);
		let reflected_depth = (DISK_Y - DISK_HALF_THICKNESS - FLOOR_Y) / mirrored.y.max(1e-6);
		let reflected = floor + mirrored * reflected_depth;
		let reflected_radius = reflected.x.hypot(reflected.z);
		if reflected_radius <= DISK_RADIUS {
			let edge = smooth(((DISK_RADIUS - reflected_radius) / 0.13).clamp(0.0, 1.0));
			let grazing = (1.0 + direction.y).clamp(0.0, 1.0);
			let reflection_alpha = self.transition * edge * (0.22 + 0.28 * grazing);
			let reflection = gradient(reflected.z.atan2(reflected.x) - self.angle);
			color = reflection * reflection_alpha + color * (1.0 - reflection_alpha);
			alpha = reflection_alpha + alpha * (1.0 - reflection_alpha);
		}
		(color, alpha)
	}
}

impl Trace for Platter {
	fn advance(&mut self, now: Duration) -> Camera {
		let elapsed = now.as_secs_f32();
		self.angle = disk_rotation(elapsed);
		self.transition = color_mix(elapsed);
		Camera {
			target:   vec3(0.0, 0.08, 0.0),
			yaw:      self.pointer.1 + reveal_orbit(elapsed) + (elapsed * 0.31).sin() * 0.018,
			pitch:    CAMERA_PITCH,
			distance: CAMERA_DISTANCE,
			lift:     self.pointer.0.clamp(-0.42, 0.42) + (elapsed * 0.55).sin() * 0.014,
			focal:    CAMERA_FOCAL,
		}
	}

	/// Shades one sample: returns the color composited over the card
	/// background and the coverage used for braille dot thresholds.
	fn shade(&self, ray: Ray) -> (Vec3, f32) {
		let Ray { origin, dir: direction } = ray;

		// Top surface of the disk.
		let mut disk_depth = f32::INFINITY;
		let mut disk_point = Vec3::ZERO;
		let mut disk_radial = 0.0;
		if direction.y < 0.0 {
			let depth = (DISK_Y + DISK_HALF_THICKNESS - origin.y) / direction.y;
			if depth > 0.0 {
				let point = origin + direction * depth;
				let radial = point.x.hypot(point.z);
				if radial <= DISK_RADIUS {
					disk_depth = depth;
					disk_point = point;
					disk_radial = radial;
				}
			}
		}
		let disk_visible = disk_depth.is_finite();
		let (axis_depth, axis_visible, axis_normal) = axis_hit(origin, direction);

		let (ground_color, ground_alpha) = self.ground(origin, direction);
		let mut color = ground_color * ground_alpha + BACKGROUND * (1.0 - ground_alpha);
		let mut alpha = ground_alpha;

		let view = direction * -1.0;
		let halfway = if disk_visible || axis_visible {
			(self.sun + view).normalize()
		} else {
			Vec3::ZERO
		};
		let axis_color = if axis_visible {
			let diffuse = axis_normal.dot(self.sun).max(0.0);
			let specular = axis_normal.dot(halfway).max(0.0).powi(44);
			(WHITE * (0.32 + 0.68 * diffuse + 0.48 * specular)).clamp01()
		} else {
			Vec3::ZERO
		};

		if axis_visible && axis_depth > disk_depth {
			color = axis_color;
			alpha = 1.0;
		}

		if disk_visible {
			let diffuse = self.sun.y.max(0.0);
			let specular = halfway.y.max(0.0).powi(72);
			let fresnel = (1.0 - view.y.max(0.0)).powi(4);
			let material_angle = disk_point.z.atan2(disk_point.x) - self.angle;
			let rim = smooth(((disk_radial - (DISK_RADIUS - 0.075)) / 0.055).clamp(0.0, 1.0));
			let streak_angle = (material_angle - 0.32 + PI).rem_euclid(TAU) - PI;
			let streak = (-(streak_angle / 0.19).powi(2)).exp();
			let incident = sun_rays(disk_point.x, disk_point.z);

			let opaque =
				(WHITE * (0.30 + 0.27 * diffuse + 0.36 * incident + 0.20 * specular)).clamp01();
			let glass = (gradient(material_angle) * (0.34 + 0.70 * diffuse)
				+ WHITE * (0.72 * specular + 0.16 * fresnel + 0.20 * streak))
				.clamp01();
			let border_strength = rim * self.transition;
			let mut disk_color = opaque
				.lerp(glass, self.transition)
				.lerp(WHITE, border_strength);

			// Orbiting index marker punched into the surface.
			let marker_x = 0.52 * self.angle.cos();
			let marker_z = 0.52 * self.angle.sin();
			let marker_distance = (disk_point.x - marker_x).hypot(disk_point.z - marker_z);
			let marker = smooth(((0.10 - marker_distance) / 0.035).clamp(0.0, 1.0));
			disk_color = disk_color.lerp(INK, marker);

			let disk_alpha = (1.0 - self.transition * (1.0 - DISK_GLASS_OPACITY))
				.max(border_strength * 0.96)
				.max(marker * 0.98);
			color = disk_color * disk_alpha + color * (1.0 - disk_alpha);
			alpha = disk_alpha + alpha * (1.0 - disk_alpha);
		}

		if axis_visible && axis_depth <= disk_depth {
			color = axis_color;
			alpha = 1.0;
		}
		(tone(color), alpha)
	}

Trait Implementations

impl Add for Vec3

type Output = Vec3

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl AddAssign for Vec3

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl Clone for Vec3

fn clone(&self) -> Vec3

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Vec3

impl Debug for Vec3

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

Formats the value using the given formatter.

impl Default for Vec3

fn default() -> Vec3

Returns the “default value” for a type.

impl Div<f32> for Vec3

type Output = Vec3

The resulting type after applying the / operator.

fn div(self, divisor: f32) -> Self

Performs the / operation.

impl From<Vec3> for Color

Encodes linear-light components through the sRGB transfer function.

fn from(color: Vec3) -> Self

Converts to this type from the input type.

impl Mul for Vec3

type Output = Vec3

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Vec3> for f32

type Output = Vec3

The resulting type after applying the * operator.

fn mul(self, vector: Vec3) -> Vec3

Performs the * operation.

impl Mul<f32> for Vec3

type Output = Vec3

The resulting type after applying the * operator.

fn mul(self, factor: f32) -> Self

Performs the * operation.

impl MulAssign<f32> for Vec3

fn mul_assign(&mut self, factor: f32)

Performs the *= operation.

impl Neg for Vec3

type Output = Vec3

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Vec3

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Vec3

impl Sub for Vec3

type Output = Vec3

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.