@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/components/viewer/perf-panel.js

@@ -1,5 +1,5 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { createPortal } from 'react-dom';
 import { usePerfActionReceipts } from '../../lib/perf-actions';

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":"AA8CA,eAAO,MAAM,YAAY;;;CAGxB,CAAA;AAGD,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAavB,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,GAAI,iCAG3B;IACD,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,SAmnBA,CAAA;AAED,eAAe,oBAAoB,CAAA"}
+{"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"}

package/dist/components/viewer/post-processing.js

@@ -3,25 +3,26 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Color, Layers, Matrix4, Scene, UnsignedByteType } from 'three';
 import { ssgi } from 'three/addons/tsl/display/SSGINode.js';
 import { denoise } from 'three/examples/jsm/tsl/display/DenoiseNode.js';
-import { add, diffuseColor, mix, mrt, normalView, normalWorldGeometry, oscSine, output, pass, premultiplyAlpha, renderOutput, sample, saturation, screenUV, smoothstep, time, float as tslFloat, uniform, vec3, vec4, } from 'three/tsl';
+import { add, diffuseColor, mix, normalView, normalWorldGeometry, oscSine, output, pass, premultiplyAlpha, renderOutput, sample, saturation, screenUV, smoothstep, time, color as tslColor, float as tslFloat, uniform, vec3, vec4, } from 'three/tsl';
 import { RenderPipeline, TimestampQuery } from 'three/webgpu';
-import { backdropGradient, deepSkyColor, horizonHazeColor } from '../../lib/backdrop';
+import { backdropColors, backdropGradient, flatBackdropOutput } from '../../lib/backdrop';
 import { edgeColorFor, edgeOpacityScaleFor } from '../../lib/edge-style';
 import { PERF_OVERLAY_ENABLED } from '../../lib/gpu-perf';
-import { inkedEdges } from '../../lib/ink-edges';
+import { createEdgeDepthSampler, inkedEdges } from '../../lib/ink-edges';
 import { refreshIsolation } from '../../lib/isolation';
 import { LayerPassIndex, LayerPassNode } from '../../lib/layer-pass';
-import { GRID_LAYER, OVERLAY_LAYER, SCENE_LAYER, ZONE_LAYER } from '../../lib/layers';
+import { OVERLAY_LAYER, SCENE_LAYER, scenePassLayers, ZONE_LAYER } from '../../lib/layers';
+import { isLiveFrameHeld } from '../../lib/live-frame-hold';
 import { mergedOutline } from '../../lib/merged-outline-node';
 import { recordPerfSample, timeSpan } from '../../lib/perf-tracks';
 import { PostProcessingResources } from '../../lib/post-processing-resources';
-import { getSceneTheme } from '../../lib/scene-themes';
+import { sceneLightingMask, scenePassMrt } from '../../lib/scene-pass-mrt';
 import { packNormalToRGB, unpackRGBToNormal } from '../../lib/tsl-compat';
+import { earthNow, UNDERGROUND_VIGNETTE, undergroundAmbianceNode, undergroundBackdrop, undergroundDissolve, undergroundDissolveGrain, undergroundEarthNode, undergroundFogAmount, undergroundVignette, worldPositionFromDepth, } from '../../lib/underground-ambiance';
 import useViewer from '../../store/use-viewer';
 import { useSceneAtmosphere } from './scene-atmosphere';
-// Scene-referred grade applied before the output tone mapping (AgX). AgX rolls
-// highlights off gently but reads flat on its own; a mild mid-gray-pivot
-// contrast + saturation lift restores the punch. Rendered shading only.
+// A mild mid-gray contrast and saturation lift separates surfaces before the
+// output transform. Saved project looks can turn it off. Rendered shading only.
 export const GRADE_PARAMS = {
     contrast: 1.05,
     saturation: 1.1,
@@ -142,29 +143,33 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
     const { gl: renderer, invalidate, scene, camera, size } = useThree();
     const resourcesRef = useRef(null);
     const atmosphere = useSceneAtmosphere();
-    const directSkyNode = useMemo(() => (atmosphere ? atmosphere.skyRadiance(normalWorldGeometry) : null), [atmosphere]);
+    // Under the ground the sky is the dark mode's: the same mix the pipeline's backdrop makes.
+    const directSkyNode = useMemo(() => atmosphere
+        ? mix(atmosphere.skyRadiance(normalWorldGeometry), undergroundBackdrop(normalWorldGeometry.y), undergroundEarthNode())
+        : null, [atmosphere]);
     const hasPipelineErrorRef = useRef(false);
     const retryCountRef = useRef(0);
     const rebuildTimeoutRef = useRef(null);
     const skippedZeroSizeRef = useRef(false);
     // Background color uniform — updated every frame via lerp, read by the TSL pipeline.
     // Initialised from the current scene theme so there's no flash on first render.
-    const initTheme = getSceneTheme(useViewer.getState().sceneTheme);
+    const initTheme = useViewer.getState().sceneAppearance;
+    const initBackdrop = backdropColors(initTheme);
     const initBg = initTheme.background;
     const bgUniform = useRef(uniform(new Color(initBg)));
     const bgCurrent = useRef(new Color(initBg));
     const bgTarget = useRef(new Color());
     // Zenith colour of the backdrop gradient (falls back to the flat background).
-    const initSky = initTheme.backgroundSky ?? initBg;
+    const initSky = initBackdrop.sky;
     const bgSkyUniform = useRef(uniform(new Color(initSky)));
     const bgSkyCurrent = useRef(new Color(initSky));
     const bgSkyTarget = useRef(new Color());
     // Horizon haze band + deep zenith (derived — see lib/backdrop.ts).
-    const initHaze = horizonHazeColor(initSky, initTheme.appearance);
+    const initHaze = initBackdrop.haze;
     const bgHazeUniform = useRef(uniform(new Color(initHaze)));
     const bgHazeCurrent = useRef(new Color(initHaze));
     const bgHazeTarget = useRef(new Color());
-    const initSkyDeep = deepSkyColor(initSky);
+    const initSkyDeep = initBackdrop.skyDeep;
     const bgSkyDeepUniform = useRef(uniform(new Color(initSkyDeep)));
     const bgSkyDeepCurrent = useRef(new Color(initSkyDeep));
     const bgSkyDeepTarget = useRef(new Color());
@@ -173,6 +178,9 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
     // view ray from these to find the true horizon (dir.y = 0).
     const camProjInvUniform = useRef(uniform(new Matrix4()));
     const camWorldUniform = useRef(uniform(new Matrix4()));
+    // The clear colour of the no-pipeline fallback under the ground (scratch, and the dark mode's tone).
+    const fallbackClear = useRef(new Color());
+    const fallbackEarth = useRef(new Color(UNDERGROUND_VIGNETTE));
     // Ink-line colour follows the scene-theme background luminance (dark lines on
     // light scenes, light on dark), refreshed each frame like the background.
     // Dark scenes also scale the ink opacity down (see edge-style.ts).
@@ -189,13 +197,10 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
     // picking), so without this the gizmos/handles/tool previews land in the
     // depth+normal MRT and get inked / AO'd as if they were geometry. The grid is
     // kept in here (not the overlay pass) so scene geometry depth-occludes it; it's
-    // a flat, depth-non-writing plane so the ink never picks it up.
-    const sceneOnlyLayers = useMemo(() => {
-        const l = new Layers();
-        l.set(SCENE_LAYER);
-        l.enable(GRID_LAYER);
-        return l;
-    }, []);
+    // a flat, depth-non-writing plane. The dust shares the layer and writes alpha 0 to
+    // the normal and diffuse attachments, which `scenePassMrt` blends, so the ink
+    // never sees its quads.
+    const sceneOnlyLayers = useMemo(scenePassLayers, []);
     // Editor overlays render in their own pass, composited on top after the ink
     // and outlines so they read as crisp UI rather than scene geometry.
     const overlayLayers = useMemo(() => {
@@ -203,7 +208,10 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
         l.set(OVERLAY_LAYER);
         return l;
     }, []);
-    const hoverHighlightMode = useViewer((s) => s.hoverHighlightMode);
+    const hoverMode = useViewer((s) => s.hoverHighlightMode);
+    // Elements a chat chip points at draw in the `point` style whatever the editor's hover mode is.
+    const hasPointedIds = useViewer((s) => s.pointedIds.length > 0);
+    const hoverHighlightMode = hasPointedIds ? 'point' : hoverMode;
     const hoverVisibleColor = useMemo(() => uniform(new Color(DEFAULT_HOVER_STYLE.visibleColor)), []);
     const hoverHiddenColor = useMemo(() => uniform(new Color(DEFAULT_HOVER_STYLE.hiddenColor)), []);
     const hoverStrength = useMemo(() => uniform(DEFAULT_HOVER_STYLE.strength), []);
@@ -211,6 +219,9 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
     // Subscribe to projectId so the pipeline rebuilds on project switch
     const projectId = useViewer((s) => s.projectId);
     const shading = useViewer((s) => s.shading);
+    const ambientOcclusion = useViewer((s) => s.sceneAppearance.postprocessing?.ambientOcclusion !== false);
+    const colorGrading = useViewer((s) => s.sceneAppearance.postprocessing?.colorGrading !== false);
+    const flatBackground = useViewer((s) => s.sceneAppearance.backgroundSky === null);
     const edges = useViewer((s) => s.edges);
     const inkOpacityOverride = useViewer((s) => s.inkOpacity);
     const transparentBackground = useViewer((s) => s.transparentBackground);
@@ -294,7 +305,7 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
             disposePipeline();
             return;
         }
-        const ssgiEnabled = shading === 'rendered' && SSGI_PARAMS.enabled && !perfDisable.ao;
+        const ssgiEnabled = shading === 'rendered' && ambientOcclusion && SSGI_PARAMS.enabled && !perfDisable.ao;
         const denoiseEnabled = ssgiEnabled && !perfDisable.denoise;
         const outlineEnabled = !perfDisable.outline;
         const inkEnabled = edges !== 'off';
@@ -312,6 +323,8 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
             perfDisable,
             projectId,
             shading,
+            ambientOcclusion,
+            colorGrading,
             transparentBackground,
             rendererCtor: renderer.constructor?.name,
             width,
@@ -371,18 +384,21 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
             // Scene depth is shared by SSGI, ink, and outlines.
             // The normal MRT is only built when SSGI or ink needs it.
             const scenePassDepth = scenePass.getTextureNode('depth');
+            const sampleEdgeDepth = createEdgeDepthSampler(scenePassDepth, camera);
             let scenePassNormal = null;
             if (needsNormalMRT) {
-                scenePass.setMRT(mrt({
+                scenePass.setMRT(scenePassMrt({
                     output,
                     diffuseColor,
                     normal: packNormalToRGB(normalView),
+                    lighting: sceneLightingMask(),
                 }));
                 scenePassNormal = scenePass.getTextureNode('normal');
             }
             if (scenePassNormal) {
                 const normalTexture = scenePass.getTexture('normal');
                 normalTexture.type = UnsignedByteType;
+                scenePass.getTexture('lighting').type = UnsignedByteType;
             }
             // Extract normal from color-encoded texture (SSGI consumes the node form).
             const normalNode = scenePassNormal;
@@ -428,10 +444,12 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
                 // (same ≈150→350 m window as ink-edges' distanceFade) so the horizon
                 // disc and the geometry↔sky depth cliff never grow an AO band — that
                 // band read as a visible line along the horizon.
-                const aoFarFade = smoothstep(tslFloat(0.9994), tslFloat(0.9998), scenePassDepth.sample(screenUV).r);
+                const aoFarFade = smoothstep(tslFloat(0.9994), tslFloat(0.9998), sampleEdgeDepth(screenUV));
                 ao = mix(ao, tslFloat(1), aoFarFade);
+                const lightingWeight = scenePass.getTextureNode('lighting').r;
+                ao = mix(tslFloat(1), ao, lightingWeight);
                 // Composite: scene * AO + diffuse * GI
-                sceneColor = vec4(add(scenePassColor.rgb.mul(ao), add(zonePass.rgb, scenePassDiffuse.rgb.mul(gi))), contentAlpha);
+                sceneColor = vec4(add(scenePassColor.rgb.mul(ao), add(zonePass.rgb, scenePassDiffuse.rgb.mul(gi).mul(lightingWeight))), contentAlpha);
             }
             // Screen-space ink outline (SketchUp look) — depth/normal edge detection
             // over the composited scene. Topology-agnostic, so it handles CSG-cut
@@ -439,7 +457,7 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
             if (inkEnabled && scenePassDepth && scenePassNormal) {
                 sceneColor = vec4(inkedEdges({
                     sceneRgb: sceneColor.rgb,
-                    depthTex: scenePassDepth,
+                    sampleDepth: sampleEdgeDepth,
                     normalTex: scenePassNormal,
                     inkColor: inkColorUniform.current,
                     radius: inkRadius,
@@ -452,7 +470,7 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
             // backdrop below so geometry that fades to the background colour (the
             // horizon disc) matches it exactly.
             const gradeRgb = (rgb) => saturation(rgb.div(0.18).pow(vec3(GRADE_PARAMS.contrast)).mul(0.18), GRADE_PARAMS.saturation);
-            if (shading === 'rendered') {
+            if (shading === 'rendered' && colorGrading) {
                 sceneColor = vec4(gradeRgb(sceneColor.rgb), sceneColor.a);
             }
             // Reused scene depth lets outlined groups occlude each other; materials
@@ -509,11 +527,37 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
                     sky: bgSkyUniform.current,
                     skyDeep: bgSkyDeepUniform.current,
                 });
-            if (shading === 'rendered') {
+            if (shading === 'rendered' && colorGrading) {
                 bgGradient = gradeRgb(bgGradient);
             }
-            const sceneComposite = compositeWithOutlines.rgb;
-            const composited = mix(bgGradient, sceneComposite, contentAlpha);
+            let sceneComposite = compositeWithOutlines.rgb;
+            // Under the ground (the eye below the ground surface) the scene goes to its dark mode: the
+            // sky is the dark theme's backdrop, and what stands far from the shown level dissolves into
+            // it (distance outside the level's box, from the scene pass's own depth; backdrop and fog
+            // meet in one colour per pixel). A noise mask closes over the screen as the eye crosses,
+            // 0 everywhere above the ground, 1 everywhere below.
+            let dive = null;
+            if (!transparentBackground) {
+                const grain = undergroundDissolveGrain();
+                dive = undergroundDissolve(screenUV, undergroundAmbianceNode(), grain);
+                // The backdrop follows the earth factor, which is the dark mode's own in the overview and
+                // alone in the walkthrough (looking out of a basement window shows earth, the rooms keep
+                // their light: no fog, no vignette).
+                const earthDive = undergroundDissolve(screenUV, undergroundEarthNode(), grain);
+                const dark = undergroundBackdrop(worldDir.y);
+                // The day's backdrop leaves ahead of the blobs: it greys and dims over the first half of
+                // the crossing, so the anthracite spreads over a neutral grey picture, not a blue sky.
+                const leaving = smoothstep(tslFloat(0), tslFloat(0.5), undergroundEarthNode());
+                const day = saturation(bgGradient, tslFloat(1).sub(leaving)).mul(tslFloat(1).sub(leaving.mul(0.35)));
+                bgGradient = mix(day, dark, earthDive);
+                const worldPosition = worldPositionFromDepth(scenePassDepth.sample(screenUV).r, camProjInvUniform.current, camWorldUniform.current);
+                sceneComposite = mix(sceneComposite, dark, undergroundFogAmount(worldPosition).mul(dive));
+            }
+            let composited = mix(bgGradient, sceneComposite, contentAlpha);
+            // The screen's edges close in with it.
+            if (dive) {
+                composited = mix(composited, tslColor(UNDERGROUND_VIGNETTE), undergroundVignette().mul(dive));
+            }
             // Editor overlays painted on top by their own alpha — they never get inked,
             // AO'd, or outlined, and always read crisp regardless of scene depth.
             const withOverlay = mix(composited, overlayColor.rgb, overlayColor.a);
@@ -527,9 +571,21 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
                     .div(alpha.max(tslFloat(0.00001)));
                 finalOutput = premultiplyAlpha(renderOutput(vec4(straightRgb, alpha)));
             }
+            else if (flatBackground && !atmosphere) {
+                const backdrop = flatBackdropOutput({
+                    background: bgUniform.current,
+                    foreground: sceneComposite,
+                    alpha: contentAlpha,
+                    toneMapping: renderer.toneMapping,
+                    outputColorSpace: renderer.outputColorSpace,
+                });
+                const overlay = renderOutput(vec4(overlayColor.rgb, 1), renderer.toneMapping, renderer.outputColorSpace);
+                finalOutput = vec4(mix(backdrop.rgb, overlay.rgb, overlayColor.a), 1);
+            }
             const renderPipeline = new RenderPipeline(renderer);
             resources.pipeline = renderPipeline;
-            renderPipeline.outputColorTransform = !transparentBackground;
+            renderPipeline.outputColorTransform =
+                !transparentBackground && !(flatBackground && !atmosphere);
             renderPipeline.outputNode = finalOutput;
             retryCountRef.current = 0;
         }
@@ -563,6 +619,9 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
         renderer,
         scene,
         shading,
+        ambientOcclusion,
+        colorGrading,
+        flatBackground,
         transparentBackground,
         size.height,
         size.width,
@@ -574,6 +633,9 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
         if (size.width < 1 || size.height < 1) {
             return;
         }
+        // A capture is working on the shared scene: the canvas keeps its last frame.
+        if (isLiveFrameHeld())
+            return;
         // `?disable=draw`: nothing downstream wants pixels — render an EMPTY scene
         // instead of the real one. This is the only render call (positive-priority
         // useFrame subscribers already disable R3F's automatic render), so the real
@@ -593,17 +655,18 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
             return;
         }
         // Animate background colour toward the current scene theme target (same lerp as AnimatedBackground)
-        const bgTheme = getSceneTheme(useViewer.getState().sceneTheme);
+        const bgTheme = useViewer.getState().sceneAppearance;
+        const backdrop = backdropColors(bgTheme);
         bgTarget.current.set(bgTheme.background);
         bgCurrent.current.lerp(bgTarget.current, Math.min(delta, 0.1) * 4);
         bgUniform.current.value.copy(bgCurrent.current);
-        bgSkyTarget.current.set(bgTheme.backgroundSky ?? bgTheme.background);
+        bgSkyTarget.current.set(backdrop.sky);
         bgSkyCurrent.current.lerp(bgSkyTarget.current, Math.min(delta, 0.1) * 4);
         bgSkyUniform.current.value.copy(bgSkyCurrent.current);
-        bgHazeTarget.current.set(horizonHazeColor(bgTheme.backgroundSky ?? bgTheme.background, bgTheme.appearance));
+        bgHazeTarget.current.set(backdrop.haze);
         bgHazeCurrent.current.lerp(bgHazeTarget.current, Math.min(delta, 0.1) * 4);
         bgHazeUniform.current.value.copy(bgHazeCurrent.current);
-        bgSkyDeepTarget.current.set(deepSkyColor(bgTheme.backgroundSky ?? bgTheme.background));
+        bgSkyDeepTarget.current.set(backdrop.skyDeep);
         bgSkyDeepCurrent.current.lerp(bgSkyDeepTarget.current, Math.min(delta, 0.1) * 4);
         bgSkyDeepUniform.current.value.copy(bgSkyDeepCurrent.current);
         camProjInvUniform.current.value.copy(camera.projectionMatrixInverse);
@@ -625,9 +688,14 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
                 scene.backgroundNode = directSkyNode;
             try {
                 const clearAlpha = transparentBackground ? 0 : 1;
+                // Without the pipeline there is no fog and no vignette: the clear colour is the dark mode's.
+                const underground = transparentBackground ? 0 : earthNow();
+                const clearColor = underground > 0 ? fallbackClear.current.copy(bgCurrent.current) : bgCurrent.current;
+                if (underground > 0)
+                    clearColor.lerp(fallbackEarth.current, underground);
                 if (renderer.setClearColor) {
                     ;
-                    renderer.setClearColor(bgCurrent.current, clearAlpha);
+                    renderer.setClearColor(clearColor, clearAlpha);
                 }
                 else if (renderer.setClearAlpha) {
                     ;

package/dist/components/viewer/registered-systems.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registered-systems.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/registered-systems.tsx"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,uCAgChC"}
+{"version":3,"file":"registered-systems.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/registered-systems.tsx"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,uCAkChC"}

package/dist/components/viewer/registered-systems.js

@@ -1,7 +1,7 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { createSceneApi, isNodeKindEnabled, nodeRegistry, useRegistryVersion, useScene, } from '@pascal-app/core';
-import { lazy, Suspense, useMemo } from 'react';
+import { Component, lazy, Suspense, useMemo } from 'react';
 const DEFAULT_PRIORITY = 5;
 const lazyCache = new WeakMap();
 function loadSystem(def) {
@@ -14,6 +14,20 @@ function loadSystem(def) {
     lazyCache.set(def.system.module, Comp);
     return Comp;
 }
+class SystemErrorBoundary extends Component {
+    state = { failed: false };
+    static getDerivedStateFromError() {
+        return { failed: true };
+    }
+    componentDidCatch(error) {
+        if (process.env.NODE_ENV !== 'production') {
+            console.error(`[viewer] Disabled system ${this.props.systemId}`, error);
+        }
+    }
+    render() {
+        return this.state.failed ? null : this.props.children;
+    }
+}
 /**
  * Mounts every registered node kind's system component, ordered by
  * `system.priority` (default {@link DEFAULT_PRIORITY}).
@@ -56,6 +70,6 @@ export function RegisteredSystems() {
             const Comp = loadSystem(def);
             if (!Comp)
                 return null;
-            return (_jsx(Suspense, { fallback: null, children: _jsx(Comp, { sceneApi: sceneApi }) }, `registered-system:${kind}`));
+            return (_jsx(SystemErrorBoundary, { systemId: kind, children: _jsx(Suspense, { fallback: null, children: _jsx(Comp, { sceneApi: sceneApi }) }) }, `registered-system:${kind}`));
         }) }));
 }

package/dist/components/viewer/render-error.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+type RenderErrorHandler = ((cause: unknown) => void) | undefined;
+/**
+ * One handler that notifies every given handler (the immersive session's and
+ * the host's), or undefined when there is none. A handler that throws is
+ * logged and does not stop the others.
+ */
+export declare function composeRenderErrorHandlers(...handlers: RenderErrorHandler[]): RenderErrorHandler;
+/**
+ * The viewer-scene error boundary: a node renderer or system that throws while
+ * rendering renders nothing in its place, and every handler hears about it.
+ */
+export declare function SceneErrorBoundary({ handlers, children, }: {
+    handlers: RenderErrorHandler[];
+    children: ReactNode;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=render-error.d.ts.map

package/dist/components/viewer/render-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-error.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/render-error.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;AAEhE;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,QAAQ,EAAE,kBAAkB,EAAE,GAAG,kBAAkB,CAYhG;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,kBAAkB,EAAE,CAAA;IAC9B,QAAQ,EAAE,SAAS,CAAA;CACpB,+BAUA"}

package/dist/components/viewer/render-error.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ErrorBoundary } from '../error-boundary';
+/**
+ * One handler that notifies every given handler (the immersive session's and
+ * the host's), or undefined when there is none. A handler that throws is
+ * logged and does not stop the others.
+ */
+export function composeRenderErrorHandlers(...handlers) {
+    const present = handlers.filter((handler) => handler !== undefined);
+    if (present.length === 0)
+        return;
+    return (cause) => {
+        for (const handler of present) {
+            try {
+                handler(cause);
+            }
+            catch (error) {
+                console.error('[viewer] a render-error handler threw', error);
+            }
+        }
+    };
+}
+/**
+ * The viewer-scene error boundary: a node renderer or system that throws while
+ * rendering renders nothing in its place, and every handler hears about it.
+ */
+export function SceneErrorBoundary({ handlers, children, }) {
+    return (_jsx(ErrorBoundary, { fallback: null, onError: composeRenderErrorHandlers(...handlers), scope: "viewer-scene", children: children }));
+}

package/dist/components/viewer/scene-bvh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-bvh.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/scene-bvh.tsx"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,SAAS,EAA0C,MAAM,OAAO,CAAA;AAC1F,OAAO,EAAuB,KAAK,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAC7D,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAA;AAEvB,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,EAAE,aAAa,CAAA;IACxB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAKD,eAAO,MAAM,kBAAkB,GAAI,QAAQ,IAAI,YAA4C,CAAA;AAY3F,eAAO,MAAM,QAAQ,mIAoGpB,CAAA"}
+{"version":3,"file":"scene-bvh.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/scene-bvh.tsx"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,SAAS,EAA0C,MAAM,OAAO,CAAA;AAC1F,OAAO,EAAuB,KAAK,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAC7D,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAA;AAEvB,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,EAAE,aAAa,CAAA;IACxB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAKD,eAAO,MAAM,kBAAkB,WAAY,IAAI,YAA4C,CAAA;AAY3F,eAAO,MAAM,QAAQ,mIAoGpB,CAAA"}

package/dist/components/viewer/scene-bvh.js

@@ -26,7 +26,7 @@ export const SceneBvh = forwardRef(({ children, enabled = true, firstHitOnly = f
             verbose,
             setBoundingBox,
             maxDepth,
-            maxLeafSize,
+            targetLeafSize: maxLeafSize,
             indirect,
         };
         const group = ref.current;

package/dist/components/viewer/scene-environment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-environment.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/scene-environment.tsx"],"names":[],"mappings":"AAoEA,wBAAgB,gBAAgB,SA8B/B"}
+{"version":3,"file":"scene-environment.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/scene-environment.tsx"],"names":[],"mappings":"AAoEA,wBAAgB,gBAAgB,SA8C/B"}

package/dist/components/viewer/scene-environment.js

@@ -1,8 +1,8 @@
 'use client';
 import { useThree } from '@react-three/fiber';
-import { useEffect, useMemo, useRef } from 'react';
+import { useEffect, useRef } from 'react';
+import { RoomEnvironment } from 'three/addons/environments/RoomEnvironment.js';
 import * as THREE from 'three/webgpu';
-import { getSceneTheme } from '../../lib/scene-themes';
 import useViewer from '../../store/use-viewer';
 import { useSceneAtmosphere } from './scene-atmosphere';
 /**
@@ -63,31 +63,51 @@ function buildGradientSky() {
 }
 export function SceneEnvironment() {
     const scene = useThree((state) => state.scene);
-    const texture = useMemo(buildGradientSky, []);
-    const appearance = useViewer((state) => getSceneTheme(state.sceneTheme).appearance);
+    const renderer = useThree((state) => state.gl);
+    const appearance = useViewer((state) => state.sceneAppearance.appearance);
+    const environment = useViewer((state) => state.sceneAppearance.environment);
+    const source = environment?.source ?? 'gradient';
     const atmosphere = useSceneAtmosphere();
     const atmosphereRef = useRef(atmosphere);
     atmosphereRef.current = atmosphere;
     useEffect(() => {
         const prevEnvironment = scene.environment;
-        const prevIntensity = scene.environmentIntensity;
+        let target;
+        let texture = null;
+        if (source === 'room') {
+            const room = new RoomEnvironment();
+            const generator = new THREE.PMREMGenerator(renderer);
+            target = generator.fromScene(room, 0.04);
+            texture = target.texture;
+            room.dispose();
+            generator.dispose();
+        }
+        else if (source === 'gradient')
+            texture = buildGradientSky();
         scene.environment = texture;
         return () => {
             if (scene.environment === texture) {
                 scene.environment = prevEnvironment;
-                if (!atmosphereRef.current)
-                    scene.environmentIntensity = prevIntensity;
             }
-            texture.dispose();
+            if (target)
+                target.dispose();
+            else
+                texture?.dispose();
         };
-    }, [scene, texture]);
+    }, [renderer, scene, source]);
     useEffect(() => {
         // An atmosphere owns environmentIntensity while its environmentNode is
         // active. The gradient remains installed as the fallback texture and takes
         // over immediately when the atmosphere restores scene ownership.
         if (atmosphere)
             return;
-        scene.environmentIntensity = appearance === 'dark' ? ENV_INTENSITY_DARK : ENV_INTENSITY;
-    }, [appearance, atmosphere, scene]);
+        const previous = scene.environmentIntensity;
+        scene.environmentIntensity =
+            environment?.intensity ?? (appearance === 'dark' ? ENV_INTENSITY_DARK : ENV_INTENSITY);
+        return () => {
+            if (!atmosphereRef.current)
+                scene.environmentIntensity = previous;
+        };
+    }, [appearance, atmosphere, scene, environment?.intensity]);
     return null;
 }

package/dist/components/viewer/scene-ground-replacement.d.ts

@@ -1,5 +1,11 @@
+import type { Scene } from 'three';
 /** Whether modeled exterior ground replaces this scene's fallback horizon disc. */
 export declare function useSceneGroundReplacement(): boolean;
+/**
+ * The same claim from outside React (a map layer that hangs its own meshes on
+ * the scene): returns the release. The last release restores the fallback.
+ */
+export declare function claimSceneGround(scene: Scene): () => void;
 /** Mount alongside replacement ground. The last release restores the fallback. */
 export declare function SceneGroundReplacement(): null;
 //# sourceMappingURL=scene-ground-replacement.d.ts.map

package/dist/components/viewer/scene-ground-replacement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-ground-replacement.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/scene-ground-replacement.tsx"],"names":[],"mappings":"AAoBA,mFAAmF;AACnF,wBAAgB,yBAAyB,IAAI,OAAO,CAInD;AAED,kFAAkF;AAClF,wBAAgB,sBAAsB,SAarC"}
+{"version":3,"file":"scene-ground-replacement.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/scene-ground-replacement.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAA;AAgBlC,mFAAmF;AACnF,wBAAgB,yBAAyB,IAAI,OAAO,CAInD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,IAAI,CASzD;AAED,kFAAkF;AAClF,wBAAgB,sBAAsB,SAarC"}

package/dist/components/viewer/scene-ground-replacement.js

@@ -18,6 +18,21 @@ export function useSceneGroundReplacement() {
     const store = useMemo(() => groundStore(scene), [scene]);
     return useStore(store, (state) => state.owners > 0);
 }
+/**
+ * The same claim from outside React (a map layer that hangs its own meshes on
+ * the scene): returns the release. The last release restores the fallback.
+ */
+export function claimSceneGround(scene) {
+    const store = groundStore(scene);
+    store.setState((state) => ({ owners: state.owners + 1 }));
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        store.setState((state) => ({ owners: Math.max(0, state.owners - 1) }));
+    };
+}
 /** Mount alongside replacement ground. The last release restores the fallback. */
 export function SceneGroundReplacement() {
     const scene = useThree((state) => state.scene);

package/dist/components/viewer/selection-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection-manager.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/selection-manager.tsx"],"names":[],"mappings":"AAqSA,eAAO,MAAM,gBAAgB,mCA0G5B,CAAA"}
+{"version":3,"file":"selection-manager.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/selection-manager.tsx"],"names":[],"mappings":"AAqSA,eAAO,MAAM,gBAAgB,mCA+G5B,CAAA"}