185 lines
7.4 KiB
JavaScript
185 lines
7.4 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import { readFile } from "node:fs/promises";
|
|
import vm from "node:vm";
|
|
import { test } from "node:test";
|
|
import * as Three from "../../public/vendor/three/three.module.js";
|
|
|
|
// Exercise real scene geometry/camera math with a minimal rendering boundary. No DOM or GPU
|
|
// is required: these tests cover gesture arbitration and view state, not WebGL rendering.
|
|
const source = (await readFile(new URL("./scene.js", import.meta.url), "utf8"))
|
|
.replace(/^import .*;\r?\n/gm, "")
|
|
.replace(/^export /gm, "");
|
|
|
|
class Surface extends EventTarget {
|
|
style = { touchAction: "" };
|
|
dataset = {};
|
|
hidden = false;
|
|
getBoundingClientRect() { return { left: 0, top: 0, right: 390, bottom: 460, width: 390, height: 460 }; }
|
|
}
|
|
|
|
function setup({ reduced = false } = {}) {
|
|
const window = new Surface();
|
|
const document = new Surface();
|
|
const canvas = new Surface();
|
|
const frames = new Map();
|
|
let nextFrame = 1;
|
|
let failRenderer = false;
|
|
class Renderer {
|
|
shadowMap = {};
|
|
setClearColor() {}
|
|
setPixelRatio() {}
|
|
setSize() {}
|
|
constructor() { if (failRenderer) throw new Error("GPU unavailable"); }
|
|
render(scene, camera) { scene.updateMatrixWorld(true); camera.updateMatrixWorld(true); }
|
|
dispose() { this.disposed = true; }
|
|
}
|
|
class Controls extends Three.EventDispatcher {
|
|
target = new Three.Vector3();
|
|
mouseButtons = {};
|
|
touches = {};
|
|
minDistance = 0;
|
|
maxDistance = Infinity;
|
|
update() {}
|
|
dispose() { this.disposed = true; }
|
|
}
|
|
class Observer { observe() {} disconnect() { this.disconnected = true; } }
|
|
window.matchMedia = (query) => Object.assign(new Surface(), {
|
|
matches: query === "(pointer: coarse)" || (query.includes("reduced-motion") && reduced),
|
|
});
|
|
window.devicePixelRatio = 1;
|
|
const context = vm.createContext({
|
|
THREE: { ...Three, WebGLRenderer: Renderer }, OrbitControls: Controls,
|
|
window, document, Event, performance, console: { warn() {} },
|
|
ResizeObserver: Observer, MutationObserver: Observer, IntersectionObserver: Observer,
|
|
requestAnimationFrame(callback) { const id = nextFrame++; frames.set(id, callback); return id; },
|
|
cancelAnimationFrame(id) { frames.delete(id); },
|
|
});
|
|
vm.runInContext(`${source}\nthis.api = {mountScene,setFloor,setViewMode,resetScene,zoomScene,highlightZone,disposeScene,scenes};`, context);
|
|
const api = context.api;
|
|
const selected = [];
|
|
const layout = JSON.stringify({ floors: [1, 2].map((level) => ({
|
|
level, width_m: 10, depth_m: 10, openings: [], verticals: [],
|
|
zones: [{ label: `층${level}`, kind: "seating", x: 1, y: 1, w: 4, d: 4, furniture: [], evidence_photos: [`p${level}`] }],
|
|
})) });
|
|
const mount = () => api.mountScene(canvas, layout, (label) => selected.push(label));
|
|
const handle = mount();
|
|
const st = api.scenes.get(handle);
|
|
const frame = () => {
|
|
const batch = [...frames.values()];
|
|
frames.clear();
|
|
batch.forEach((callback) => callback());
|
|
};
|
|
frame();
|
|
function point(pin = st.pinMeshes[0]) {
|
|
st.scene.updateMatrixWorld(true);
|
|
st.camera.lookAt(st.controls.target);
|
|
st.camera.updateMatrixWorld(true);
|
|
const v = pin.getWorldPosition(new Three.Vector3()).project(st.camera);
|
|
return { x: (v.x + 1) * 195, y: (1 - v.y) * 230 };
|
|
}
|
|
function pointer(target, type, { id = 1, x, y, primary = true } = {}) {
|
|
const event = new Event(type, { cancelable: true });
|
|
Object.assign(event, { pointerId: id, clientX: x, clientY: y, isPrimary: primary, button: 0 });
|
|
target.dispatchEvent(event);
|
|
}
|
|
return { api, canvas, window, document, selected, handle, st, frame, point, pointer, frames, mount, fail: () => { failRenderer = true; } };
|
|
}
|
|
|
|
test("photo pins work while page scrolling is enabled", () => {
|
|
const t = setup();
|
|
assert.equal(t.canvas.style.touchAction, "pan-y");
|
|
assert.equal(t.st.controls.enabled, false);
|
|
t.api.setFloor(t.handle, 1);
|
|
const p = t.point();
|
|
t.pointer(t.canvas, "pointerdown", p);
|
|
t.pointer(t.window, "pointerup", p);
|
|
assert.deepEqual(t.selected, ["층1"]);
|
|
t.api.disposeScene(t.handle);
|
|
});
|
|
|
|
test("scroll, cancelled, and multi-touch gestures cannot select a pin", () => {
|
|
const t = setup();
|
|
const p = t.point();
|
|
t.pointer(t.canvas, "pointerdown", p);
|
|
t.pointer(t.window, "pointermove", { x: p.x, y: p.y + 12 });
|
|
t.pointer(t.window, "pointerup", p);
|
|
t.pointer(t.canvas, "pointerdown", p);
|
|
t.pointer(t.window, "pointercancel", p);
|
|
t.pointer(t.window, "pointerup", p);
|
|
t.pointer(t.canvas, "pointerdown", p);
|
|
t.pointer(t.canvas, "pointerdown", { ...p, id: 2, primary: false });
|
|
t.pointer(t.window, "pointerup", { ...p, id: 2, primary: false });
|
|
t.pointer(t.window, "pointerup", p);
|
|
t.pointer(t.canvas, "pointerdown", p);
|
|
t.pointer(t.window, "pointerdown", { ...p, id: 2, primary: false });
|
|
t.pointer(t.window, "pointerup", p);
|
|
t.pointer(t.window, "pointerup", { ...p, id: 2, primary: false });
|
|
assert.deepEqual(t.selected, []);
|
|
t.api.disposeScene(t.handle);
|
|
});
|
|
|
|
test("plan mode locks rotation and floor changes preserve its zoom and orientation", () => {
|
|
const t = setup();
|
|
t.api.setFloor(t.handle, 1);
|
|
t.api.setViewMode(t.handle, "plan");
|
|
assert.equal(t.st.controls.enableRotate, false);
|
|
assert.equal(t.st.controls.maxPolarAngle, 0);
|
|
assert.equal(t.st.controls.touches.ONE, Three.TOUCH.PAN);
|
|
t.api.zoomScene(t.handle, 1);
|
|
const offset = t.st.camera.position.clone().sub(t.st.controls.target);
|
|
t.api.setFloor(t.handle, 2);
|
|
assert.ok(offset.distanceTo(t.st.camera.position.clone().sub(t.st.controls.target)) < 1e-10);
|
|
assert.equal(t.st.floorGroups.get(1).group.visible, false);
|
|
t.api.setViewMode(t.handle, "3d");
|
|
assert.equal(t.st.controls.enableRotate, true);
|
|
assert.equal(t.st.floorGroups.get(1).group.visible, true);
|
|
assert.equal(t.st.activeLevel, 2);
|
|
t.api.disposeScene(t.handle);
|
|
});
|
|
|
|
test("reduced motion renders on demand and freezes decorative pins", () => {
|
|
const t = setup({ reduced: true });
|
|
assert.equal(t.st.controls.enableDamping, false);
|
|
assert.equal(t.frames.size, 0);
|
|
assert.ok(t.st.pinMeshes.every((pin) => pin.rotation.y === 0 && pin.position.y === pin.userData.baseY));
|
|
t.api.zoomScene(t.handle, 1);
|
|
assert.equal(t.frames.size, 1);
|
|
t.frame();
|
|
assert.equal(t.frames.size, 0);
|
|
t.api.disposeScene(t.handle);
|
|
});
|
|
|
|
test("context loss reports a recoverable state and disposal cancels work", () => {
|
|
const t = setup();
|
|
let errors = 0;
|
|
let ready = 0;
|
|
t.canvas.addEventListener("scene-error", () => errors++);
|
|
t.canvas.addEventListener("scene-ready", () => ready++);
|
|
const lost = new Event("webglcontextlost", { cancelable: true });
|
|
t.canvas.dispatchEvent(lost);
|
|
assert.equal(lost.defaultPrevented, true);
|
|
assert.equal(errors, 1);
|
|
assert.ok(t.canvas.dataset.sceneError);
|
|
assert.equal(t.frames.size, 0);
|
|
t.canvas.dispatchEvent(new Event("webglcontextrestored"));
|
|
assert.equal(ready, 1);
|
|
assert.equal(t.canvas.dataset.sceneError, "");
|
|
t.api.disposeScene(t.handle);
|
|
assert.equal(t.api.scenes.size, 0);
|
|
assert.equal(t.frames.size, 0);
|
|
assert.equal(t.st.renderer.disposed, true);
|
|
assert.equal(t.st.controls.disposed, true);
|
|
assert.equal(t.canvas.style.touchAction, "");
|
|
t.canvas.dispatchEvent(new Event("webglcontextlost", { cancelable: true }));
|
|
assert.equal(errors, 1);
|
|
});
|
|
|
|
test("unavailable WebGL returns an explicit failure handle instead of throwing", () => {
|
|
const t = setup();
|
|
t.api.disposeScene(t.handle);
|
|
t.fail();
|
|
assert.equal(t.mount(), 0);
|
|
assert.ok(t.canvas.dataset.sceneError);
|
|
assert.equal(t.api.scenes.size, 0);
|
|
});
|