@pascal-app/viewer 1.0.6 → 1.0.7

package/dist/components/viewer/index.js

@@ -4,6 +4,7 @@ import { nodeRegistry, RoofElevationSystem, StairOpeningSystem, sceneRegistry, u
 import { Canvas, extend, useFrame, useThree } from '@react-three/fiber';
 import { forwardRef, useEffect, useImperativeHandle, useLayoutEffect, useRef, useState, } from 'react';
 import * as THREE from 'three/webgpu';
+import { classifyDevice, isSoftwareRenderer, readDeviceSignals } from '../../lib/device-tier';
 import { hasDrawableGeometry } from '../../lib/drawable-geometry';
 import { PERF_OVERLAY_ENABLED } from '../../lib/gpu-perf';
 import { applyIsolation, clearIsolation } from '../../lib/isolation';
@@ -21,6 +22,7 @@ import { subscribeWallBuildInteractions } from '../../systems/wall/wall-build-li
 import { ImmersiveXRPresentationProvider } from '../../xr/presentation-context';
 import { SceneRenderer } from '../renderers/scene-renderer';
 import { BATCH_SPIKE_ENABLED, BatchedMeshSpike } from './batched-mesh-spike';
+import { DaylightAtmosphere } from './daylight-atmosphere';
 import FrameLimiter from './frame-limiter';
 import { Lights } from './lights';
 import { PerfMonitor } from './perf-monitor';
@@ -283,7 +285,13 @@ function SceneReadyTracker({ onSceneReadyChange, sceneReadyKey, sceneReadyMaxWai
     }, 10);
     return null;
 }
-const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVER_STYLES, selectionManager = 'default', perf = false, useBvh = true, renderContext = 'editor', transparent, defaultRender, presentation: suppliedPresentation, isolate, sceneReadyKey, onSceneReadyChange, onRenderError, onBreadcrumb, sceneReadyMaxWaitMs, maxFps = 50, disablePostFx = false, renderPaused = false, immersive, }, ref) {
+const MAX_DPR = { high: 1.5, medium: 1.25, low: 1 };
+/**
+ * A software renderer can't reach the usual cadence, and chasing it starves the app of the CPU it
+ * rasterizes on: frames are capped lower there.
+ */
+const SOFTWARE_MAX_FPS = 20;
+const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVER_STYLES, selectionManager = 'default', perf = false, useBvh = true, renderContext = 'editor', transparent, defaultRender, presentation: suppliedPresentation, daylight = true, isolate, sceneReadyKey, onSceneReadyChange, onRenderError, onBreadcrumb, sceneReadyMaxWaitMs, maxFps = 50, disablePostFx = false, renderPaused = false, immersive, }, ref) {
     useEffect(() => {
         if (nodeRegistry.size === 0) {
             console.warn('[viewer] Node registry is empty. Install @pascal-app/nodes and call await loadPlugin(builtinPlugin) before mounting <Viewer>.');
@@ -313,12 +321,18 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
     const isDark = useViewer((state) => state.sceneAppearance.appearance === 'dark');
     const sceneTheme = useViewer((state) => state.sceneTheme);
     const previousLampTheme = useRef(sceneTheme);
+    // Scene themes drive the lamps only in monochrome; the colored appearance's daylight follows
+    // its time of day instead.
+    const colored = useViewer((state) => state.textures);
+    const themeDrivesLamps = !(daylight && colored);
     useEffect(() => {
+        if (!themeDrivesLamps)
+            return;
         useInteractive
             .getState()
             .setLampDefault(getSceneTheme(sceneTheme).appearance === 'dark', previousLampTheme.current !== sceneTheme);
         previousLampTheme.current = sceneTheme;
-    }, [sceneTheme]);
+    }, [sceneTheme, themeDrivesLamps]);
     const transparentBackground = useViewer((state) => state.transparentBackground);
     // The shadows toggle drives `renderer.shadowMap.enabled` (via the Canvas
     // `shadows` prop) rather than the lights' `castShadow`: toggling castShadow
@@ -384,7 +398,10 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
     // Coarse-pointer devices (phones/tablets) get a tighter DPR ceiling to keep
     // fragment-shader cost down — saves another ~30% over 1.5x on high-DPI mobile.
     // Desktops (fine pointer) keep the original 1.5 cap.
-    const maxDpr = typeof window !== 'undefined' && window.matchMedia('(pointer: coarse)').matches ? 1.25 : 1.5;
+    // Pixel-ratio cap per quality tier (touch devices default to Medium).
+    const renderQuality = useViewer((state) => state.renderQuality);
+    const softwareRenderer = useViewer((state) => state.softwareRenderer);
+    const maxDpr = MAX_DPR[renderQuality];
     const showGpuFallback = rendererInitFailed;
     // When we can't mount the GPU canvas, the SceneReadyTracker never mounts and
     // the host editor would otherwise wait on its scene-readiness timeout. Signal
@@ -434,6 +451,11 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
                         });
                         if (result.status === 'ready') {
                             installEmptyDrawGuard(result.renderer);
+                            // Before the first frame, so the post-processing builds once at the device's tier.
+                            const signals = readDeviceSignals(result.backend, result.renderer.backend?.device);
+                            useViewer
+                                .getState()
+                                .setDetectedRenderQuality(classifyDevice(signals), isSoftwareRenderer(signals));
                             return result.renderer;
                         }
                         if (canvas)
@@ -456,11 +478,13 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
                 }, shadows: {
                     type: THREE.PCFShadowMap,
                     enabled: shadowsEnabled,
-                }, children: _jsx(ImmersiveXRPresentationProvider, { enabled: immersiveActive, children: ImmersiveSession ? (_jsx(ImmersiveSession, { children: _jsx(ViewerScene, { disablePostFx: true, hoverStyles: hoverStyles, immersiveXR: true, renderErrorHandlers: [immersive.onError, onRenderError], onSceneReadyChange: onSceneReadyChange, perf: perf, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs, selectionManager: selectionManager, useBvh: useBvh, SceneWrapper: immersive.Scene, children: children }) })) : (_jsxs(_Fragment, { children: [_jsx(FrameLimiter, { fps: maxFps, onFrameError: composeRenderErrorHandlers(onRenderError), paused: renderPaused }), _jsx(ViewerScene, { disablePostFx: disablePostFx, hoverStyles: hoverStyles, renderErrorHandlers: [onRenderError], onSceneReadyChange: onSceneReadyChange, perf: perf, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs, selectionManager: selectionManager, useBvh: useBvh, children: children })] })) }) }, immersiveActive ? 'webgl-xr' : 'webgpu')] }));
+                }, children: _jsx(ImmersiveXRPresentationProvider, { enabled: immersiveActive, children: ImmersiveSession ? (_jsx(ImmersiveSession, { children: _jsx(ViewerScene, { daylight: daylight, disablePostFx: true, hoverStyles: hoverStyles, immersiveXR: true, renderErrorHandlers: [immersive.onError, onRenderError], onSceneReadyChange: onSceneReadyChange, perf: perf, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs, selectionManager: selectionManager, useBvh: useBvh, SceneWrapper: immersive.Scene, children: children }) })) : (_jsxs(_Fragment, { children: [_jsx(FrameLimiter, { fps: softwareRenderer ? Math.min(maxFps, SOFTWARE_MAX_FPS) : maxFps, onFrameError: composeRenderErrorHandlers(onRenderError), paused: renderPaused }), _jsx(ViewerScene, { daylight: daylight, disablePostFx: disablePostFx, hoverStyles: hoverStyles, renderErrorHandlers: [onRenderError], onSceneReadyChange: onSceneReadyChange, perf: perf, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs, selectionManager: selectionManager, useBvh: useBvh, children: children })] })) }) }, immersiveActive ? 'webgl-xr' : 'webgpu')] }));
 });
-function ViewerScene({ children, disablePostFx, hoverStyles, immersiveXR = false, renderErrorHandlers, onSceneReadyChange, perf, sceneReadyKey, sceneReadyMaxWaitMs, selectionManager, useBvh, SceneWrapper, }) {
+function ViewerScene({ children, daylight, disablePostFx, hoverStyles, immersiveXR = false, renderErrorHandlers, onSceneReadyChange, perf, sceneReadyKey, sceneReadyMaxWaitMs, selectionManager, useBvh, SceneWrapper, }) {
+    // Colored appearance = the built-in daylight look; monochrome keeps the scene themes.
+    const colored = useViewer((state) => state.textures);
     const renderedScene = useBvh ? (_jsx(SceneBvh, { children: _jsx(SceneRenderer, {}) })) : (_jsx(SceneRenderer, {}));
     const spatialScene = (_jsxs(_Fragment, { children: [renderedScene, _jsx(FloorElevationSystem, {}), _jsx(GeometrySystem, {}), _jsx(StairOpeningSystem, {}), _jsx(RoofElevationSystem, {}), _jsx(RegisteredSystems, {}), BATCH_SPIKE_ENABLED && _jsx(BatchedMeshSpike, {}), children] }));
-    return (_jsxs(_Fragment, { children: [_jsx(ViewerCamera, { immersiveXR: immersiveXR }), immersiveXR && _jsx(ImmersiveXRBackground, {}), _jsx(PointerRaycastLayers, {}), _jsx(GPUDeviceWatcher, { intentionalWebGL: immersiveXR }), _jsx(ToneMappingExposure, {}), _jsx(SceneReadyTracker, { onSceneReadyChange: onSceneReadyChange, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs }), _jsxs(SceneErrorBoundary, { handlers: renderErrorHandlers, children: [_jsx(Lights, {}), SceneWrapper ? _jsx(SceneWrapper, { children: spatialScene }) : spatialScene, !immersiveXR && _jsx(PostProcessing, { disablePostFx: disablePostFx, hoverStyles: hoverStyles }), selectionManager === 'default' && _jsx(SelectionManager, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfMonitor, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfActionSettleSystem, {})] })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(ViewerCamera, { immersiveXR: immersiveXR }), immersiveXR && _jsx(ImmersiveXRBackground, {}), _jsx(PointerRaycastLayers, {}), _jsx(GPUDeviceWatcher, { intentionalWebGL: immersiveXR }), _jsx(ToneMappingExposure, {}), _jsx(SceneReadyTracker, { onSceneReadyChange: onSceneReadyChange, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs }), _jsxs(SceneErrorBoundary, { handlers: renderErrorHandlers, children: [daylight && colored && _jsx(DaylightAtmosphere, {}), _jsx(Lights, {}), SceneWrapper ? _jsx(SceneWrapper, { children: spatialScene }) : spatialScene, !immersiveXR && _jsx(PostProcessing, { disablePostFx: disablePostFx, hoverStyles: hoverStyles }), selectionManager === 'default' && _jsx(SelectionManager, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfMonitor, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfActionSettleSystem, {})] })] }));
 }
 export default Viewer;

package/dist/components/viewer/lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/lights.tsx"],"names":[],"mappings":"AAmGA,wBAAgB,MAAM,gCAiVrB"}
+{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/lights.tsx"],"names":[],"mappings":"AAoGA,wBAAgB,MAAM,gCA+XrB"}

package/dist/components/viewer/lights.js

@@ -3,6 +3,7 @@ import { sceneRegistry } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three/webgpu';
+import { isDaylightAtmosphere } from '../../lib/daylight/look';
 import { getKeyLightDirectionOverride } from '../../lib/key-light-override';
 import { SHADOW_ONLY_LAYER } from '../../lib/layers';
 import { registerSkyLights } from '../../lib/underground-ambiance';
@@ -97,7 +98,10 @@ export function Lights() {
         fillMounted.current = true;
     const filled = fillMounted.current;
     const atmosphere = useSceneAtmosphere();
-    const lightSlots = useMemo(() => Array.from({ length: atmosphere ? 2 : theme.lights.length }, (_, index) => index), [atmosphere, theme.lights.length]);
+    // The daylight look lights with one key (sun, or moon at night) and the sky environment only:
+    // no moon slot, hemisphere or ambient light (each light costs every material's shader).
+    const daylight = isDaylightAtmosphere(atmosphere);
+    const lightSlots = useMemo(() => Array.from({ length: daylight ? 1 : atmosphere ? 2 : theme.lights.length }, (_, index) => index), [atmosphere, daylight, theme.lights.length]);
     const lightRefs = useRef([]);
     const shadowCamera = useRef(null);
     // Initial ortho half-size; overridden each refresh to fit the building.
@@ -109,6 +113,10 @@ export function Lights() {
     const boundsBox = useRef(new THREE.Box3()); // scratch: union AABB
     const boundsSphere = useRef(new THREE.Sphere()); // scratch: fitted sphere
     const lastBoundsTime = useRef(-1); // last refresh timestamp (-1 = never)
+    // Daylight sun shadows render on change only (see `shadowSignature`).
+    const shadowCasters = useRef([]);
+    const shadowCasterTime = useRef(-1);
+    const lastShadowSignature = useRef(Number.NaN);
     const shadowHelpers = useRef([]);
     const hemiRef = useRef(null);
     const ambientRef = useRef(null);
@@ -135,6 +143,9 @@ export function Lights() {
         const dt = Math.min(delta, 0.1) * 4;
         const sourceShadow = atmosphere ? undefined : theme.lights[0]?.shadow;
         const sourceCamera = sourceShadow?.camera;
+        // The daylight look: one key (sun or moon) with its own shadow settings, frustum fitted
+        // tightly around the building in light space.
+        const daylightShadow = isDaylightAtmosphere(atmosphere) ? atmosphere.shadow : undefined;
         // Atmosphere directions are stable mutable vectors. Keep both light
         // resources mounted and move them imperatively so time/angle changes never
         // rebuild materials or shadow resources.
@@ -168,11 +179,24 @@ export function Lights() {
             if (!sourceCamera && now - lastBoundsTime.current >= BOUNDS_REFRESH_INTERVAL) {
                 lastBoundsTime.current = now;
                 const box = boundsBox.current.makeEmpty();
+                const counted = new Set();
                 for (const [id, obj] of sceneRegistry.nodes) {
                     if (SHADOW_EXCLUDED_TYPES.some((type) => sceneRegistry.byType[type].has(id)))
                         continue;
-                    box.expandByObject(obj);
+                    counted.add(obj);
                 }
+                // A counted node's subtree already holds the nodes below it: walk each mesh once, not
+                // once per counted ancestor (building, level, wall, item…).
+                for (const obj of counted) {
+                    let nested = false;
+                    for (let p = obj.parent; p && !nested; p = p.parent)
+                        nested = counted.has(p);
+                    if (!nested)
+                        expandByWorldBounds(box, obj);
+                }
+                // Baked artifacts stay out of the registry: frame their shadow casters instead.
+                if (box.isEmpty() && daylightShadow)
+                    expandByShadowCasters(state.scene, box);
                 box.getBoundingSphere(boundsSphere.current);
                 const center = boundsSphere.current.center;
                 const radius = boundsSphere.current.radius;
@@ -235,7 +259,29 @@ export function Lights() {
                     light.position.set(tx, ty, tz).add(shadowDir.current);
                 }
                 const cam = light.shadow?.camera;
-                if (cam) {
+                if (cam && daylightShadow && !sourceCamera) {
+                    light.shadow.mapSize.setScalar(daylightShadow.mapSize);
+                    light.shadow.bias = daylightShadow.bias;
+                    light.shadow.normalBias = daylightShadow.normalBias;
+                    light.shadow.radius = daylightShadow.radius;
+                    cam.layers.enable(SHADOW_ONLY_LAYER);
+                    fitShadowToBounds(light, boundsBox.current, shadowDir.current);
+                    // The sun's map re-renders only when something it depends on changes: its placement,
+                    // frustum or settings, or a caster that moved, appeared, vanished or changed shape.
+                    // A walkthrough or an orbit moves only the eye, so the map is reused frame to frame.
+                    light.shadow.autoUpdate = false;
+                    if (now - shadowCasterTime.current >= BOUNDS_REFRESH_INTERVAL) {
+                        shadowCasterTime.current = now;
+                        collectShadowCasters(state.scene, shadowCasters.current);
+                    }
+                    const signature = shadowSignature(light, cam, shadowCasters.current);
+                    if (signature !== lastShadowSignature.current) {
+                        lastShadowSignature.current = signature;
+                        light.shadow.needsUpdate = true;
+                    }
+                }
+                else if (cam) {
+                    light.shadow.autoUpdate = true;
                     // The calibrated building bias detaches furniture-scale contact shadows.
                     // Small scenes need finer shadow edges too; retain the building map budget.
                     const smallScene = !sourceCamera && shadowRadius.current < 1.5;
@@ -300,7 +346,9 @@ export function Lights() {
                 light.color.lerp(target, dt);
             }
             if (index === 0 && light.shadow?.intensity !== undefined) {
-                const shadowIntensity = sourceShadow?.intensity ?? (intensity <= 1 ? intensity : MAX_SHADOW_INTENSITY);
+                const shadowIntensity = daylightShadow
+                    ? 1
+                    : (sourceShadow?.intensity ?? (intensity <= 1 ? intensity : MAX_SHADOW_INTENSITY));
                 light.shadow.intensity =
                     atmosphere || !initialized.current
                         ? shadowIntensity
@@ -353,5 +401,144 @@ export function Lights() {
                         : (themeLight?.position ?? [0, 1, 0]), ref: (light) => {
                         lightRefs.current[index] = light;
                     }, "shadow-bias": SHADOW_DEPTH_BIAS, "shadow-mapSize": [1024, 1024], "shadow-normalBias": SHADOW_NORMAL_BIAS, "shadow-radius": 2, children: index === 0 && keyCastsShadow ? (_jsx("orthographicCamera", { attach: "shadow-camera", bottom: -shadowCameraSize, far: 400, left: -shadowCameraSize, near: 1, ref: shadowCamera, right: shadowCameraSize, top: shadowCameraSize })) : null }, index));
-            }), atmosphere || theme.hemi ? _jsx("hemisphereLight", { ref: hemiRef }) : null, _jsx("ambientLight", { ref: ambientRef }), filled && _jsx(UndergroundFill, { lightRef: fillRef }), _jsx(UndergroundAmbiance, {})] }));
+            }), !daylight && (atmosphere || theme.hemi) ? _jsx("hemisphereLight", { ref: hemiRef }) : null, daylight ? null : _jsx("ambientLight", { ref: ambientRef }), filled && _jsx(UndergroundFill, { lightRef: fillRef }), _jsx(UndergroundAmbiance, {})] }));
+}
+const _fitCenter = new THREE.Vector3();
+const _fitSize = new THREE.Vector3();
+const _fitCorner = new THREE.Vector3();
+const _fitBox = new THREE.Box3();
+const _fitBounds = new THREE.Box3();
+const _fitView = new THREE.Matrix4();
+const _fitUp = new THREE.Vector3(0, 1, 0);
+const _fitMargin = new THREE.Vector3(2, 0, 2);
+/**
+ * Daylight key: place the light on its direction around the building and fit the ortho shadow
+ * camera to the building box (+2 m of ground) projected into light space — the tightest frustum,
+ * so the map's texels all land on the building. Its depth reaches on to where the casters' shadows
+ * meet the ground: a receiver beyond the far plane reads as fully lit, which cut long shadows off
+ * square. A shadow keeps its caster's light-space x/y, so only the depth grows, not the texels.
+ */
+function fitShadowToBounds(light, bounds, direction) {
+    if (bounds.isEmpty())
+        return;
+    const center = bounds.getCenter(_fitCenter);
+    const radius = bounds.getSize(_fitSize).length() / 2 + 2;
+    const toLight = _fitSize.copy(direction).normalize();
+    light.position.copy(center).addScaledVector(toLight, radius * 2);
+    light.target.position.copy(center);
+    light.target.updateMatrixWorld();
+    light.updateMatrixWorld();
+    _fitView.lookAt(light.position, center, _fitUp).invert();
+    _fitView.setPosition(0, 0, 0);
+    const b = _fitBounds.copy(bounds).expandByVector(_fitMargin);
+    const box = _fitBox.makeEmpty();
+    // The ground under the casters (the site ground sits just below 0).
+    const groundY = Math.min(bounds.min.y, -0.07);
+    for (let i = 0; i < 8; i++) {
+        const y = i & 2 ? b.max.y : b.min.y;
+        _fitCorner
+            .set(i & 1 ? b.max.x : b.min.x, y, i & 4 ? b.max.z : b.min.z)
+            .sub(light.position)
+            .applyMatrix4(_fitView);
+        box.expandByPoint(_fitCorner);
+        // Down the light ray to the ground: same x/y in light space, only deeper.
+        if (toLight.y > 0)
+            box.min.z = Math.min(box.min.z, _fitCorner.z - (y - groundY) / toLight.y);
+    }
+    const cam = light.shadow.camera;
+    cam.left = box.min.x - 0.5;
+    cam.right = box.max.x + 0.5;
+    cam.bottom = box.min.y - 0.5;
+    cam.top = box.max.y + 0.5;
+    cam.near = Math.max(0.1, -box.max.z - 1);
+    cam.far = -box.min.z + 1;
+    cam.updateProjectionMatrix();
+}
+/** Every shadow-casting mesh under `root` (visible or not: a level shown again must count). */
+function collectShadowCasters(root, out) {
+    out.length = 0;
+    root.traverse((object) => {
+        const mesh = object;
+        if (mesh.isMesh && mesh.castShadow)
+            out.push(mesh);
+    });
+}
+/**
+ * A number that changes whenever the sun's shadow map would: the light's world placement and
+ * projection, its map settings, and each caster's world transform, shown state (through its
+ * ancestors) and geometry. Cheap enough per frame: a few reads per caster, no allocation.
+ */
+function shadowSignature(light, cam, casters) {
+    // A weighted sum, not a multiply-and-wrap hash: it stays exact to ~1e-7 at these magnitudes,
+    // so a door turning by a fraction of a degree still changes it.
+    let h = light.shadow.mapSize.x + light.shadow.bias * 1e4 + light.shadow.normalBias * 1e3;
+    h += light.shadow.radius * 7;
+    const lm = light.matrixWorld.elements;
+    const pm = cam.projectionMatrix.elements;
+    for (let i = 0; i < 16; i++)
+        h += (i + 1) * (lm[i] * 1.013 + pm[i] * 0.917);
+    for (let i = 0; i < casters.length; i++) {
+        const mesh = casters[i];
+        let shown = mesh.castShadow;
+        for (let x = mesh; x && shown; x = x.parent)
+            shown = x.visible;
+        if (!shown)
+            continue;
+        const m = mesh.matrixWorld.elements;
+        const w = (i % 89) + 1;
+        h +=
+            w *
+                (m[0] +
+                    m[1] * 2 +
+                    m[2] * 3 +
+                    m[5] * 5 +
+                    m[10] * 7 +
+                    m[12] * 11 +
+                    m[13] * 13 +
+                    m[14] * 17 +
+                    mesh.geometry.id * 0.019 +
+                    0.5);
+    }
+    return h;
+}
+const _objectBox = new THREE.Box3();
+/**
+ * `Box3.expandByObject` without its `updateWorldMatrix` on every object visited, which recomposed
+ * ~10k matrices per refresh: the frame's render already brought world matrices up to date
+ * (scene-matrices.ts), and bounds a frame old are fine for fitting the shadow frustum.
+ */
+function expandByWorldBounds(box, root) {
+    root.traverse((object) => {
+        const geometry = object.geometry;
+        if (geometry === undefined)
+            return;
+        const owned = object;
+        if (owned.boundingBox !== undefined) {
+            if (owned.boundingBox === null)
+                owned.computeBoundingBox?.();
+            if (!owned.boundingBox)
+                return;
+            _objectBox.copy(owned.boundingBox);
+        }
+        else {
+            if (geometry.boundingBox === null)
+                geometry.computeBoundingBox();
+            _objectBox.copy(geometry.boundingBox);
+        }
+        _objectBox.applyMatrix4(object.matrixWorld);
+        box.union(_objectBox);
+    });
+}
+/** Shadow-casting meshes of a scene (skipping the effectively infinite grounds). */
+function expandByShadowCasters(scene, box) {
+    const mesh = new THREE.Box3();
+    scene.traverseVisible((object) => {
+        const candidate = object;
+        if (!candidate.isMesh || !candidate.castShadow)
+            return;
+        mesh.setFromObject(candidate);
+        if (mesh.isEmpty() || mesh.max.x - mesh.min.x > 500 || mesh.max.z - mesh.min.z > 500)
+            return;
+        box.union(mesh);
+    });
 }

package/dist/components/viewer/post-processing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"post-processing.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/post-processing.tsx"],"names":[],"mappings":"AA0DA,eAAO,MAAM,YAAY;IACvB,QAAQ;IACR,UAAU;CACX,CAAA;AAGD,eAAO,MAAM,WAAW;IACtB,OAAO;IACP,UAAU;IACV,SAAS;IACT,MAAM;IACN,SAAS;IACT,SAAS;IACT,gBAAgB;IAChB,WAAW;IACX,WAAW;IACX,kBAAkB;IAClB,sBAAsB;IACtB,oBAAoB;CACrB,CAAA;AAgED,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,UAAU,CAAA;CACpB,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;AAS9B,eAAO,MAAM,oBAAoB,EAAE,WAElC,CAAA;AA+CD,QAAA,MAAM,oBAAoB,oCAGvB;IACD,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,SAwsBA,CAAA;eAEc,oBAAoB"}
+{"version":3,"file":"post-processing.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/post-processing.tsx"],"names":[],"mappings":"AA+FA,eAAO,MAAM,YAAY;IACvB,QAAQ;IACR,UAAU;CACX,CAAA;AAGD,eAAO,MAAM,WAAW;IACtB,OAAO;IACP,UAAU;IACV,SAAS;IACT,MAAM;IACN,SAAS;IACT,SAAS;IACT,gBAAgB;IAChB,WAAW;IACX,WAAW;IACX,kBAAkB;IAClB,sBAAsB;IACtB,oBAAoB;CACrB,CAAA;AAgED,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,UAAU,CAAA;CACpB,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;AAS9B,eAAO,MAAM,oBAAoB,EAAE,WAElC,CAAA;AA+CD,QAAA,MAAM,oBAAoB,oCAGvB;IACD,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,SAkvBA,CAAA;eAEc,oBAAoB"}