107 lines
5.2 KiB
JavaScript
107 lines
5.2 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import * as THREE from 'three';
|
|
import { WindowReveal } from '../src/objects/WindowReveal.ts';
|
|
|
|
const glassZ = 0.6;
|
|
const cameraZ = 3;
|
|
const depthScales = [0, 0.25, 0.4];
|
|
const aspects = [0.7, 1.6];
|
|
const offsets = [
|
|
[0, 0],
|
|
[0.5, 0], [-0.5, 0], [0, 0.5], [0, -0.5], [0.9, 0], [-0.9, 0], [0, 0.9], [0, -0.9],
|
|
[0.5, 0.5], [-0.5, 0.5], [0.5, -0.5], [-0.5, -0.5],
|
|
[0.9, 0.9], [-0.9, 0.9], [0.9, -0.9], [-0.9, -0.9]
|
|
];
|
|
const samples = [-1, -0.75, -0.5, 0, 0.5, 0.75, 1];
|
|
|
|
function makePhoto(width, height, z) {
|
|
const photo = new THREE.Mesh(new THREE.PlaneGeometry(width, height), new THREE.MeshBasicMaterial({ side: THREE.DoubleSide }));
|
|
photo.position.z = z;
|
|
photo.updateMatrixWorld(true);
|
|
return photo;
|
|
}
|
|
|
|
function makePriorFrame(frontWidth, frontHeight) {
|
|
const frameThickness = Math.min(frontWidth, frontHeight) * 0.035;
|
|
const frameDepth = frameThickness * 1.5;
|
|
const frameZ = glassZ + frameDepth * 0.25;
|
|
const geometry = new THREE.BoxGeometry(1, 1, 1);
|
|
const material = new THREE.MeshBasicMaterial({ side: THREE.DoubleSide });
|
|
const left = new THREE.Mesh(geometry, material);
|
|
const right = new THREE.Mesh(geometry, material);
|
|
const top = new THREE.Mesh(geometry, material);
|
|
const bottom = new THREE.Mesh(geometry, material);
|
|
left.position.set(-(frontWidth + frameThickness) * 0.5, 0, frameZ);
|
|
right.position.set((frontWidth + frameThickness) * 0.5, 0, frameZ);
|
|
top.position.set(0, (frontHeight + frameThickness) * 0.5, frameZ);
|
|
bottom.position.set(0, -(frontHeight + frameThickness) * 0.5, frameZ);
|
|
left.scale.set(frameThickness, frontHeight, frameDepth);
|
|
right.scale.set(frameThickness, frontHeight, frameDepth);
|
|
top.scale.set(frontWidth + frameThickness * 2, frameThickness, frameDepth);
|
|
bottom.scale.set(frontWidth + frameThickness * 2, frameThickness, frameDepth);
|
|
const meshes = [left, right, top, bottom];
|
|
meshes.forEach((mesh) => mesh.updateMatrixWorld(true));
|
|
return { meshes, geometry, material };
|
|
}
|
|
|
|
function coveredBy(objects, camera, x, y, frontZ) {
|
|
const point = new THREE.Vector3(x, y, frontZ);
|
|
const direction = point.clone().sub(camera.position).normalize();
|
|
const intersections = new THREE.Raycaster(camera.position, direction).intersectObjects(objects, false);
|
|
return intersections.length > 0;
|
|
}
|
|
|
|
let baselineMisses = 0;
|
|
for (const aspect of aspects) {
|
|
const baseW = aspect;
|
|
const baseH = 1;
|
|
const frontW = baseW * (3 - glassZ) / 3;
|
|
const frontH = baseH * (3 - glassZ) / 3;
|
|
for (const depthScale of depthScales) {
|
|
const backZ = glassZ - 0.04 - depthScale;
|
|
const backW = baseW * (3 - backZ) / 3;
|
|
const backH = baseH * (3 - backZ) / 3;
|
|
const photo = makePhoto(backW, backH, backZ);
|
|
const priorFrame = makePriorFrame(frontW, frontH);
|
|
const material = new THREE.MeshBasicMaterial({ side: THREE.DoubleSide });
|
|
const reveal = new WindowReveal(material);
|
|
reveal.update(frontW, frontH, backW, backH, glassZ, backZ);
|
|
reveal.meshes.forEach((mesh) => mesh.updateMatrixWorld(true));
|
|
for (const [offsetX, offsetY] of offsets) {
|
|
const camera = new THREE.PerspectiveCamera(40, 1, 0.1, 100);
|
|
camera.position.set(offsetX, offsetY, cameraZ);
|
|
camera.lookAt(0, 0, 0);
|
|
for (const xRatio of samples) {
|
|
for (const yRatio of samples) {
|
|
const x = xRatio * frontW / 2;
|
|
const y = yRatio * frontH / 2;
|
|
if (!coveredBy([photo, ...priorFrame.meshes], camera, x, y, glassZ)) baselineMisses += 1;
|
|
assert.equal(coveredBy([photo, ...reveal.meshes], camera, x, y, glassZ), true, `uncovered aperture ray aspect=${aspect} depth=${depthScale} offset=${offsetX},${offsetY} sample=${xRatio},${yRatio}`);
|
|
}
|
|
}
|
|
}
|
|
photo.geometry.dispose(); photo.material.dispose(); priorFrame.geometry.dispose(); priorFrame.material.dispose(); reveal.dispose(); material.dispose();
|
|
}
|
|
}
|
|
|
|
assert.ok(baselineMisses > 0, 'the previous shallow frame must leave some lateral aperture rays uncovered');
|
|
|
|
const reuseMaterial = new THREE.MeshBasicMaterial({ side: THREE.DoubleSide });
|
|
const reusableReveal = new WindowReveal(reuseMaterial);
|
|
reusableReveal.update(0.8, 0.6, 0.85, 0.64, glassZ, 0.52);
|
|
const reusableGeometries = reusableReveal.meshes.map((mesh) => mesh.geometry);
|
|
const reusablePositions = reusableGeometries.map((geometry) => geometry.getAttribute('position'));
|
|
const disposeCounts = reusableGeometries.map((geometry) => {
|
|
let count = 0;
|
|
geometry.addEventListener('dispose', () => { count += 1; });
|
|
return () => count;
|
|
});
|
|
reusableReveal.update(0.9, 0.7, 0.96, 0.75, glassZ, 0.48);
|
|
assert.deepEqual(reusableReveal.meshes.map((mesh) => mesh.geometry), reusableGeometries, 'updates preserve geometry identities');
|
|
assert.deepEqual(reusableGeometries.map((geometry) => geometry.getAttribute('position')), reusablePositions, 'updates preserve position buffer identities');
|
|
reusableReveal.dispose();
|
|
assert.deepEqual(disposeCounts.map((getCount) => getCount()), [1, 1, 1, 1], 'disposal emits exactly once per reveal geometry');
|
|
reuseMaterial.dispose();
|
|
|
|
console.log(`Window reveal coverage passed: ${baselineMisses} previous-frame misses sealed across ${aspects.length} aspects, ${depthScales.length} depth scales, ${offsets.length} view offsets (including neutral) and ${samples.length ** 2} aperture samples; geometry reuse/disposal verified.`);
|