@pascal-app/viewer 1.0.4 → 1.0.6

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

@@ -3,26 +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 { 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,
@@ -143,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());
@@ -174,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).
@@ -190,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(() => {
@@ -204,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), []);
@@ -212,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);
@@ -295,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';
@@ -313,6 +323,8 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
             perfDisable,
             projectId,
             shading,
+            ambientOcclusion,
+            colorGrading,
             transparentBackground,
             rendererCtor: renderer.constructor?.name,
             width,
@@ -375,16 +387,18 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
             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;
@@ -432,8 +446,10 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
                 // band read as a visible line along the horizon.
                 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
@@ -454,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
@@ -511,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);
@@ -529,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;
         }
@@ -565,6 +619,9 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, disablePostF
         renderer,
         scene,
         shading,
+        ambientOcclusion,
+        colorGrading,
+        flatBackground,
         transparentBackground,
         size.height,
         size.width,
@@ -598,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);
@@ -630,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.js

@@ -1,5 +1,5 @@
 '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 { Component, lazy, Suspense, useMemo } from 'react';
 const DEFAULT_PRIORITY = 5;

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/selection-manager.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 { emitter, getSelectableKinds, pointInPolygon, resolveSelectionProxyId, sceneRegistry, useRegistryVersion, useScene, } from '@pascal-app/core';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
@@ -362,6 +362,7 @@ const OutlinerSync = () => {
     const selection = useViewer((s) => s.selection);
     const externalSelectedIds = useViewer((s) => s.externalSelectedIds);
     const hoveredId = useViewer((s) => s.hoveredId);
+    const pointedIds = useViewer((s) => s.pointedIds);
     const outliner = useViewer((s) => s.outliner);
     const geometryRevision = useViewer((s) => s.geometryRevision);
     const nodes = useScene((s) => s.nodes);
@@ -377,16 +378,23 @@ const OutlinerSync = () => {
             if (obj)
                 outliner.selectedObjects.push(obj);
         }
-        // Sync hovered objects
+        // Sync hovered objects, then the ones a chat chip points at (Point and ask).
         outliner.hoveredObjects.length = 0;
         if (hoveredId) {
             const hoveredNode = nodes[hoveredId];
-            if (hoveredNode?.type === 'slab')
-                return;
-            const obj = sceneRegistry.nodes.get(hoveredId);
-            if (obj)
+            if (hoveredNode?.type !== 'slab') {
+                const obj = sceneRegistry.nodes.get(hoveredId);
+                if (obj)
+                    outliner.hoveredObjects.push(obj);
+            }
+        }
+        for (const id of new Set(pointedIds)) {
+            if (nodes[id]?.type === 'slab')
+                continue;
+            const obj = sceneRegistry.nodes.get(id);
+            if (obj && !outliner.hoveredObjects.includes(obj))
                 outliner.hoveredObjects.push(obj);
         }
-    }, [selection, externalSelectedIds, hoveredId, outliner, nodes, geometryRevision]);
+    }, [selection, externalSelectedIds, hoveredId, pointedIds, outliner, nodes, geometryRevision]);
     return null;
 };

package/dist/components/viewer/underground-ambiance.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Keeps the two states the ground is the medium of. The eye above the ground, a level below
+ * grade shown with the ground on Auto: a hole opens in the ground (the factor `hole`, eased).
+ * The eye under the ground: the dark mode, the factor `ambiance`, eased in over a short
+ * crossing and back out when the eye comes up. Neither follows the other: a veiled basement
+ * seen from above has no ambiance. Mount beside `Lights`, which does.
+ */
+export declare function UndergroundAmbiance(): null;
+//# sourceMappingURL=underground-ambiance.d.ts.map

package/dist/components/viewer/underground-ambiance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"underground-ambiance.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/underground-ambiance.tsx"],"names":[],"mappings":"AAoCA;;;;;;GAMG;AACH,wBAAgB,mBAAmB,SAyGlC"}

package/dist/components/viewer/underground-ambiance.js

@@ -0,0 +1,105 @@
+'use client';
+import { buildingGroundBox, groundHeightAt, levelStackGroundBox, sceneRegistry, useScene, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import { useRef } from 'react';
+import { Vector3 } from 'three';
+import { AMBIANCE_SECONDS, ambianceNow, ambianceTarget, applyAmbianceToSkyLights, earthNow, earthTarget, easeAmbiance, eyeUnderTheGround, FADE_SECONDS, restoreSkyLights, setAmbianceFactor, setAmbianceFocus, setDiveGrainWeight, setEarthFactor, setGroundHoleOpen, stepAmbianceProgress, } from '../../lib/underground-ambiance';
+import useViewer, { groundVeiled } from '../../store/use-viewer';
+import { revealMotionOff } from '../../systems/construction-reveal/construction-reveal';
+/**
+ * Keeps the two states the ground is the medium of. The eye above the ground, a level below
+ * grade shown with the ground on Auto: a hole opens in the ground (the factor `hole`, eased).
+ * The eye under the ground: the dark mode, the factor `ambiance`, eased in over a short
+ * crossing and back out when the eye comes up. Neither follows the other: a veiled basement
+ * seen from above has no ambiance. Mount beside `Lights`, which does.
+ */
+export function UndergroundAmbiance() {
+    const progress = useRef(null);
+    const holeProgress = useRef(null);
+    const earthProgress = useRef(null);
+    const eye = useRef(new Vector3());
+    const lastEye = useRef(new Vector3(Number.NaN, Number.NaN, Number.NaN));
+    const lastNodes = useRef(null);
+    const groundY = useRef(0);
+    // The box the fog keeps clear: the host's ground window box when it keeps one, else the level
+    // shown (or the building) worked out here, so a host without the window still gets it.
+    const focus = useRef(null);
+    const focusFrom = useRef([]);
+    // Before `Lights` lerps the sky's lights (-1) they are given back as the theme set them, and
+    // after it they are moved for the frame the pipeline (1) draws.
+    useFrame((state, delta) => {
+        restoreSkyLights();
+        const viewer = useViewer.getState();
+        state.camera.getWorldPosition(eye.current);
+        const { nodes } = useScene.getState();
+        if (!eye.current.equals(lastEye.current) || nodes !== lastNodes.current) {
+            lastEye.current.copy(eye.current);
+            lastNodes.current = nodes;
+            const siteId = sceneRegistry.byType.site?.values().next().value;
+            const site = siteId ? nodes[siteId] : null;
+            groundY.current = groundHeightAt(site, eye.current.x, eye.current.z);
+        }
+        const under = eyeUnderTheGround(viewer.eyeUnderGround, eye.current.y, groundY.current);
+        if (under !== viewer.eyeUnderGround)
+            useViewer.setState({ eyeUnderGround: under });
+        // The first frame takes the world as it is: a project opened below grade does not dive.
+        const instant = revealMotionOff() || viewer.isExporting;
+        const fade = viewer.undergroundLook.transition === 'fade';
+        const seconds = instant ? 0 : fade ? FADE_SECONDS : AMBIANCE_SECONDS;
+        setDiveGrainWeight(fade ? 0 : 1);
+        const dt = Math.min(delta, 0.1);
+        const target = ambianceTarget({
+            eyeUnderGround: under,
+            groundMode: viewer.groundMode,
+            walkthroughMode: viewer.walkthroughMode,
+        });
+        const next = stepAmbianceProgress(progress.current ?? target, target, dt, seconds);
+        progress.current = next;
+        const eased = easeAmbiance(next);
+        setAmbianceFactor(eased);
+        const active = eased > 0;
+        if (viewer.ambianceActive !== active)
+            useViewer.setState({ ambianceActive: active });
+        // What is seen beyond the walls turns to earth with the eye, in the walkthrough too: there it
+        // is the only part of the dark mode that does (the rooms keep their light, no fog, no vignette).
+        const earthWanted = earthTarget({ eyeUnderGround: under, groundMode: viewer.groundMode });
+        const earthNext = stepAmbianceProgress(earthProgress.current ?? earthWanted, earthWanted, dt, seconds);
+        earthProgress.current = earthNext;
+        setEarthFactor(easeAmbiance(earthNext));
+        const holeTarget = groundVeiled(viewer) ? 1 : 0;
+        const holeNext = stepAmbianceProgress(holeProgress.current ?? holeTarget, holeTarget, dt, instant ? 0 : AMBIANCE_SECONDS);
+        holeProgress.current = holeNext;
+        setGroundHoleOpen(easeAmbiance(holeNext));
+        if (next !== target || holeNext !== holeTarget || earthNext !== earthWanted)
+            state.invalidate();
+        if (eased > 0 || earthNext > 0) {
+            const { selection, hideLevelsAboveSelection, belowGrade, groundWindowBox } = viewer;
+            const from = [
+                nodes,
+                selection.levelId,
+                selection.buildingId,
+                hideLevelsAboveSelection,
+                belowGrade,
+                groundWindowBox,
+            ];
+            if (from.some((value, index) => value !== focusFrom.current[index])) {
+                focusFrom.current = from;
+                // Where the world stays clear: the shown level and the ones under it (a deep level is
+                // seen with the stack over it opened), else the host's window box, else the building.
+                focus.current =
+                    (selection.levelId && (hideLevelsAboveSelection || belowGrade)
+                        ? levelStackGroundBox(nodes, selection.levelId)
+                        : null) ??
+                        groundWindowBox ??
+                        buildingGroundBox(nodes, selection.buildingId ?? null);
+            }
+        }
+    }, -2);
+    useFrame(() => {
+        const amount = ambianceNow();
+        if (amount > 0 || earthNow() > 0)
+            setAmbianceFocus(focus.current, eye.current);
+        applyAmbianceToSkyLights(amount);
+    }, 0);
+    return null;
+}

package/dist/components/viewer/viewer-camera.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viewer-camera.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/viewer-camera.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAOnC,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,cAWxF;AAcD,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,OAAO;;;EAExD;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,sBAAsB,IAAI,IAAI,CAAA;CAAE,EACrE,WAAW,EAAE,OAAO,QAMrB;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,IAAI,EAAE,MAAM,CAAA;IACZ,sBAAsB,IAAI,IAAI,CAAA;CAC/B,cASA;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,WAEnF;AAED,eAAO,MAAM,YAAY,GAAI,iBAAyB;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,gCAqB9E,CAAA"}
+{"version":3,"file":"viewer-camera.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/viewer-camera.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAOnC,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,cAWxF;AAcD,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,OAAO;;;EAExD;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,sBAAsB,IAAI,IAAI,CAAA;CAAE,EACrE,WAAW,EAAE,OAAO,QAMrB;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,IAAI,EAAE,MAAM,CAAA;IACZ,sBAAsB,IAAI,IAAI,CAAA;CAC/B,cASA;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,WAEnF;AAED,eAAO,MAAM,YAAY,oBAA6B;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,gCAqB9E,CAAA"}

package/dist/components/viewer/viewer-camera.js

@@ -1,4 +1,4 @@
-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 { OrthographicCamera, PerspectiveCamera } from '@react-three/drei';
 import { useThree } from '@react-three/fiber';
 import { useEffect } from 'react';

package/dist/components/viewer/viewer-presentations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viewer-presentations.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/viewer-presentations.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,aAAa,EAAY,MAAM,kBAAkB,CAAA;AAE7E,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAG9C,MAAM,MAAM,+BAA+B,GAAG;IAC5C,kFAAkF;IAClF,WAAW,EAAE,MAAM,OAAO,CAAA;IAC1B,6DAA6D;IAC7D,OAAO,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAA;IACpC,8DAA8D;IAC9D,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,wEAAwE;IACxE,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;CAChD,CAAA;AACD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,iFAAiF;IACjF,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxC,4EAA4E;IAC5E,aAAa,EAAE,OAAO,CAAA;IACtB,WAAW,EAAE,OAAO,CAAA;IACpB,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,CAAC,GAAG,EAAE,+BAA+B,KAAK,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAA;CAC5F,CAAA;AAGD;;;;GAIG;AACH,wBAAgB,qCAAqC,CAAC,CAAC,SAAS,OAAO,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAGtF;AAED,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAE7E;AAED,MAAM,MAAM,8BAA8B,GAAG;IAC3C,kFAAkF;IAClF,EAAE,EAAE,MAAM,CAAA;IACV,mFAAmF;IACnF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,4EAA4E;IAC5E,SAAS,EAAE,aAAa,CAAA;IACxB,gFAAgF;IAChF,aAAa,CAAC,EAAE,+BAA+B,CAAA;IAC/C;;;OAGG;IACH,YAAY,CAAC,EAAE,8BAA8B,CAAA;CAC9C,CAAA;AAeD,cAAM,8BAA8B;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoD;IAClF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,MAAM,CAAuC;IAErD,SAAS,GAAI,UAAU,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC,CAK/C;IAED,WAAW,QAAO,8BAA8B,EAAE,CAAe;IAEjE,KAAK,IAAI,IAAI;IAKb,QAAQ,CAAC,YAAY,EAAE,8BAA8B,GAAG,IAAI;IAmD5D,OAAO,CAAC,IAAI;CAIb;AAED,eAAO,MAAM,0BAA0B,gCAAuC,CAAA;AAE9E,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,8BAA8B,GAAG,IAAI,CAE7F;AA2BD;;;;;GAKG;AACH,wBAAgB,mBAAmB,2CAalC"}
+{"version":3,"file":"viewer-presentations.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/viewer-presentations.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,aAAa,EAAY,MAAM,kBAAkB,CAAA;AAE7E,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAG9C,MAAM,MAAM,+BAA+B,GAAG;IAC5C,kFAAkF;IAClF,WAAW,EAAE,MAAM,OAAO,CAAA;IAC1B,6DAA6D;IAC7D,OAAO,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAA;IACpC,8DAA8D;IAC9D,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,wEAAwE;IACxE,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;CAChD,CAAA;AACD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,iFAAiF;IACjF,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxC,4EAA4E;IAC5E,aAAa,EAAE,OAAO,CAAA;IACtB,WAAW,EAAE,OAAO,CAAA;IACpB,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,CAAC,GAAG,EAAE,+BAA+B,KAAK,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAA;CAC5F,CAAA;AAGD;;;;GAIG;AACH,wBAAgB,qCAAqC,CAAC,CAAC,SAAS,OAAO,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAGtF;AAED,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAE7E;AAED,MAAM,MAAM,8BAA8B,GAAG;IAC3C,kFAAkF;IAClF,EAAE,EAAE,MAAM,CAAA;IACV,mFAAmF;IACnF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,4EAA4E;IAC5E,SAAS,EAAE,aAAa,CAAA;IACxB,gFAAgF;IAChF,aAAa,CAAC,EAAE,+BAA+B,CAAA;IAC/C;;;OAGG;IACH,YAAY,CAAC,EAAE,8BAA8B,CAAA;CAC9C,CAAA;AAeD,cAAM,8BAA8B;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoD;IAClF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,MAAM,CAAuC;IAErD,SAAS,aAAc,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC,CAK/C;IAED,WAAW,QAAO,8BAA8B,EAAE,CAAe;IAEjE,KAAK,IAAI,IAAI,CAGZ;IAED,QAAQ,CAAC,YAAY,EAAE,8BAA8B,GAAG,IAAI,CAiD3D;IAED,OAAO,CAAC,IAAI;CAIb;AAED,eAAO,MAAM,0BAA0B,gCAAuC,CAAA;AAE9E,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,8BAA8B,GAAG,IAAI,CAE7F;AA2BD;;;;;GAKG;AACH,wBAAgB,mBAAmB,2CAalC"}

package/dist/hooks/use-gltf-ktx2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-gltf-ktx2.d.ts","sourceRoot":"","sources":["../../src/hooks/use-gltf-ktx2.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAK3C,QAAA,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,UAAU,CAAC,OAAO,OAAO,CAO5D,CAAA;AAED,OAAO,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"use-gltf-ktx2.d.ts","sourceRoot":"","sources":["../../src/hooks/use-gltf-ktx2.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAM3C,QAAA,MAAM,WAAW,SAAU,MAAM,KAAG,UAAU,CAAC,OAAO,OAAO,CAQ5D,CAAA;AAED,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/hooks/use-gltf-ktx2.js

@@ -1,10 +1,12 @@
 import { useGLTF } from '@react-three/drei';
 import { useThree } from '@react-three/fiber';
 import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
+import { preserveGltfUnlit } from '../lib/gltf-unlit';
 import { configureKtx2Support } from '../lib/ktx2-loader';
 const useGLTFKTX2 = (path) => {
     const gl = useThree((state) => state.gl);
     return useGLTF(path, true, true, (loader) => {
+        loader.register(preserveGltfUnlit);
         configureKtx2Support(loader, gl);
         loader.setMeshoptDecoder(MeshoptDecoder);
     });

package/dist/hooks/use-node-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-node-events.d.ts","sourceRoot":"","sources":["../../src/hooks/use-node-events.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,WAAW,EAIjB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAQpD,KAAK,UAAU,CAAC,CAAC,SAAS,WAAW,IAAI,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,CAAA;AAEtE,wBAAgB,aAAa,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;uBAyC1D,UAAU,CAAC,YAAY,CAAC;qBAK1B,UAAU,CAAC,YAAY,CAAC;kBAQ3B,UAAU,CAAC,YAAY,CAAC;wBAIlB,UAAU,CAAC,YAAY,CAAC;wBAIxB,UAAU,CAAC,YAAY,CAAC;uBAIzB,UAAU,CAAC,YAAY,CAAC;uBAIxB,UAAU,CAAC,YAAY,CAAC;uBAIxB,UAAU,CAAC,YAAY,CAAC;EAK9C"}
+{"version":3,"file":"use-node-events.d.ts","sourceRoot":"","sources":["../../src/hooks/use-node-events.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,WAAW,EAIjB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAQpD,KAAK,UAAU,CAAC,CAAC,SAAS,WAAW,IAAI,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,CAAA;AAEtE,wBAAgB,aAAa,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IAyC7E,aAAa,MAAM,UAAU,CAAC,YAAY,CAAC;IAK3C,WAAW,MAAM,UAAU,CAAC,YAAY,CAAC;IAQzC,OAAO,OAAO,UAAU,CAAC,YAAY,CAAC;IAItC,cAAc,MAAM,UAAU,CAAC,YAAY,CAAC;IAI5C,cAAc,MAAM,UAAU,CAAC,YAAY,CAAC;IAI5C,aAAa,MAAM,UAAU,CAAC,YAAY,CAAC;IAI3C,aAAa,MAAM,UAAU,CAAC,YAAY,CAAC;IAI3C,aAAa,MAAM,UAAU,CAAC,YAAY,CAAC;EAK9C"}