@pascal-app/viewer 0.8.0 → 0.9.2

package/dist/lib/polygon-union.js

@@ -0,0 +1,289 @@
+const EPSILON = 1e-7;
+const KEY_SCALE = 1e6;
+function pointsEqual(a, b, tolerance = EPSILON) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]) <= tolerance;
+}
+function pointKey(point) {
+    return `${Math.round(point[0] * KEY_SCALE)}:${Math.round(point[1] * KEY_SCALE)}`;
+}
+function interpolate(a, b, t) {
+    return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+}
+function cross(ax, ay, bx, by) {
+    return ax * by - ay * bx;
+}
+function polygonArea(points) {
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const current = points[i];
+        const next = points[(i + 1) % points.length];
+        area += current[0] * next[1] - next[0] * current[1];
+    }
+    return area / 2;
+}
+function pointOnSegment(point, start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const crossValue = cross(point[0] - start[0], point[1] - start[1], dx, dz);
+    if (Math.abs(crossValue) > EPSILON)
+        return false;
+    const dot = (point[0] - start[0]) * (point[0] - end[0]) + (point[1] - start[1]) * (point[1] - end[1]);
+    return dot <= EPSILON;
+}
+function pointInPolygonOrOnBoundary(point, polygon) {
+    if (polygon.some((start, index) => pointOnSegment(point, start, polygon[(index + 1) % polygon.length]))) {
+        return true;
+    }
+    return pointInPolygon(point, polygon);
+}
+function pointInPolygon(point, polygon) {
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const pi = polygon[i];
+        const pj = polygon[j];
+        if (pointOnSegment(point, pj, pi))
+            return false;
+        const intersects = pi[1] > point[1] !== pj[1] > point[1] &&
+            point[0] < ((pj[0] - pi[0]) * (point[1] - pi[1])) / (pj[1] - pi[1]) + pi[0];
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+function normalizeRing(ring) {
+    const normalized = [];
+    for (const [x, z] of ring) {
+        if (!Number.isFinite(x) || !Number.isFinite(z))
+            continue;
+        const point = [x, z];
+        const previous = normalized[normalized.length - 1];
+        if (!previous || !pointsEqual(previous, point)) {
+            normalized.push(point);
+        }
+    }
+    const first = normalized[0];
+    const last = normalized[normalized.length - 1];
+    if (first && last && pointsEqual(first, last)) {
+        normalized.pop();
+    }
+    if (normalized.length < 3 || Math.abs(polygonArea(normalized)) <= EPSILON)
+        return [];
+    return polygonArea(normalized) < 0 ? [...normalized].reverse() : normalized;
+}
+function addSplit(edge, t) {
+    if (t < -EPSILON || t > 1 + EPSILON)
+        return;
+    const clamped = Math.max(0, Math.min(1, t));
+    if (edge.splits.some((split) => Math.abs(split - clamped) <= EPSILON))
+        return;
+    edge.splits.push(clamped);
+}
+function parameterOnEdge(point, edge) {
+    const dx = edge.end[0] - edge.start[0];
+    const dz = edge.end[1] - edge.start[1];
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared <= EPSILON)
+        return 0;
+    return ((point[0] - edge.start[0]) * dx + (point[1] - edge.start[1]) * dz) / lengthSquared;
+}
+function addIntersectionSplits(left, right) {
+    const rx = left.end[0] - left.start[0];
+    const rz = left.end[1] - left.start[1];
+    const sx = right.end[0] - right.start[0];
+    const sz = right.end[1] - right.start[1];
+    const qpx = right.start[0] - left.start[0];
+    const qpz = right.start[1] - left.start[1];
+    const denominator = cross(rx, rz, sx, sz);
+    const numerator = cross(qpx, qpz, rx, rz);
+    if (Math.abs(denominator) <= EPSILON) {
+        if (Math.abs(numerator) > EPSILON)
+            return;
+        for (const point of [left.start, left.end, right.start, right.end]) {
+            if (pointOnSegment(point, left.start, left.end) &&
+                pointOnSegment(point, right.start, right.end)) {
+                addSplit(left, parameterOnEdge(point, left));
+                addSplit(right, parameterOnEdge(point, right));
+            }
+        }
+        return;
+    }
+    const t = cross(qpx, qpz, sx, sz) / denominator;
+    const u = cross(qpx, qpz, rx, rz) / denominator;
+    if (t < -EPSILON || t > 1 + EPSILON || u < -EPSILON || u > 1 + EPSILON)
+        return;
+    addSplit(left, t);
+    addSplit(right, u);
+}
+function buildEdges(polygons) {
+    const edges = [];
+    polygons.forEach((polygon, polygonIndex) => {
+        for (let i = 0; i < polygon.length; i++) {
+            edges.push({
+                start: polygon[i],
+                end: polygon[(i + 1) % polygon.length],
+                polygonIndex,
+                splits: [0, 1],
+            });
+        }
+    });
+    for (let i = 0; i < edges.length; i++) {
+        for (let j = i + 1; j < edges.length; j++) {
+            const left = edges[i];
+            const right = edges[j];
+            if (left.polygonIndex === right.polygonIndex)
+                continue;
+            addIntersectionSplits(left, right);
+        }
+    }
+    return edges;
+}
+function buildBoundarySegments(edges, polygons) {
+    const segments = [];
+    for (const edge of edges) {
+        const splits = [...edge.splits].sort((a, b) => a - b);
+        for (let i = 0; i < splits.length - 1; i++) {
+            const startT = splits[i];
+            const endT = splits[i + 1];
+            if (endT - startT <= EPSILON)
+                continue;
+            const start = interpolate(edge.start, edge.end, startT);
+            const end = interpolate(edge.start, edge.end, endT);
+            const mid = interpolate(edge.start, edge.end, (startT + endT) / 2);
+            const insideAnother = polygons.some((polygon, index) => index !== edge.polygonIndex && pointInPolygon(mid, polygon));
+            if (!insideAnother) {
+                segments.push({ start, end, used: false });
+            }
+        }
+    }
+    return removeDuplicateInteriorSegments(segments);
+}
+function segmentKey(segment) {
+    const start = pointKey(segment.start);
+    const end = pointKey(segment.end);
+    return start < end ? `${start}|${end}` : `${end}|${start}`;
+}
+function removeDuplicateInteriorSegments(segments) {
+    const groups = new Map();
+    for (const segment of segments) {
+        const key = segmentKey(segment);
+        const group = groups.get(key);
+        if (group) {
+            group.push(segment);
+        }
+        else {
+            groups.set(key, [segment]);
+        }
+    }
+    const result = [];
+    for (const group of groups.values()) {
+        if (group.length === 1) {
+            result.push(group[0]);
+            continue;
+        }
+        const firstStart = pointKey(group[0].start);
+        const firstEnd = pointKey(group[0].end);
+        const hasOppositeDirection = group.some((segment) => pointKey(segment.start) === firstEnd && pointKey(segment.end) === firstStart);
+        if (!hasOppositeDirection) {
+            result.push(group[0]);
+        }
+    }
+    return result;
+}
+function assembleRings(segments) {
+    const byStart = new Map();
+    for (const segment of segments) {
+        const key = pointKey(segment.start);
+        const group = byStart.get(key);
+        if (group) {
+            group.push(segment);
+        }
+        else {
+            byStart.set(key, [segment]);
+        }
+    }
+    const rings = [];
+    for (const firstSegment of segments) {
+        if (firstSegment.used)
+            continue;
+        firstSegment.used = true;
+        const ring = [firstSegment.start, firstSegment.end];
+        const startKey = pointKey(firstSegment.start);
+        let currentKey = pointKey(firstSegment.end);
+        while (currentKey !== startKey) {
+            const next = byStart.get(currentKey)?.find((segment) => !segment.used);
+            if (!next)
+                break;
+            next.used = true;
+            ring.push(next.end);
+            currentKey = pointKey(next.end);
+        }
+        if (currentKey !== startKey)
+            continue;
+        const last = ring[ring.length - 1];
+        if (last && pointsEqual(ring[0], last)) {
+            ring.pop();
+        }
+        const normalized = normalizeRing(ring);
+        if (normalized.length >= 3) {
+            rings.push(normalized);
+        }
+    }
+    return rings;
+}
+export function unionPolygons(polygons) {
+    const validPolygons = polygons.map(normalizeRing).filter((polygon) => polygon.length >= 3);
+    if (validPolygons.length <= 1)
+        return validPolygons;
+    const edges = buildEdges(validPolygons);
+    const segments = buildBoundarySegments(edges, validPolygons);
+    const rings = assembleRings(segments);
+    return rings.length > 0 ? rings : validPolygons;
+}
+function buildDifferenceBoundarySegments(edges, polygons) {
+    const subject = polygons[0];
+    const cutters = polygons.slice(1);
+    if (!subject)
+        return [];
+    const segments = [];
+    for (const edge of edges) {
+        const splits = [...edge.splits].sort((a, b) => a - b);
+        for (let i = 0; i < splits.length - 1; i++) {
+            const startT = splits[i];
+            const endT = splits[i + 1];
+            if (endT - startT <= EPSILON)
+                continue;
+            const start = interpolate(edge.start, edge.end, startT);
+            const end = interpolate(edge.start, edge.end, endT);
+            const mid = interpolate(edge.start, edge.end, (startT + endT) / 2);
+            if (edge.polygonIndex === 0) {
+                const insideCutter = cutters.some((cutter) => pointInPolygonOrOnBoundary(mid, cutter));
+                if (!insideCutter) {
+                    segments.push({ start, end, used: false });
+                }
+                continue;
+            }
+            const insideSubject = pointInPolygon(mid, subject);
+            const insideAnotherCutter = cutters.some((cutter, cutterIndex) => cutterIndex !== edge.polygonIndex - 1 && pointInPolygonOrOnBoundary(mid, cutter));
+            if (insideSubject && !insideAnotherCutter) {
+                segments.push({ start: end, end: start, used: false });
+            }
+        }
+    }
+    return removeDuplicateInteriorSegments(segments);
+}
+export function subtractPolygonsFromPolygon(subject, cutters) {
+    const validSubject = normalizeRing(subject);
+    if (validSubject.length < 3)
+        return [];
+    const validCutters = cutters.map(normalizeRing).filter((polygon) => polygon.length >= 3);
+    if (validCutters.length === 0)
+        return [validSubject];
+    const polygons = [validSubject, ...validCutters];
+    const edges = buildEdges(polygons);
+    const segments = buildDifferenceBoundarySegments(edges, polygons);
+    const rings = assembleRings(segments);
+    if (rings.length > 0)
+        return rings;
+    const fullyCovered = validSubject.every((point) => validCutters.some((cutter) => pointInPolygonOrOnBoundary(point, cutter)));
+    return fullyCovered ? [] : [validSubject];
+}

package/dist/lib/polygon-union.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=polygon-union.test.d.ts.map

package/dist/lib/polygon-union.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-union.test.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-union.test.ts"],"names":[],"mappings":""}

package/dist/lib/polygon-union.test.js

@@ -0,0 +1,105 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { subtractPolygonsFromPolygon, unionPolygons } from './polygon-union';
+function polygonArea(points) {
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const current = points[i];
+        const next = points[(i + 1) % points.length];
+        area += current[0] * next[1] - next[0] * current[1];
+    }
+    return Math.abs(area / 2);
+}
+describe('unionPolygons', () => {
+    test('collapses a contained polygon into the containing polygon', () => {
+        const small = [
+            [0, 0],
+            [1, 0],
+            [1, 1],
+            [0, 1],
+        ];
+        const large = [
+            [-1, -1],
+            [2, -1],
+            [2, 2],
+            [-1, 2],
+        ];
+        const result = unionPolygons([small, large]);
+        expect(result).toHaveLength(1);
+        expect(polygonArea(result[0])).toBeCloseTo(9);
+    });
+    test('combines overlapping rectangles into one boundary', () => {
+        const left = [
+            [0, 0],
+            [2, 0],
+            [2, 2],
+            [0, 2],
+        ];
+        const right = [
+            [1, 1],
+            [3, 1],
+            [3, 3],
+            [1, 3],
+        ];
+        const result = unionPolygons([left, right]);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toHaveLength(8);
+        expect(polygonArea(result[0])).toBeCloseTo(7);
+    });
+    test('keeps disjoint polygons as separate boundaries', () => {
+        const left = [
+            [0, 0],
+            [1, 0],
+            [1, 1],
+            [0, 1],
+        ];
+        const right = [
+            [2, 0],
+            [3, 0],
+            [3, 1],
+            [2, 1],
+        ];
+        const result = unionPolygons([left, right]);
+        expect(result).toHaveLength(2);
+        expect(result.map(polygonArea)).toEqual([1, 1]);
+    });
+});
+describe('subtractPolygonsFromPolygon', () => {
+    test('turns a boundary-overlapping cutter into an indentation', () => {
+        const slab = [
+            [0, 0],
+            [4, 0],
+            [4, 3],
+            [0, 3],
+        ];
+        const cutout = [
+            [1, -0.5],
+            [3, -0.5],
+            [3, 1],
+            [1, 1],
+        ];
+        const result = subtractPolygonsFromPolygon(slab, [cutout]);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toContainEqual([1, 1]);
+        expect(result[0]).toContainEqual([3, 1]);
+        expect(polygonArea(result[0])).toBeCloseTo(10);
+    });
+    test('returns separate contours when a cutter splits the subject', () => {
+        const slab = [
+            [0, 0],
+            [4, 0],
+            [4, 3],
+            [0, 3],
+        ];
+        const cutout = [
+            [1.5, -1],
+            [2.5, -1],
+            [2.5, 4],
+            [1.5, 4],
+        ];
+        const result = subtractPolygonsFromPolygon(slab, [cutout]);
+        expect(result).toHaveLength(2);
+        expect(result.map(polygonArea).sort((a, b) => a - b)).toEqual([4.5, 4.5]);
+    });
+});

package/dist/lib/scene-themes.d.ts

@@ -0,0 +1,30 @@
+import type { SurfaceRole } from '@pascal-app/core';
+export type SceneTheme = {
+    id: string;
+    name: string;
+    appearance: 'light' | 'dark';
+    background: string;
+    backgroundSky?: string;
+    ground: string;
+    ambient: {
+        color: string;
+        intensity: number;
+    };
+    hemi?: {
+        sky: string;
+        ground: string;
+        intensity: number;
+    };
+    lights: Array<{
+        position: [number, number, number];
+        color: string;
+        intensity: number;
+        castShadow?: boolean;
+    }>;
+    toneMappingExposure: number;
+    clayTints?: Partial<Record<SurfaceRole, string>>;
+};
+export declare const SCENE_THEMES: SceneTheme[];
+export declare const SCENE_THEME_IDS: string[];
+export declare function getSceneTheme(id: string): SceneTheme;
+//# sourceMappingURL=scene-themes.d.ts.map

package/dist/lib/scene-themes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-themes.d.ts","sourceRoot":"","sources":["../../src/lib/scene-themes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IAIZ,UAAU,EAAE,OAAO,GAAG,MAAM,CAAA;IAC5B,UAAU,EAAE,MAAM,CAAA;IAIlB,aAAa,CAAC,EAAE,MAAM,CAAA;IAItB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7C,IAAI,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IACzD,MAAM,EAAE,KAAK,CAAC;QACZ,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;QAClC,KAAK,EAAE,MAAM,CAAA;QACb,SAAS,EAAE,MAAM,CAAA;QACjB,UAAU,CAAC,EAAE,OAAO,CAAA;KACrB,CAAC,CAAA;IACF,mBAAmB,EAAE,MAAM,CAAA;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;CACjD,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,UAAU,EAoMpC,CAAA;AAED,eAAO,MAAM,eAAe,UAAwC,CAAA;AAIpE,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,CAEpD"}

package/dist/lib/scene-themes.js

@@ -0,0 +1,202 @@
+export const SCENE_THEMES = [
+    {
+        id: 'studio',
+        name: 'Studio',
+        appearance: 'light',
+        background: '#fbfbfa',
+        backgroundSky: '#b6cfe7',
+        ground: '#e9e7e2',
+        ambient: { color: '#ffffff', intensity: 0.15 },
+        hemi: { sky: '#ffffff', ground: '#aaa49a', intensity: 0.45 },
+        lights: [
+            { position: [10, 10, 10], color: '#ffffff', intensity: 4, castShadow: true },
+            { position: [-10, 10, -10], color: '#ffffff', intensity: 0.6 },
+        ],
+        toneMappingExposure: 0.9,
+        clayTints: {
+            wall: '#e9e5db',
+            floor: '#d8d2c4',
+            ceiling: '#f1ede4',
+            roof: '#c4bba6',
+            glazing: '#cdd8df',
+        },
+    },
+    {
+        id: 'paper',
+        name: 'Paper',
+        appearance: 'light',
+        background: '#ede9df',
+        backgroundSky: '#c0d2e4',
+        ground: '#e7e1d3',
+        ambient: { color: '#fff9eb', intensity: 0.55 },
+        hemi: { sky: '#fff5d9', ground: '#c2b89c', intensity: 0.35 },
+        lights: [
+            { position: [16, 22, 12], color: '#fff1c8', intensity: 2.6, castShadow: true },
+            { position: [-14, 10, -6], color: '#dde5ff', intensity: 0.35 },
+        ],
+        toneMappingExposure: 1,
+        clayTints: {
+            wall: '#efe9da',
+            floor: '#ddd4bf',
+            ceiling: '#f5efe0',
+            roof: '#b9b09a',
+            glazing: '#cdd5d8',
+        },
+    },
+    {
+        id: 'sunset',
+        name: 'Sunset',
+        appearance: 'light',
+        background: '#f6e8d4',
+        backgroundSky: '#b5bede',
+        ground: '#ecd9bf',
+        ambient: { color: '#ffd9a8', intensity: 0.45 },
+        hemi: { sky: '#ffd9a8', ground: '#5b4634', intensity: 0.4 },
+        lights: [
+            { position: [22, 8, 8], color: '#ffb070', intensity: 3.4, castShadow: true },
+            { position: [-14, 16, -10], color: '#a4b8ff', intensity: 0.4 },
+        ],
+        toneMappingExposure: 1,
+        clayTints: {
+            wall: '#f3e3cf',
+            floor: '#e2cdab',
+            ceiling: '#f6e7d2',
+            roof: '#a6764f',
+            glazing: '#e7c9a8',
+        },
+    },
+    {
+        id: 'overcast',
+        name: 'Overcast',
+        appearance: 'light',
+        background: '#e6e7e6',
+        backgroundSky: '#c3ccd6',
+        ground: '#dadcd9',
+        ambient: { color: '#eef0ef', intensity: 1.1 },
+        hemi: { sky: '#f4f5f3', ground: '#bcbfbb', intensity: 0.9 },
+        lights: [{ position: [12, 28, 10], color: '#f4f5f3', intensity: 0.8, castShadow: true }],
+        toneMappingExposure: 0.9,
+        clayTints: {
+            wall: '#dedfdc',
+            floor: '#cdcec9',
+            ceiling: '#e8e9e6',
+            roof: '#a3a49e',
+            glazing: '#c6cdd0',
+        },
+    },
+    {
+        id: 'blueprint',
+        name: 'Blueprint',
+        appearance: 'light',
+        background: '#dde6ef',
+        backgroundSky: '#a5c4e2',
+        ground: '#c9d6e6',
+        ambient: { color: '#cfdcec', intensity: 0.7 },
+        hemi: { sky: '#dfeaf6', ground: '#5b6b80', intensity: 0.55 },
+        lights: [
+            { position: [16, 24, 12], color: '#e6efff', intensity: 1.8, castShadow: true },
+            { position: [-12, 10, -8], color: '#9fb6d8', intensity: 0.4 },
+        ],
+        toneMappingExposure: 0.9,
+        clayTints: {
+            wall: '#9fb6d2',
+            floor: '#8ba2c2',
+            ceiling: '#aec0d8',
+            roof: '#5f789b',
+            glazing: '#b6d7ea',
+        },
+    },
+    {
+        id: 'mediterranean',
+        name: 'Mediterranean',
+        appearance: 'light',
+        background: '#bdd6e8',
+        backgroundSky: '#8ab4d6',
+        ground: '#ddd2bb',
+        ambient: { color: '#d6e6f3', intensity: 0.5 },
+        hemi: { sky: '#a8c8e2', ground: '#d8c9a4', intensity: 0.6 },
+        lights: [
+            { position: [18, 20, 12], color: '#fff4d4', intensity: 3.6, castShadow: true },
+            { position: [-12, 8, -8], color: '#8fb3d8', intensity: 0.7 },
+        ],
+        toneMappingExposure: 0.9,
+        clayTints: {
+            wall: '#f6f1e6',
+            floor: '#e0d6c2',
+            ceiling: '#f3ede0',
+            roof: '#3e6585',
+            glazing: '#bcd3e2',
+        },
+    },
+    {
+        id: 'twilight',
+        name: 'Twilight',
+        appearance: 'dark',
+        background: '#3a3550',
+        backgroundSky: '#272338',
+        ground: '#67618a',
+        ambient: { color: '#a89cc8', intensity: 0.55 },
+        hemi: { sky: '#d8a8c0', ground: '#3a3450', intensity: 0.7 },
+        lights: [
+            { position: [-14, 22, -10], color: '#a4b6e8', intensity: 1.4, castShadow: true },
+            { position: [14, 6, 8], color: '#ffb070', intensity: 0.9 },
+        ],
+        toneMappingExposure: 0.9,
+        clayTints: {
+            wall: '#c5b9cf',
+            floor: '#ad9fbb',
+            ceiling: '#d2c6dc',
+            roof: '#5b4f74',
+            glazing: '#c3b6d4',
+        },
+    },
+    {
+        id: 'night',
+        name: 'Night',
+        appearance: 'dark',
+        background: '#1f2433',
+        backgroundSky: '#12161f',
+        ground: '#4a5470',
+        ambient: { color: '#a0b0ff', intensity: 0.25 },
+        hemi: { sky: '#3a4666', ground: '#232a3d', intensity: 0.55 },
+        lights: [
+            { position: [10, 10, 10], color: '#e0e5ff', intensity: 1.2, castShadow: true },
+            { position: [-10, 10, -10], color: '#8090ff', intensity: 0.3 },
+        ],
+        toneMappingExposure: 0.9,
+        clayTints: {
+            wall: '#aab3c6',
+            floor: '#98a1b5',
+            ceiling: '#b7bfd0',
+            roof: '#5b6680',
+            glazing: '#aebbd0',
+        },
+    },
+    {
+        id: 'verdant',
+        name: 'Verdant',
+        appearance: 'light',
+        background: '#d6e4d2',
+        backgroundSky: '#aecde0',
+        ground: '#c7d6b4',
+        ambient: { color: '#e3efdd', intensity: 0.5 },
+        hemi: { sky: '#cfe6cf', ground: '#8ea06f', intensity: 0.65 },
+        lights: [
+            { position: [16, 22, 12], color: '#fff6d8', intensity: 3, castShadow: true },
+            { position: [-12, 10, -8], color: '#bfe0c2', intensity: 0.5 },
+        ],
+        toneMappingExposure: 0.9,
+        clayTints: {
+            wall: '#eef0e6',
+            floor: '#d8ddc6',
+            ceiling: '#f1f3ea',
+            roof: '#6f8a5a',
+            glazing: '#c4dcd0',
+        },
+    },
+];
+export const SCENE_THEME_IDS = SCENE_THEMES.map((theme) => theme.id);
+const SCENE_THEME_BY_ID = new Map(SCENE_THEMES.map((theme) => [theme.id, theme]));
+export function getSceneTheme(id) {
+    return SCENE_THEME_BY_ID.get(id) ?? SCENE_THEMES[0];
+}

package/dist/lib/shadow-only.d.ts

@@ -0,0 +1,4 @@
+import type { Object3D } from 'three';
+export declare function applyShadowOnly(root: Object3D): void;
+export declare function clearShadowOnly(root: Object3D): void;
+//# sourceMappingURL=shadow-only.d.ts.map

package/dist/lib/shadow-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-only.d.ts","sourceRoot":"","sources":["../../src/lib/shadow-only.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAuBrC,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CASpD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAOpD"}

package/dist/lib/shadow-only.js

@@ -0,0 +1,36 @@
+import { SCENE_LAYER, SHADOW_ONLY_LAYER } from './layers';
+/**
+ * Shadow-caster-only hiding: removes an object (and its descendants) from the
+ * color passes while keeping it in the shadow map, so a hidden roof or level
+ * still shadows the interior and sun enters through windows correctly.
+ *
+ * Uses layer masks instead of `visible = false` for two reasons: `visible`
+ * cascades (and, critically, prunes the object from the shadow pass too),
+ * while layers are tested per-object against the rendering camera — the main
+ * camera never enables {@link SHADOW_ONLY_LAYER}, but every shadow-casting
+ * light's shadow camera does (see `lights.tsx`).
+ *
+ * The original `layers.mask` is stashed under a private Symbol so
+ * {@link clearShadowOnly} restores the exact prior state. Both calls are
+ * idempotent and cheap to reapply.
+ */
+const ORIGINAL_LAYERS = Symbol('pascal:shadow-only:original-layers');
+export function applyShadowOnly(root) {
+    root.traverse((obj) => {
+        const carrier = obj;
+        if (carrier[ORIGINAL_LAYERS] === undefined) {
+            carrier[ORIGINAL_LAYERS] = obj.layers.mask;
+        }
+        obj.layers.disable(SCENE_LAYER);
+        obj.layers.enable(SHADOW_ONLY_LAYER);
+    });
+}
+export function clearShadowOnly(root) {
+    root.traverse((obj) => {
+        const carrier = obj;
+        if (carrier[ORIGINAL_LAYERS] === undefined)
+            return;
+        obj.layers.mask = carrier[ORIGINAL_LAYERS];
+        delete carrier[ORIGINAL_LAYERS];
+    });
+}