At 19998c2Copy the commit ID
const keys = ["x", "y", "z", "tilt", "turn", "roll", "width", "height", "open", "spark", "cue"];
const mix = (a, b, t) => a + (b - a) * t;
const smoothstep = (t) => t * t * (3 - 2 * t);
const ramp = (t, start, end) => smoothstep(Math.max(0, Math.min(1, (t - start) / (end - start))));
const rotationAxes = { x: "tilt", y: "turn", z: "roll" };
const pointOrder = ["pointUp", "pointRight", "pointDown", "pointLeft"];
const pointHold = .58;
export const pointLoopDuration = 4;
const curledFingers = [
[32, 93, 47, 7],
[35, 89, 49, 2],
[38, 86, 52, -6],
[40, 83, 50, -11],
];
const fist = [[34, 35, 24, -37], ...curledFingers];
const pointingIndex = [0, 0, 0, 7];
const turningIndex = [8, 25, 17, 7];
const thumbs = [[0, 0, 0, -2], ...curledFingers];
function interpolate(from, to, t) {
const pose = { ...to };
for (const key of keys) pose[key] = mix(from[key], to[key], t);
const turn = (((to.roll - from.roll + 180) % 360) + 360) % 360 - 180;
pose.roll = from.roll + turn * t;
pose.shadowAccent = mix(from.shadowAccent ?? 0, to.shadowAccent ?? 0, t);
pose.indexExtension = mix(from.indexExtension ?? 0, to.indexExtension ?? 0, t);
pose.floorView = mix(from.floorView ?? 0, to.floorView ?? 0, t);
pose.pointThumbWrap = mix(from.pointThumbWrap ?? 0, to.pointThumbWrap ?? 0, t);
pose.fistThumbWrap = mix(from.fistThumbWrap ?? 0, to.fistThumbWrap ?? 0, t);
pose.fingers = from.fingers.map((finger, index) =>
finger.map((angle, joint) => mix(angle, to.fingers[index][joint], t)));
return pose;
}
export function createPosePlayer(rest, openFingers, draw, requestFrame, reducedMotion) {
const sphere = { ...rest, spark: 0, sparkX: 0, sparkY: 0, rise: 0, cue: 0 };
const hand = { ...sphere, open: 1, x: -.14, y: -.10, roll: -12, turn: -6, tilt: -4 };
const point = {
...hand, turn: 0, shadowAccent: 1, indexExtension: .19, pointThumbWrap: 1,
fingers: [fist[0], pointingIndex, ...curledFingers.slice(1)],
};
const poses = {
sphere,
open: { ...hand, fingers: openFingers },
fist: {
...hand, y: .04, tilt: -42, turn: -15, roll: -28,
fingers: fist, fistThumbWrap: 1,
},
// These rolls align the straight index's 19° spread with the grid axes.
pointLeft: { ...point, x: .36, tilt: 56, roll: 71 },
pointRight: { ...point, x: -.36, tilt: -42, roll: -109 },
pointUp: { ...point, x: .04, y: -.24, tilt: 0, turn: -46, roll: -19 },
pointDown: { ...point, x: .04, y: .54, tilt: 0, turn: 48, roll: 161 },
// The straight thumb is 54° off the local +Y axis. Rotate it onto ±Y in the scene.
up: { ...hand, y: -.13, tilt: 0, turn: 32, roll: -54, fingers: thumbs, shadowAccent: 1 },
down: { ...hand, y: .17, tilt: 0, turn: -34, roll: 126, fingers: thumbs, shadowAccent: 1 },
};
function pointLoopPose(progress) {
const beat = (progress % 1) * pointOrder.length;
const index = Math.floor(beat);
const phase = beat - index;
const from = poses[pointOrder[index]];
if (phase <= pointHold) return from;
const next = poses[pointOrder[(index + 1) % pointOrder.length]];
const transition = (phase - pointHold) / (1 - pointHold);
const turn = ramp(transition, .14, .88);
const curl = ramp(transition, 0, .36) * (1 - ramp(transition, .46, 1));
const pose = interpolate(from, next, turn);
// Keep the thumb side in view as the pointing finger sweeps up from below.
if (pointOrder[index] === "pointDown") pose.turn += 40 * turn * (1 - turn);
// The finger leads the wrist into the turn and straightens as it settles.
pose.fingers[1] = pointingIndex.map((angle, joint) => mix(angle, turningIndex[joint], curl));
return pose;
}
const adjustedPoses = new Map();
const getPose = (name) => adjustedPoses.get(name) ?? poses[name];
let current;
let target;
let origin;
let elapsed = 0;
function select(name, from = current) {
const next = getPose(name);
if (next === target && from === current) return;
target = next;
origin = current = from;
elapsed = 0;
if (!origin || reducedMotion()) {
current = target;
draw(current);
} else {
requestFrame();
}
}
function step(delta) {
if (current === target) return;
elapsed += delta;
const progress = Math.min(1, elapsed / 270);
const blend = smoothstep(progress);
current = progress === 1 ? target : interpolate(origin, target, blend);
draw(current);
}
function rotation(name) {
const { tilt, turn, roll } = getPose(name);
return { x: tilt, y: turn, z: roll };
}
function applyRotation(next) {
if (current === target || reducedMotion()) {
current = target = next;
draw(current);
} else {
target = next;
requestFrame();
}
}
function rotate(name, axis, degrees) {
const key = rotationAxes[axis];
const pose = getPose(name);
if (pose[key] === degrees) return;
const next = { ...pose, [key]: degrees };
adjustedPoses.set(name, next);
applyRotation(next);
}
function resetRotation(name) {
if (adjustedPoses.delete(name)) applyRotation(poses[name]);
}
return { select, step, rotation, rotate, resetRotation, pointLoopPose, isMoving: () => current !== target };
}