Files

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);
});