Files
vibemake/tests/assembly-animation.test.js

127 lines
6.4 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { Group, PerspectiveCamera, Vector3 } from 'three';
import { AssemblyViewer } from '../js/assembly-viewer.js';
import { ASSEMBLY_PACE, assemblyEase, presentationScrewMotion } from '../js/assembly-animation.js';
import { ScrewTransition, screwDuration } from '../js/assembly-motion.js';
function viewer() {
const v = Object.create(AssemblyViewer.prototype);
v.camera = new PerspectiveCamera(32, 1.6, .01, 50);
v.camera.position.set(0, 0, 2);
v.controls = { target: new Vector3(), update() { return false; } };
v.renderer = { domElement: { style: {} }, shadowMap: {}, render() {} };
v.loop = { invalidate() {} };
v.notifyMotion = () => {};
v.transitions = [];
return v;
}
function animate(v, frame, reduced = false) {
const original = globalThis.matchMedia;
globalThis.matchMedia = () => ({ matches: reduced });
try { v.moveCamera(frame, true); } finally { globalThis.matchMedia = original; }
}
test('insertion ramps up and down gently, never overshooting its exact final position', () => {
assert.equal(assemblyEase(-1), 0);
assert.equal(assemblyEase(2), 1);
assert.ok(assemblyEase(.01) / .01 < .001, 'near-zero initial velocity');
assert.ok((1 - assemblyEase(.99)) / .01 < .001, 'near-zero final velocity');
for (let i = 1; i <= 100; i++) assert.ok(assemblyEase(i / 100) >= assemblyEase((i - 1) / 100));
const v = viewer(), part = new Group();
part.position.set(1, 0, 0);
v.transitions = [{ instance: part, from: part.position.clone(), target: new Vector3(), duration: ASSEMBLY_PACE.insertion, elapsed: 0 }];
v.render(.1);
assert.ok(part.position.x > .99, 'first 100 ms should not launch the part at full speed');
v.render(.45);
assert.ok(part.position.x > .5, 'the old half-second duration must no longer finish the insertion');
v.render(1);
assert.deepEqual(part.position.toArray(), [0, 0, 0]);
});
test('front/back camera pulls back and arcs without fading or crossing through the work', () => {
const v = viewer();
const frame = { position: new Vector3(0, 0, -2), target: new Vector3() };
animate(v, frame);
const duration = v.cameraTransition.motionDuration;
const part = new Group();
part.position.set(1, 0, 0);
v.transitions = [{ instance: part, from: part.position.clone(), target: new Vector3(), duration: 1, elapsed: 0 }];
v.render(duration * .18);
assert.ok(v.camera.position.z > 2, 'pull out before turning');
assert.ok(Math.abs(v.camera.position.x) < 1e-10);
const paused = v.camera.position.clone();
v.setAnimationPaused(true);
v.render(1);
assert.deepEqual(v.camera.position.toArray(), paused.toArray());
v.setAnimationPaused(false);
v.render(duration * .32);
assert.ok(Math.abs(v.camera.position.x) > 2, 'midpoint is beside the work, never through its center');
assert.ok(Math.abs(v.camera.position.z) < 1e-8);
assert.ok(!v.renderer.domElement.style.opacity, 'the canvas stays fully visible');
assert.equal(part.position.x, 1, 'installation waits for the camera');
v.render(duration * .5);
assert.deepEqual(v.camera.position.toArray(), frame.position.toArray());
v.render(ASSEMBLY_PACE.cameraHold + .001);
assert.equal(part.position.x, 1, 'camera settles before insertion');
assert.equal(v.cameraTransition, null);
v.render(.5);
assert.equal(part.position.x, .5);
animate(v, { position: paused, target: new Vector3() });
v.render(.2);
const interrupted = v.camera.position.clone();
v.cancelCameraTransition();
v.render(.2);
assert.deepEqual(v.camera.position.toArray(), interrupted.toArray());
animate(v, frame, true);
assert.equal(v.cameraTransition, null, 'reduced motion uses an immediate visible cut');
assert.deepEqual(v.camera.position.toArray(), frame.position.toArray());
});
test('camera takes the short route across the azimuth seam with no sudden frame jumps', () => {
const v = viewer();
const point = degrees => new Vector3(Math.sin(degrees * Math.PI / 180) * 2, .5, Math.cos(degrees * Math.PI / 180) * 2);
v.camera.position.copy(point(175));
animate(v, { position: point(-175), target: new Vector3() });
assert.ok(Math.abs(v.cameraTransition.theta) < .18);
let previous = v.camera.position.clone();
while (v.cameraTransition) {
v.render(1 / 60);
assert.ok(v.camera.position.distanceTo(previous) < .015, 'continuous motion');
assert.ok(v.camera.position.z < -1.9, 'no long orbit around the front');
previous.copy(v.camera.position);
}
});
test('frame rate does not change the camera path or the time at which it settles', () => {
const a = viewer(), b = viewer();
const frame = { position: new Vector3(.5, .3, 2), target: new Vector3(.1, 0, 0) };
animate(a, frame); animate(b, frame);
for (let i = 0; i < 15; i++) a.render(1 / 30);
for (let i = 0; i < 30; i++) b.render(1 / 60);
assert.ok(a.camera.position.distanceTo(b.camera.position) < 1e-10);
assert.ok(a.cameraTransition && b.cameraTransition);
for (let i = 0; i < 60; i++) a.render(1 / 30);
for (let i = 0; i < 120; i++) b.render(1 / 60);
assert.equal(a.cameraTransition, null); assert.equal(b.cameraTransition, null);
assert.deepEqual(a.camera.position.toArray(), frame.position.toArray());
assert.deepEqual(b.camera.position.toArray(), frame.position.toArray());
});
test('slower screw phases retain authored paths, longer durations and serial tool scheduling', () => {
const original = { type:'screw', approachDuration:.45, engageDuration:.3, tightenDuration:2.4, retractDuration:.35,
axis:[0,0,-1], socketPosition:[0,0,0], toolQuaternion:[0,0,0,1], travel:.002, turns:3, direction:'clockwise', toolClearance:.01 };
const snapshot = JSON.stringify(original), motion = presentationScrewMotion(original);
const part = {position:[0,0,0], quaternion:[0,0,0,1], scale:[1,1,1], installOffset:[0,0,.05], installation:motion};
const one = new ScrewTransition(new Group(), part, new Group(), {tipPosition:[0,0,0]});
const two = new ScrewTransition(new Group(), part, new Group(), {tipPosition:[0,0,0]}, screwDuration(motion));
one.sample(one.duration - .001); two.sample(one.duration - .001);
assert.equal(one.tool.visible, true); assert.equal(two.instance.visible, false);
one.sample(one.duration); two.sample(one.duration);
assert.equal(one.tool.visible, false); assert.equal(two.instance.visible, true);
assert.deepEqual(one.instance.position.toArray(), part.position);
assert.equal(JSON.stringify(original), snapshot);
assert.equal(presentationScrewMotion({...original, approachDuration:4}).approachDuration, 4);
});