Files
cutaway/sims/piranha-shared/tour_bee.js
T
Nyxera0x 5d8f1c6efe Cutaway skill: build, film and score a 3D object that takes itself apart from one picture
The skill (SKILL.md), the kit for building one HTML page and capturing a 60 fps film, the procedural sound engine, the green page and look, and 3 complete examples: a tarantula, a piranha and a wasp, each with a full film and a 10-second version. The method docs move into docs/ with the README's GIFs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 12:57:09 +03:00

482 lines
25 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// The Vesper AX-6 tour cut 1:1 on the bee's (robobee-shared/tour_v2.js, robobee-sim2/timeline.json), the way the
// hummingbird's was (robohum-shared/tour_bee.js): the same beat times in the same order, the same push-ins and orbits,
// the same 330° explode turntable with the fast reassembly, distances scaled to the fish. The bee's banking fly-in is
// the fish swimming in with a bank and a roll, its tail sweeping and its jaw snapping once near the end of the 3 s; the
// bee's fly-off is a lunge (the jaw snaps and it shoots past the camera). The five assemblies map beat for beat:
// OPTICS = the eye (the bubble lifts, the lens rings unscrew out along the axis, the iris opens), WING = the near
// pectoral fin (it leaves its root and turns over in the air), LEG = the lure (the stalk comes apart link by link with
// a servo spinning in each joint, the cage blooms and the light flares), THORAX = the ribcage (the shields swing off
// and the drive rings slide out spinning 5× faster), ABDOMEN = the jaw (it drops away, the fang rows fly out along their
// rims and snap back).
// The camera rules on top: frame 0 is already the front three-quarter hero view of the still (the eye side and
// the open mouth toward the camera, the fish big and moving); every teardown is shot from that side within about ±35°
// and pushed in on the part; sides change only in the orbits, the turntable and the exit; the camera rides smooth
// splines and follows only the fish's path, never its sway. Labels show only while parts move.
// Script: the entry's timeline.json, {duration, script: [{t, act}]}; act is optics, wing, leg, thorax, abdomen,
// 'exploded', 'assemble' or 'hero' (the lunge). Everything is a pure function of film time t.
import * as THREE from 'three';
import {GAPE_LO} from './piranha.js';
import {VIEWPORT} from './console.js';
const smoother = (x) => {
const u = Math.min(1, Math.max(0, x));
return u * u * u * (u * (u * 6 - 15) + 10);
};
const ss = (a, b, t) => smoother((t - a) / (b - a));
const lerp = (a, b, k) => a + (b - a) * k;
const D2R = Math.PI / 180;
// the bee's distances scaled to the fish (tail tip to lure bulb about 5.3 units against the bee's 3)
const S = 1.6;
// the tail's stroke: radians per second of its sweep while swimming (about 0.5 Hz, heavy), and the cruise level
const STROKE_W = 3.1;
export const STROKE_HZ = STROKE_W / (2 * Math.PI);
const CRUISE = 0.65;
// fish units to metres for the dive panel (the fish is a 1.6 m drone)
const M_PER = 0.3;
const DEPTH0 = 412.6;
export const ASSEMBLIES = ['hero', 'optics', 'wing', 'leg', 'thorax', 'abdomen'];
export const ASSEMBLY_LABEL = {hero: 'HERO', optics: 'OPTICS', wing: 'FIN', leg: 'TAIL', thorax: 'FLANK', abdomen: 'JAW'};
export const DISPLAY2 = ['labels', 'exploded', 'flare', 'turntable'];
export const DISPLAY2_LABEL = {labels: 'LABELS', exploded: 'EXPLODED', flare: 'COIL FLARE', turntable: 'TURNTABLE'};
const BUTTON = {optics: 'optics', wing: 'wing', leg: 'leg', thorax: 'thorax', abdomen: 'abdomen', exploded: 'exploded', assemble: 'exploded', hero: 'hero'};
// each act's own clock, the bee's (seconds after its click): when it opens, when it closes, whether the swim eases off
// (only the ribcage: the fish keeps its slow stroke through the others, its own motion between the beats)
const ACT = {
optics: {open: [0.35, 1.5], close: [2.2, 2.65], stop: false},
wing: {open: [0.45, 1.25], close: [2.35, 2.7], stop: false},
leg: {open: [0.35, 1.45], close: [2.15, 2.55], stop: false},
thorax: {open: [0.3, 1.4], close: [2.1, 2.6], stop: true},
abdomen: {open: [0.3, 1.3], close: [2.0, 2.45], stop: false},
};
// the fin: the bee's full turn over 0.9-2.3 s; the lure's cage blooms behind the stalk and the light flares in it
const WING_FLIP = [0.9, 2.3];
const CAGE = {open: [0.75, 1.6], close: [2.05, 2.5]};
const FLARE = {open: [1.05, 1.5], close: [1.95, 2.4]};
// the jaw's snaps: the one at the end of the swim-in and the one that starts the lunge (start of the shut, seconds)
const SNAP_IN = 2.3;
const DEP = 1.0;
// ------------------------------------------------------------ cameras: [az, el, d, tx, ty, tz, sx, sy], u = seconds on
// az from +z (the fish's right flank, the near side) toward +x (its face): the still's hero view is az 30. The bee's
// angles map onto the hero side: every teardown sits between az -5 and 65. A = the world points of the parts at rest.
export function makeBeeCams(A) {
const add = (p, d) => p.map((v, i) => v + d[i]);
const mid = (a, b, k = 0.5) => a.map((v, i) => v + (b[i] - v) * k);
// the fish's middle at rest (the bulb to the tail, the lure's top to the fins): every close-up aims between it and
// its part, so the push-in lands on the part and the whole fish stays inside the viewport
const C0 = [0.15, 0.3, 0.1];
const lens = mid(C0, add(A.lens, A.eyeAxis.map((v) => v * 0.45)), 0.45).map((v, i) => (i === 1 ? C0[1] + 0.2 : v));
const wing = mid(C0, add(A.finHub, [0.9, -0.35, 1.0]), 0.35).map((v, i) => (i === 1 ? 0.2 : v));
const lure = add(mid(C0, A.lureMid, 0.3), [0.1, 0.06, 0]);
const rib = mid(C0, A.core, 0.4).map((v, i) => (i === 1 ? C0[1] - 0.1 : i === 0 ? v + 0.25 : v));
const jaw = mid(C0, A.jaw, 0.4).map((v, i) => (i === 1 ? -0.03 : v));
// the piranha's close-up targets sit on the parts themselves
const eye = mid(add(A.lens, A.eyeAxis.map((v) => v * 0.3)), C0, 0.15);
const stalk = add(A.lureMid, [0.18, -0.05, 0.05]);
const flank = add(A.core, [0, 0.05, 0.15]);
const mouth = add(A.jaw, [-0.1, 0.25, 0]);
// every close-up keeps pushing in through its whole act and keeps orbiting about 14°/s, so a hold never parks
const push = (a, b, u) => lerp(a, b, ss(0, 2.5, u));
// the explode: wide while it is apart, pushing in through the reassembly toward the hero distance
const ASM = A.asm ?? 3.2;
return {
intro: (u) => {
const k = ss(0, 3.0, u);
return [lerp(2, 32, k), lerp(13, 8, k), lerp(11.2, 10.4, k), C0[0], C0[1] + 0.08, C0[2], 0, -24];
},
// 2026-11-06, the piranha's own cameras: the angler's ones parked the shot (az
// 20-50, el 6-10, the same distance in every beat). Every beat now sits on its part from its own side and height
// and pushes in while the part hangs open: the eye in macro from the face side, the tail stalk from behind, the
// glass flank from above, the jaw from below, the explode passing low round the parts.
optics: (u) => [72 - 8 * u, lerp(10, 18, ss(0, 2.5, u)), push(6.2, 5.0, u), ...eye, 0, -24],
wing: (u) => [10 + 14 * u, 13, push(12.6, 11.1, u), ...wing, 0, -24],
leg: (u) => [-42 + 9 * u, 14, push(8.0, 6.8, u), ...stalk, 0, -24],
thorax: (u) => [4 + 8 * u, 40 - 3 * u, push(8.2, 6.9, u), ...flank, 0, -24],
abdomen: (u) => [56 - 7 * u, -4 + 2 * u, push(8.8, 7.4, u), ...mouth, 0, -24],
// the explode: while the parts fly the camera swings 38° toward the face and drops under them to look up, then
// through the reassembly swings back against the turntable onto the hero side, rises and pushes in, so the whole
// fish turns into the hero view as it snaps together
exploded: (u) => {
const go = ss(0.3, 2.8, u);
const back = ss(ASM, ASM + 1.5, u);
return [34 + 38 * go - 67 * back, lerp(16, 0, go) + 9 * back, lerp(lerp(16.8, 14.8, go), 11.0, ss(ASM + 0.1, ASM + 1.2, u)), 0.1, lerp(0.58, 0.3, ss(ASM, ASM + 1.0, u)) - 0.22 * Math.sin(Math.PI * ss(1.8, 3.0, u)), 0.0, 0, -24];
},
// the turntable stops at 330°, so the fish comes out of it turned -30°: the hero view after it sits 30° lower in
// the world to land on the same side of the fish
hero: (u) => [-2 + 12 * u, 8, 10.3, ...C0, 0, -24],
};
}
export function makeBeeTour(TL, A) {
const CAM2 = makeBeeCams(A);
const SCRIPT = [...TL.script].sort((a, b) => a.t - b.t);
const DURATION = TL.duration;
const EVENTS = SCRIPT.map((e) => e.t);
const AT = {};
for (const e of SCRIPT) (AT[e.act] ??= []).push(e.t);
const at = (act) => AT[act] ?? [];
const T_EXP = at('exploded')[0] ?? 999;
const T_ASM = at('assemble')[0] ?? 999;
const T_END = at('hero')[0] ?? 999;
const T_LUNGE = T_END + DEP;
const win = (act, W, t) => {
let v = 0;
for (const t0 of at(act)) v = Math.max(v, ss(t0 + W.open[0], t0 + W.open[1], t) * (1 - ss(t0 + W.close[0], t0 + W.close[1], t)));
return v;
};
const openOf = (act, t) => win(act, ACT[act], t);
// the full explode: out 0.2-1.8 s after EXPLODED, home 0-1.0 s after it goes off (fast, it snaps)
const explodeAt = (t) => ss(T_EXP + 0.2, T_EXP + 1.8, t) * (1 - ss(T_ASM, T_ASM + 1.0, t));
// the turntable: 330° from the explode to just after the fish is whole again, steady in the middle
const TT = [T_EXP + 0.2, T_ASM + 1.5];
const turnAt = (t) => {
const [a, b] = TT;
if (t <= a) return 0;
const R = 0.6;
const span = b - a;
const v = 330 / (span - R);
const x = Math.min(t, b) - a;
if (x < R) return (v * x * x) / (2 * R);
if (x < span - R) return v * (x - R / 2);
const y = x - (span - R);
return v * (span - 1.5 * R) + v * y - (v * y * y) / (2 * R);
};
const stopAt = (t) => {
let v = 0;
for (const act of Object.keys(ACT)) {
if (!ACT[act].stop) continue;
for (const t0 of at(act)) v = Math.max(v, ss(t0, t0 + 0.45, t) * (1 - ss(t0 + ACT[act].close[1], t0 + ACT[act].close[1] + 0.5, t)));
}
return Math.max(v, ss(T_EXP, T_EXP + 0.45, t) * (1 - ss(T_ASM + 0.9, T_ASM + 1.5, t)));
};
const activity = (t) => Math.max(...Object.keys(ACT).map((a) => openOf(a, t)), explodeAt(t));
const DT = 1 / 240;
const SPIN = [0];
for (let i = 1; i * DT <= DURATION + 1; i++) SPIN.push(SPIN[i - 1] + (1 + 5 * activity((i - 0.5) * DT)) * DT);
const look = (A2, t) => {
const u = Math.max(0, Math.min(A2.length - 2, t / DT));
const i = Math.floor(u);
return A2[i] + (A2[i + 1] - A2[i]) * (u - i);
};
const spinAt = (t) => (t < 0 ? t : look(SPIN, t));
// the swim stroke: heavy while it swims in, a cruise between the beats, held still while a part is off, the full
// stroke again for the wind-up and the lunge
const swimAt = (t) => Math.max(1 - ss(2.5, 3.6, t), CRUISE * (1 - 0.6 * stopAt(t) - 0.4 * Math.min(1, explodeAt(t) * 3)), ss(T_END + 0.1, T_END + 0.8, t));
// the jaw: its gape in degrees, with the snap at the end of the swim-in, the wide wind-up before the lunge and the
// snap that starts it
const snap = (t, t0) => ss(t0, t0 + 0.12, t) * (1 - ss(t0 + 0.2, t0 + 0.55, t));
const gapeAt = (t) => GAPE_LO + 9 * ss(T_END + 0.15, T_END + 0.85, t) * (1 - ss(T_LUNGE, T_LUNGE + 0.12, t)) - 22 * snap(t, SNAP_IN) - 24 * snap(t, T_LUNGE);
// the swim: in from behind-left banking through a turn toward the camera, the cruise, the turntable, the wind-up and
// the lunge past the camera. path is the smooth part the camera follows; the stroke's sway rides on top for the fish
// alone.
const flightAt = (t) => {
const kIn = ss(-0.3, 2.6, t);
const ex = explodeAt(t);
const calm = 1 - Math.min(1, ex * 2.5);
const sw = swimAt(t);
const path = new THREE.Vector3(lerp(-1.3 * S, 0, kIn), lerp(0.4 * S, 0, kIn), lerp(-1.7 * S, 0, kIn));
let yaw = lerp(-48, 0, kIn) + 12 * Math.sin(Math.PI * kIn);
let roll = -22 * Math.sin(Math.PI * Math.min(1, kIn * 1.05)) + (2.2 * Math.sin(t * 1.3 + 1.1) + 3.2 * Math.sin(t * 0.85 + 0.4)) * calm;
let pitch = 5 * Math.sin(Math.PI * kIn) + (1.6 * Math.sin(t * 1.9 + 0.6) + 2.4 * Math.sin(t * 1.2 + 2.0)) * calm;
yaw += turnAt(t);
// the wind-up: it draws back along its heading and turns its head a little toward the camera; the lunge turns it
// back onto the hero line, so it shoots forward and toward the lens and passes the camera on the right
const wind = ss(T_END + 0.1, T_END + 0.9, t);
yaw -= 9 * wind;
pitch += 4 * wind;
{
const h0 = new THREE.Vector3(Math.cos(yaw * D2R), 0, -Math.sin(yaw * D2R));
path.addScaledVector(h0, -0.4 * wind * (1 - ss(T_LUNGE, T_LUNGE + 0.3, t)));
}
if (t > T_LUNGE) {
const u = t - T_LUNGE;
const k = ss(0, 0.8, u);
yaw += 6 * k;
roll += 16 * k;
pitch -= 5 * k;
const h = new THREE.Vector3(Math.cos(yaw * D2R), 0, -Math.sin(yaw * D2R));
path.addScaledVector(h, 1.15 * S * u * u + 0.4 * S * u).add(new THREE.Vector3(0, 0.05 * S * u * u, 0));
}
// the stroke sways the head against the tail; the camera never sees it
const sway = 3.4 * sw * Math.sin(t * STROKE_W + Math.PI) * calm;
const pos = path.clone().add(new THREE.Vector3(0, 0.07 * S * Math.sin(t * 1.1) * calm, 0));
return {pos, path, yaw: yaw + sway, roll, pitch, calm, swim: sw, heading: yaw};
};
// the lure lags the turns: each joint takes the turn the fish made a moment earlier
const LAG = 0.085;
const bendAt = (t) => {
const out = [];
let a = flightAt(t);
for (let k = 0; k < 7; k++) {
const b = flightAt(t - LAG * (k + 1));
out.push([0.55 * D2R * (b.pitch - a.pitch), 0.55 * D2R * (b.yaw - a.yaw) + 0.25 * D2R * (b.roll - a.roll)]);
a = b;
}
return out;
};
// the camera: each act's view, blended over 0.85 s with a short dolly out, tracking the fish's path
const VIEWS = [{t: -1, key: 'intro'}, ...SCRIPT.map((e) => ({t: e.t, key: e.act === 'assemble' ? 'exploded' : e.act}))];
const viewIdx = (t) => {
let i = 0;
while (i < VIEWS.length - 1 && VIEWS[i + 1].t <= t) i++;
return i;
};
const camFn = (V, t) => CAM2[V.key](t - (V.key === 'intro' ? 0 : V.t));
// the reassembly keeps the explode's camera running on the explode's clock, also while the next view blends in
const runOf = (j) => {
while (j > 0 && VIEWS[j].key === 'exploded' && VIEWS[j - 1].key === 'exploded') j--;
return VIEWS[j];
};
const camAt = (t) => {
const i = viewIdx(t);
let o = camFn(runOf(i), t);
if (i > 0 && runOf(i) === VIEWS[i]) {
const k = ss(VIEWS[i].t, VIEWS[i].t + 0.85, t);
if (k < 1) {
const a = camFn(runOf(i - 1), t);
const dAz = ((o[0] - a[0] + 540) % 360) - 180;
const b = o.map((v, j) => lerp(a[j], v, k));
b[0] = a[0] + dAz * k;
b[2] += 0.9 * Math.sin(Math.PI * k);
o = b;
}
}
const f = flightAt(t);
const track = 0.85 - 0.5 * ss(T_LUNGE, T_LUNGE + 1.0, t);
return {az: o[0], el: o[1], d: o[2], tx: o[3] + f.path.x * track, ty: o[4] + f.path.y * track, tz: o[5] + f.path.z * track, sx: o[6], sy: o[7]};
};
const actAt = (t) => VIEWS[viewIdx(t)].key;
const stateAt = (t) => {
const ex = explodeAt(t);
const f = flightAt(t);
const open = Object.fromEntries(Object.keys(ACT).map((a) => [a, openOf(a, t)]));
let finFlip = 0;
for (const t0 of at('wing')) finFlip = Math.max(finFlip, ss(t0 + WING_FLIP[0], t0 + WING_FLIP[1], t));
if (finFlip >= 1) finFlip = 0;
const cage = win('leg', CAGE, t);
// the light flares in the lure act, glows up through the explode and flashes on the wind-up
const flare = Math.max(win('leg', FLARE, t), 0.55 * ss(T_END + 0.2, T_END + 0.8, t) * (1 - ss(T_LUNGE + 0.6, T_LUNGE + 1.4, t)));
const view = actAt(t);
return {
t,
spinT: spinAt(t),
explode: ex,
swim: f.swim,
gape: gapeAt(t),
eye: open.optics,
fin: open.wing,
finFlip,
lure: open.leg,
cage,
flare,
rib: open.thorax,
drop: open.abdomen,
open,
flight: f,
bend: bendAt(t),
cam: camAt(t),
view,
guides: 0.45 + 0.55 * Math.min(1, ex * 2.5 + activity(t)),
turn: turnAt(t),
};
};
const LABELS = {
optics: [['eyeGlass', 'EYE RING', 'LIT · UNDER THE BROW'], ['lensRing', 'LENS RINGS', '3 × THREADED'], ['iris', 'IRIS', '10 BLADES · OPENS 4×'], ['barrel', 'LENS BARREL', 'SLIDES OUT']],
wing: [['fin', 'PECTORAL FIN', 'FROSTED FILM'], ['finHub', 'FIN ROOT', 'PIVOT DRUM']],
leg: [['stalk', 'TAIL STALK', '4 SEGMENTS · TELESCOPING'], ['joint', 'SEGMENT SERVO', 'SPINNING FREE'], ['tailHub', 'TAIL HUB', 'BRACKET · 2 LOBES'], ['tail', 'TAIL FIN', '11 RAYS · FROSTED FILM']],
thorax: [['flank', 'GLASS BARREL', 'CLEAR · LIFTS OFF'], ['rib', 'RIB BANDS', 'HINGED · SWING UP'], ['gear', 'DRIVE GEARS', '2 BIG · 5× SPEED'], ['coil', 'LIT COILS', '2 · GREEN']],
abdomen: [['jaw', 'LOWER JAW', 'DROPS · UNDERBITE'], ['fang', 'LOWER FANGS', 'GLASS · 2 ROWS'], ['upfang', 'UPPER FANGS', 'GLASS · 2 ROWS']],
exploded: [['lens', 'OPTIC HEAD', '2 × LENS'], ['tailHub', 'TAIL', '4 SEGMENTS'], ['gear', 'DRIVE GEARS', 'SPINNING FREE'], ['fin', 'PECTORAL FIN', 'FROSTED FILM'], ['jaw', 'LOWER JAW', 'GLASS FANGS']],
};
const labelAt = (t, s) => {
const v = s.view;
if (ACT[v]) {
const t0 = at(v).filter((x) => x <= t).pop();
const A2 = ACT[v];
return {set: LABELS[v], o: ss(t0 + A2.open[0] + 0.1, t0 + A2.open[0] + 0.45, t) * (1 - ss(t0 + A2.close[0] - 0.25, t0 + A2.close[0], t))};
}
if (v === 'exploded') return {set: LABELS.exploded, o: ss(T_EXP + 0.4, T_EXP + 0.8, t) * (1 - ss(T_EXP + 2.3, T_EXP + 2.6, t))};
return {set: [], o: 0};
};
// the tail's and the near pectoral's angles in degrees, as pose() draws them
const tailDeg = (tt) => (0.14 * Math.sin(tt * 1.6) + 0.4 * swimAt(tt) * Math.sin(tt * STROKE_W)) / D2R;
const finDeg = (tt) => ((0.12 + 0.2 * swimAt(tt)) * Math.sin(tt * 2.2)) / D2R;
const telemetry = (t, s) => {
const f = s.flight;
const stroke = [];
for (let i = 0; i <= 90; i++) {
const tt = t - 4 + (i / 90) * 4;
stroke.push([tailDeg(tt), finDeg(tt)]);
}
const ex = s.explode > 0.04;
const sw = s.swim;
// the servos: FIN R, FIN L, TAIL, JAW, TAIL STALK, DORSAL; a part that is off its mount reads DETACHED
const free = [ex || s.fin > 0.08, ex, ex, ex || s.drop > 0.08, ex || s.lure > 0.08, ex];
const gapeLoad = Math.abs(s.gape - GAPE_LO) / 24;
const base = [0.3 + 0.4 * sw, 0.28 + 0.4 * sw, 0.22 + 0.62 * sw, 0.24 + 0.6 * gapeLoad, 0.3 + 0.08 * Math.abs(s.bend[3][1]) * 40, 0.2 + 0.2 * sw];
const servos = base.map((b, i) => (free[i] ? 0 : Math.max(0, Math.min(1, b + 0.04 * Math.sin(t * 7 + i) + 0.1 * Math.abs(f.roll) / 30))));
const v = s.view;
const opening = ACT[v] ? s.open[v] : 0;
const NAME = {optics: 'OPTICS OPEN', wing: 'FIN OFF', leg: 'TAIL OUT', thorax: 'FLANK OPEN', abdomen: 'JAW DROPPED'};
let status = 'CRUISE';
let kind = 'ok';
if (t < 2.6) status = 'BANKING';
if (ACT[v] && opening > 0.05) [status, kind] = [NAME[v], 'warn'];
if (v === 'exploded') [status, kind] = t < T_ASM ? ['TEARDOWN', 'warn'] : s.explode > 0.04 ? ['REASSEMBLY', 'warn'] : ['CRUISE', 'ok'];
if (t > T_END + 0.1 && t <= T_LUNGE) status = 'WIND-UP';
if (t > T_LUNGE) [status, kind] = ['LUNGE', 'warn'];
const ROW = {optics: 0, leg: 1, thorax: 2, wing: 3, abdomen: 4};
const sub = (i) => {
if (ex) return ['warn', 'DETACHED'];
if (ROW[v] === i && opening > 0.05) return ['warn', i === 3 || i === 4 ? 'DETACHED' : 'OPEN'];
if (i === 3) return sw > 0.05 ? ['ok', `${(STROKE_HZ * 60).toFixed(0)} SPM`] : ['idle', 'FEATHERED'];
if (i === 2) return sw > 0.05 ? ['ok', 'RUNNING'] : ['idle', 'IDLE'];
if (i === 1) return s.flare > 0.1 ? ['warn', 'FLARE'] : ['ok', 'LIT 18%'];
return ['ok', ['TRACKING', '', '', '', 'ARMED', 'SEALED'][i]];
};
const last = SCRIPT.filter((e) => e.t <= t).pop();
const say = (e) => (e.act === 'exploded' ? 'EXPLODED ON' : e.act === 'assemble' ? 'EXPLODED OFF · REASSEMBLE' : e.act === 'hero' ? 'HERO · RELEASE' : `ISOLATE ${ASSEMBLY_LABEL[e.act]}`);
const lungeV = t > T_LUNGE ? (2.3 * S * (t - T_LUNGE) + 0.4 * S) * M_PER : 0;
const speed = lungeV + M_PER * (0.9 * (1 - ss(1.5, 3.0, t)) + 0.35 * sw);
const labels = labelAt(t, s);
const amp = (0.14 + 0.4 * sw) / D2R;
return {
time: t,
dur: DURATION,
lift: Math.max(0, Math.min(1, 0.18 + 0.55 * sw + 0.25 * ss(T_LUNGE, T_LUNGE + 0.4, t) + 0.05 * Math.sin(t * STROKE_W))),
status,
statusKind: kind,
freq: STROKE_HZ * Math.min(1, 0.4 + sw),
amp,
stroke,
chartMax: 40,
chartTicks: [-30, 30],
chartSpan: '−4 S',
playback: 1,
blur: 1,
shutter: 'TAIL · R PECTORAL',
battery: 0.912 - 0.0021 * t,
power: 41 + 120 * Math.pow(sw, 1.4) + 60 * activity(t) + 8 * Math.sin(t * STROKE_W),
volt: 48.2,
motorT: 22 + 0.35 * t,
servos,
legsFree: free.some((x) => x),
legFreeEach: free,
depth: DEPTH0 - M_PER * f.pos.y * 4,
vs: -M_PER * 0.07 * S * 1.1 * Math.cos(t * 1.1) * f.calm,
pitch: f.pitch,
roll: f.roll,
airspeed: speed,
trim: s.explode > 0.04 ? 'FREE' : t > T_LUNGE ? 'STRIKE' : 'NEUTRAL',
view: v === 'intro' ? 'hero' : v === 'exploded' ? null : v,
display: {labels: labels.o > 0.5, exploded: t >= T_EXP && t < T_ASM, flare: s.flare > 0.2, turntable: s.turn > 0 && t < TT[1]},
subs: [0, 1, 2, 3, 4, 5].map(sub),
focus: ROW[v] ?? (v === 'exploded' ? 5 : -1),
events: EVENTS,
next: `${EVENTS.length} OPERATOR ACTIONS`,
log: last ? `OPERATOR · ${say(last)}` : 'INBOUND · BANKING IN',
mode: status,
modeSub:
status === 'BANKING'
? `BANK ${f.roll.toFixed(0)}° · INBOUND`
: status === 'TEARDOWN' || status === 'REASSEMBLY'
? `TURNTABLE ${Math.round(s.turn)}° · ${Math.round(s.explode * 100)}% APART`
: status === 'LUNGE'
? `STRIKE · ${speed.toFixed(1)} M/S`
: status === 'WIND-UP'
? `JAW ${s.gape.toFixed(0)}° · MOUTH OPEN`
: ACT[v] && opening > 0.05
? `${ASSEMBLY_LABEL[v]} · ${Math.round(opening * 100)}% APART`
: `DEPTH ${(DEPTH0 - M_PER * f.pos.y * 4).toFixed(1)} M · STATION`,
viewNote: `ISOLATE · ${v === 'intro' || v === 'hero' ? 'HERO' : v === 'exploded' ? 'ALL' : ASSEMBLY_LABEL[v]}`,
labelSet: labels,
};
};
return {SCRIPT, DURATION, stateAt, telemetry, camAt, flightAt};
}
/** Labels in two columns at the viewport's edges, from a set of anchors. */
export function makeLabels(st, fish) {
const p = new THREE.Vector3();
return ({set, o}) => {
if (o < 0.02) return [];
const pts = [];
for (const [key, name, sub] of set) {
const A = fish.anchors[key];
if (!A) continue;
A.obj.updateWorldMatrix(true, false);
const at = st.project(A.obj.localToWorld(p.copy(A.at)));
if (at && at[0] > VIEWPORT.x0 + 30 && at[0] < VIEWPORT.x1 - 30 && at[1] > VIEWPORT.y0 + 40 && at[1] < VIEWPORT.y1 - 70) pts.push({name, sub, at});
}
const mid = (VIEWPORT.x0 + VIEWPORT.x1) / 2;
const out = [];
const stack = (col, x, w) => {
let y = Math.max(VIEWPORT.y0 + 48, Math.min(col.length ? col[0].at[1] - 10 : 0, VIEWPORT.y1 - 110 - 34 * col.length));
for (const c of col) {
y = Math.max(y, Math.min(VIEWPORT.y1 - 110, c.at[1] - 10));
out.push({name: c.name, sub: c.sub, at: c.at, label: [x, y], w, o});
y += 34;
}
};
stack(pts.filter((x) => x.at[0] < mid).sort((a, b) => a.at[1] - b.at[1]), VIEWPORT.x0 + 16, 168);
stack(pts.filter((x) => x.at[0] >= mid).sort((a, b) => a.at[1] - b.at[1]), VIEWPORT.x1 - 160, 150);
return out;
};
}
// ------------------------------------------------------------ the operator's pointer, on the act buttons
const GUTTER_X = 1262;
export function makeCursor(ui, SCRIPT) {
const EV = SCRIPT.filter((e) => e.t > 0).map((e) => ({t: e.t, spot: ui.spots[BUTTON[e.act]]}));
const WP = [[0, GUTTER_X, EV[0].spot[1] + 60]];
let [px, py, pt] = [GUTTER_X, EV[0].spot[1] + 60, 0];
EV.forEach((e, n) => {
const [x, y] = e.spot;
const travel = Math.min(0.7, 0.3 + Math.hypot(x - px, y - py) / 900);
const arrive = e.t - 0.1;
if (arrive - travel - pt > 1.4) {
const rest = [GUTTER_X, Math.max(170, Math.min(720, y + 40))];
WP.push([pt + 0.7, ...rest]);
WP.push([arrive - travel, ...rest]);
} else WP.push([Math.max(pt + 0.01, arrive - travel), px, py]);
WP.push([arrive, x, y], [e.t + 0.18, x, y]);
[px, py, pt] = [x, y, e.t + 0.18];
const next = EV[n + 1];
if (!next || next.t - 0.1 - 0.7 - pt > 0.8) {
[px, py, pt] = [GUTTER_X, y + 12, pt + 0.55];
WP.push([pt, px, py]);
}
});
WP.push([pt + 0.9, GUTTER_X, Math.min(720, py + 50)]);
return (t) => {
let i = 0;
while (i < WP.length - 2 && t > WP[i + 1][0]) i++;
const [t0, x0, y0] = WP[i];
const [t1, x1, y1] = WP[i + 1];
const k = ss(t0, t1, t);
const len = Math.hypot(x1 - x0, y1 - y0);
const bow = Math.sin(Math.PI * k) * Math.min(22, len * 0.07);
let press = false;
let ring = 0;
let rx = 0;
let ry = 0;
for (const e of EV) {
if (t >= e.t - 0.07 && t < e.t + 0.09) press = true;
if (t >= e.t && t < e.t + 0.55) {
ring = 1 - (t - e.t) / 0.55;
[rx, ry] = e.spot;
}
}
return {x: x0 + (x1 - x0) * k + (len ? (-(y1 - y0) / len) * bow : 0), y: y0 + (y1 - y0) * k + (len ? ((x1 - x0) / len) * bow : 0), press, ring, ringX: rx, ringY: ry};
};
}