@pascal-app/viewer 1.0.6 → 1.1.0

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

@@ -1,22 +1,33 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { bakePolicyOf, containsPoint, distanceToBoundary, EXPLODED_GAP, itemInteraction, itemPrompt, operateItem, polygonInteriorPoint, useInteractive, } from '@pascal-app/core';
+import { bakePolicyOf, containsPoint, distanceToBoundary, EXPLODED_GAP, emitter, itemPrompt, operateItem, polygonInteriorPoint, useInteractive, usePascalI18n, } from '@pascal-app/core';
 import { operableParts, ProceduralMotionController, } from '@pascal-app/core/procedural-items';
+import { Html } from '@react-three/drei';
 import { useFrame, useThree } from '@react-three/fiber';
-import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import * as THREE from 'three';
 import { lerp } from 'three/src/math/MathUtils.js';
 import { acceleratedRaycast, computeBoundsTree, disposeBoundsTree } from 'three-mesh-bvh';
 import { useGLTFKTX2 } from '../../hooks/use-gltf-ktx2';
+import { createDaylightGroundMaterial, DAYLIGHT_PARCEL } from '../../lib/daylight/ground';
+import { isDaylightAtmosphere } from '../../lib/daylight/look';
+import { mergeBakedStatic } from '../../lib/glb-merge';
+import { setSurfaceRaycastLayers } from '../../lib/layers';
 import { createSurfaceRoleMaterial } from '../../lib/materials';
+import { attachOcclusionCuller, createOcclusionCuller, } from '../../lib/occlusion-culler';
 import { applyShadowOnly, clearShadowOnly } from '../../lib/shadow-only';
 import useViewer from '../../store/use-viewer';
+import { OPEN_SOUNDS, openingSound } from '../../systems/interactive/callout-actions';
+import { proceduralSettled } from '../../systems/interactive/opening-settled';
 import { useClipActions } from '../../systems/interactive/scripted-clips';
 import { resolveLevelVisibility } from '../../systems/level/level-utils';
 import { GlbInteractive } from './glb-interactive';
 import { bakedLoopMechanisms } from './glb-mechanisms';
 import { GlbReferenceNodes } from './glb-reference-nodes';
 import { GlbReplaceInstances } from './glb-replace-instances';
+import { bindGlbShutters, isGlbShutterHit, toggleGlbShutters } from './glb-scene-motion';
+import { GlbSelectionCallout } from './glb-selection-callout';
+import { useSceneAtmosphere } from './scene-atmosphere';
 /** Baked `kind` → surface role, so monochrome can recolor by role like the
  *  parametric viewer (textures-off collapses each face to its themed clay). */
 const ROLE_BY_KIND = {
@@ -68,6 +79,8 @@ const _camSize = new THREE.Vector3();
 const _walkPos = new THREE.Vector3();
 const _reticleNdc = new THREE.Vector2(0, 0);
 const _reticleRaycaster = new THREE.Raycaster();
+// Merged originals sit on the batched layer; the reticle still aims at them (batches never hit).
+setSurfaceRaycastLayers(_reticleRaycaster.layers);
 /** How far ahead (metres) an interactive part counts as "in view" for activation. */
 const WALK_REACH = 3;
 const ZONE_FOOTPRINT_EPSILON = 0.05;
@@ -110,10 +123,11 @@ function pointInZone(x, z, zone) {
  * when clicked. The host disables the parametric `SelectionManager`
  * (`selectionManager="custom"`).
  */
-export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes, onObjectsChange, onPick, onWalkthroughChange, }) {
+export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes, onObjectsChange, onPick, onWalkthroughChange, sceneNodes, }) {
     const gltf = useGLTFKTX2(url);
     const rootRef = useRef(null);
     const actions = useClipActions(gltf.animations, rootRef);
+    const resolveNode = useMemo(() => sceneNodes ? (id) => sceneNodes[id] : undefined, [sceneNodes]);
     const proceduralPlayback = useMemo(() => {
         const byNode = new Map();
         gltf.scene.traverse((object) => {
@@ -180,6 +194,7 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
                     clips: entry.clips,
                     spinParts,
                     sequence: 0,
+                    settling: null,
                 },
             ];
         }));
@@ -200,8 +215,14 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
     const camera = useThree((state) => state.camera);
     const controls = useThree((state) => state.controls);
     const walkthroughMode = useViewer((s) => s.walkthroughMode);
+    // Doors, the reticle prompt and the room HUD belong to the walk; the drone just flies.
+    const walkingOnFoot = useViewer((s) => s.walkthroughMode && s.walkthroughMovement === 'walk');
     const textures = useViewer((s) => s.textures);
     const sceneTheme = useViewer((s) => s.sceneTheme);
+    // Static merge of the artifact (see lib/glb-merge.ts); `?merge=0` keeps every mesh separate.
+    const mergeRef = useRef(null);
+    const [mergeVersion, setMergeVersion] = useState(0);
+    const [mergeRebuild, setMergeRebuild] = useState(0);
     // Monochrome: strip the baked textures and recolor every building mesh with a
     // flat themed-clay material by surface role — mirrors the parametric viewer's
     // textures-off path. The original baked material is stashed on the mesh
@@ -223,7 +244,40 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
                     : createSurfaceRoleMaterial(role, 'clay', THREE.DoubleSide, sceneTheme);
             });
         });
-    }, [gltf.scene, textures, sceneTheme]);
+        for (const batch of mergeRef.current?.batches ?? [])
+            applyBatchLook(batch, textures, sceneTheme);
+    }, [gltf.scene, textures, sceneTheme, mergeVersion]);
+    // Baked meshes take part in the sun's shadows (the bake carries no shadow flags). Transparent
+    // surfaces (glazing) don't cast, so sunlight still reaches the rooms behind them. Foliage ships
+    // opaque with cut-out textures (square dark leaves): alpha-test it.
+    useEffect(() => {
+        gltf.scene.traverse((object) => {
+            if (!object.userData.kind?.startsWith('trees:'))
+                return;
+            object.traverse((child) => {
+                const mesh = child;
+                if (!mesh.isMesh)
+                    return;
+                for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) {
+                    const standard = material;
+                    if (!standard.map || standard.alphaTest >= 0.5)
+                        continue;
+                    standard.alphaTest = 0.5;
+                    standard.side = THREE.DoubleSide;
+                    standard.transparent = false;
+                    standard.needsUpdate = true;
+                }
+            });
+        });
+        gltf.scene.traverse((child) => {
+            const mesh = child;
+            if (!mesh.isMesh)
+                return;
+            const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            mesh.receiveShadow = true;
+            mesh.castShadow = !materials.some((material) => material?.transparent);
+        });
+    }, [gltf.scene]);
     // The baked scene isn't wrapped in <SceneBvh> (the community viewer runs with
     // useBvh={false}), so hover/pick raycasts against the baked building were
     // brute-force triangle tests — dozens of ms per pointer move on a dense scene,
@@ -339,8 +393,6 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
             levelsWithZones: new Set(zoneList.map((zone) => zone.levelId)),
         };
     }, [gltf.scene]);
-    // Level pascalIds bottom-to-top, for the interactive light pool's level factor.
-    const levelOrder = useMemo(() => levels.map((entry) => entry.id), [levels]);
     // Loop clips no other controller plays (a plugin kind's mechanism) run on
     // click and E. As in the editor they start stopped and never persist.
     const loopMechanisms = useMemo(() => bakedLoopMechanisms(identity, new Set([
@@ -395,6 +447,80 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
         onObjectsChange?.(identity);
         return () => onObjectsChange?.(new Map());
     }, [identity, onObjectsChange]);
+    // Static merge: thousands of baked meshes become a few hundred draws per pass (the enhanced
+    // viewer's batching). Rebuilt when the interactive items change, or when a merged mesh is
+    // shown or hidden on its own (a plugin taking over a baked kind, an isolation), so a batch
+    // never draws something that should be gone.
+    const mergeEnabled = useMemo(() => typeof window === 'undefined' ||
+        new URLSearchParams(window.location.search).get('merge') !== '0', []);
+    useEffect(() => {
+        if (!mergeEnabled)
+            return;
+        const animated = new Set();
+        for (const clip of gltf.animations) {
+            for (const track of clip.tracks) {
+                const { nodeName } = THREE.PropertyBinding.parseTrackName(track.name);
+                const node = THREE.PropertyBinding.findNode(gltf.scene, nodeName);
+                if (node)
+                    animated.add(node);
+            }
+        }
+        const merge = mergeBakedStatic(gltf.scene, (kind) => ROLE_BY_KIND[kind ?? ''], {
+            keepIds: new Set((interactiveItems ?? []).map((item) => item.pascalId)),
+            animated,
+        });
+        const { textures: texturesNow, sceneTheme: themeNow } = useViewer.getState();
+        for (const batch of merge.batches)
+            applyBatchLook(batch, texturesNow, themeNow);
+        mergeRef.current = merge;
+        mergeSignature.current = merge.visibilitySignature();
+        setMergeVersion((version) => version + 1);
+        return () => {
+            for (const batch of merge.batches)
+                disposeBatchLook(batch);
+            merge.dispose();
+            if (mergeRef.current === merge)
+                mergeRef.current = null;
+        };
+    }, [gltf.scene, gltf.animations, interactiveItems, mergeEnabled, mergeRebuild]);
+    // Occlusion culling (see lib/occlusion-culler.ts): what the walls, slabs and roofs hide from
+    // the eye isn't drawn. Rebuilt with the merge, whose batches are what it mostly culls.
+    // `?occlusion=0` draws everything.
+    const rootScene = useThree((state) => state.scene);
+    const renderer = useThree((state) => state.gl);
+    const getThree = useThree((state) => state.get);
+    const occlusionEnabled = useMemo(() => typeof window === 'undefined' ||
+        new URLSearchParams(window.location.search).get('occlusion') !== '0', []);
+    useEffect(() => {
+        // three's drawing pipeline (WebGPU renderer) answers which objects a render skips.
+        const pipeline = renderer.drawingPipeline;
+        if (!occlusionEnabled || !pipeline)
+            return;
+        const culler = createOcclusionCuller(gltf.scene);
+        const detach = attachOcclusionCuller({
+            scene: rootScene,
+            pipeline,
+            culler,
+            getCamera: () => getThree().camera,
+        });
+        return () => {
+            detach();
+            culler.dispose();
+        };
+    }, [gltf.scene, rootScene, renderer, getThree, occlusionEnabled, mergeVersion]);
+    const mergeSignature = useRef(0);
+    const mergeCheck = useRef(0);
+    useFrame((_, delta) => {
+        const merge = mergeRef.current;
+        if (!merge)
+            return;
+        mergeCheck.current += delta;
+        if (mergeCheck.current < 0.25)
+            return;
+        mergeCheck.current = 0;
+        if (merge.visibilitySignature() !== mergeSignature.current)
+            setMergeRebuild((n) => n + 1);
+    });
     // Apply the viewer's level display to the baked floors each frame, by the
     // parametric LevelSystem's rule (solo, and the levels above the current one
     // hidden when the host asks). Walkthrough always shows the full stacked
@@ -451,8 +577,16 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
             if (command && command.sequence > entry.sequence) {
                 entry.controller.command(command);
                 entry.sequence = command.sequence;
+                entry.settling = command.sequence;
             }
             const frame = entry.controller.tick(delta);
+            if (entry.settling !== null && frame.settled) {
+                emitter.emit('procedural:motion-settled', {
+                    nodeId: nodeId,
+                    sequence: entry.settling,
+                });
+                entry.settling = null;
+            }
             for (const [clipName, binding] of entry.clips) {
                 const action = proceduralPlayback.actions.get(clipName);
                 if (!action)
@@ -526,15 +660,6 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
     // Items the walkthrough operates through their toggles; others fall through to loop clips.
     const toggleableItem = useCallback((pascalId) => interactiveItems?.find((item) => item.pascalId === pascalId &&
         item.interactive.controls.some((control) => control.kind === 'toggle')), [interactiveItems]);
-    // A click opens and closes an item with an `open` clip (an authored object,
-    // a scripted window or door), like a door.
-    const toggleOpenControl = useCallback((identityNode) => {
-        const item = toggleableItem(identityNode.userData.pascalId);
-        if (!item || itemInteraction(item.interactive).kind !== 'open')
-            return false;
-        operateItem(item.pascalId, item.interactive);
-        return true;
-    }, [toggleableItem]);
     const toggleLoopMechanism = useCallback((identityNode) => {
         const id = identityNode.userData.pascalId;
         if (!(id && loopMechanisms.has(id)))
@@ -543,7 +668,11 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
         state.setMechanism(id, !state.mechanisms[id]);
         return true;
     }, [loopMechanisms]);
+    useEffect(() => bindGlbShutters(identity, actions), [identity, actions]);
     const openIds = useRef(new Set());
+    // Bumped on every baked door or window toggle so the selection callout re-reads `openIds`.
+    const [, setOpenVersion] = useState(0);
+    const isOpen = useCallback((id) => openIds.current.has(id), []);
     const toggleProcedural = useCallback((hit, identityNode) => {
         const extras = identityNode.userData;
         if (extras.kind !== 'procedural-item')
@@ -588,6 +717,10 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
             openIds.current.add(id);
         else
             openIds.current.delete(id);
+        setOpenVersion((version) => version + 1);
+        // Played backwards from where it stands, the clip lands after its current time.
+        if (!willOpen)
+            return new Promise((resolve) => setTimeout(resolve, action.time * 1000));
     }, [actions]);
     // The room whose polygon contains a world point. Resolving by the raycast hit
     // point (rather than a node origin) means any surface inside a room footprint —
@@ -642,13 +775,15 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
         }
     });
     // ── Walkthrough: first-person HUD + interaction ────────────────────────────
+    const [shuttersInView, setShuttersInView] = useState(false);
     const walkDoorRef = useRef(null);
+    const walkPromptRef = useRef(null);
     const lastWalkKey = useRef(null);
     // Each frame in walkthrough, report the floor + room the camera stands in and
     // the openable directly ahead (a forward ray from screen centre) so the host
     // can draw the reticle prompt. Fires the callback only when the state changes.
     useFrame(() => {
-        if (!walkthroughMode)
+        if (!walkingOnFoot)
             return;
         camera.getWorldPosition(_walkPos);
         let floor = levels[0] ?? null;
@@ -715,7 +850,14 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
                 door = { label: extras.label ?? 'Item', isOpen, verb: isOpen ? 'turn off' : 'turn on' };
             }
         }
+        if (hit && !doorNode) {
+            const node = findIdentityAncestor(hit.object);
+            if (node?.userData?.shutters && node)
+                doorNode = { hit: hit.object, node };
+        }
+        setShuttersInView(Boolean(doorNode?.node.userData?.shutters));
         walkDoorRef.current = doorNode;
+        walkPromptRef.current = door;
         const key = `${floor?.id ?? ''}|${zone?.id ?? ''}|${door ? `${doorId}:${door.isOpen}` : ''}`;
         if (key !== lastWalkKey.current) {
             lastWalkKey.current = key;
@@ -724,41 +866,82 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
     });
     // E or click activates the openable in view. The click also re-locks the
     // pointer through the walkthrough controller; no selection happens.
-    const activateWalkDoor = useCallback(() => {
+    const activateWalkDoor = useCallback((shutterHit = false) => {
         const target = walkDoorRef.current;
         if (!target)
             return;
-        const item = toggleableItem(target.node.userData.pascalId);
+        if (shutterHit && target.node.userData.shutters && isGlbShutterHit(target.hit, target.node)) {
+            playShutterSound(target.node);
+            toggleGlbShutters(target.node);
+            return;
+        }
+        const prompt = walkPromptRef.current;
+        const extras = target.node.userData;
+        const switches = prompt?.verb !== undefined && !['open', 'close'].includes(prompt.verb);
+        const sound = switches
+            ? OPEN_SOUNDS.switch
+            : openingSound((extras.pascalId && sceneNodes?.[extras.pascalId]) || { type: extras.kind ?? 'door' });
+        const play = (settled, as = sound) => {
+            if (!prompt)
+                return;
+            // A garage door's motor runs the whole way, so it starts with the press.
+            if (!(prompt.isOpen && settled) || as === OPEN_SOUNDS.garage) {
+                emitter.emit('interaction:sound', prompt.isOpen ? as.off : as.on);
+                return;
+            }
+            if (as.swing)
+                emitter.emit('interaction:sound', as.swing);
+            void settled.then(() => emitter.emit('interaction:sound', as.off));
+        };
+        const item = toggleableItem(extras.pascalId);
         if (item) {
+            play();
             operateItem(item.pascalId, item.interactive);
             return;
         }
-        if (!(toggleProcedural(target.hit, target.node) || toggleLoopMechanism(target.node)))
-            toggleOpenable(target.node);
-    }, [toggleableItem, toggleLoopMechanism, toggleOpenable, toggleProcedural]);
+        if (toggleProcedural(target.hit, target.node)) {
+            // A recipe's door or lid swings, its drawer slides; both land on the motion's end.
+            const sliding = findProceduralMotionAncestor(target.hit)?.kind === 'slide';
+            if (switches)
+                play();
+            else
+                play(proceduralSettled(extras.pascalId), sliding ? OPEN_SOUNDS.drawer : OPEN_SOUNDS.panel);
+        }
+        else if (toggleLoopMechanism(target.node))
+            play();
+        else
+            play(toggleOpenable(target.node));
+    }, [sceneNodes, toggleableItem, toggleLoopMechanism, toggleOpenable, toggleProcedural]);
     useEffect(() => {
-        if (!walkthroughMode)
+        if (!walkingOnFoot)
             return;
         const onKey = (event) => {
             if (event.key.toLowerCase() === 'e')
                 activateWalkDoor();
+            const shutters = walkDoorRef.current?.node;
+            if (event.key.toLowerCase() === 'f' && !event.repeat && shutters?.userData.shutters) {
+                playShutterSound(shutters);
+                toggleGlbShutters(shutters);
+            }
         };
         const canvas = document.querySelector('canvas');
         window.addEventListener('keydown', onKey);
-        canvas?.addEventListener('click', activateWalkDoor);
+        const onClick = () => activateWalkDoor(true);
+        canvas?.addEventListener('click', onClick);
         return () => {
             window.removeEventListener('keydown', onKey);
-            canvas?.removeEventListener('click', activateWalkDoor);
+            canvas?.removeEventListener('click', onClick);
         };
-    }, [walkthroughMode, activateWalkDoor]);
-    // Clear the HUD (and stale targeting) whenever walkthrough turns off.
+    }, [walkingOnFoot, activateWalkDoor]);
+    // Clear the HUD (and stale targeting) whenever the walk ends, or turns into a drone flight.
     useEffect(() => {
-        if (walkthroughMode)
+        if (walkingOnFoot)
             return;
+        setShuttersInView(false);
         walkDoorRef.current = null;
         lastWalkKey.current = null;
         onWalkthroughChange?.(null);
-    }, [walkthroughMode, onWalkthroughChange]);
+    }, [walkingOnFoot, onWalkthroughChange]);
     const lastHover = useRef(null);
     const handlePointerMove = useCallback((event) => {
         event.stopPropagation();
@@ -779,8 +962,8 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
         lastHover.current = null;
         onPick?.({ type: 'hover', pick: null, modifiers: NO_MODIFIERS });
     }, [onPick]);
-    // The host's rules decide the selection; an openable the click selects (a
-    // door, a window, an item with an `open` clip, a mechanism) also plays.
+    // The host's rules decide the selection; what the element can do is offered
+    // on its selection callout, never run by the click itself.
     const handleClick = useCallback((event) => {
         event.stopPropagation();
         // Walkthrough handles its own door activation (E / canvas click) and never
@@ -789,24 +972,7 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
             return;
         const pick = resolveGlbPick(event.intersections, identity);
         onPick({ type: 'click', pick, modifiers: modifiersOf(event.nativeEvent) });
-        if (!pick || !useViewer.getState().selection.selectedIds.includes(pick.nodeId))
-            return;
-        const object = identity.get(pick.nodeId);
-        if (!object)
-            return;
-        if (!(toggleOpenControl(object) ||
-            toggleProcedural(pick.hitObject, object) ||
-            toggleLoopMechanism(object)))
-            toggleOpenable(object);
-    }, [
-        identity,
-        onPick,
-        toggleLoopMechanism,
-        toggleOpenControl,
-        toggleOpenable,
-        toggleProcedural,
-        walkthroughMode,
-    ]);
+    }, [identity, onPick, walkthroughMode]);
     // A click on empty space clears the room and the element (the floor stays).
     const handlePointerMissed = useCallback((event) => {
         if (useViewer.getState().walkthroughMode || !onPick)
@@ -822,7 +988,12 @@ export function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes,
         for (const mesh of occluderOwnMeshes)
             clearShadowOnly(mesh);
     }, [occluderOwnMeshes]);
-    return (_jsxs("group", { ref: rootRef, children: [_jsx("primitive", { object: gltf.scene, onClick: handleClick, onPointerMissed: handlePointerMissed, onPointerMove: handlePointerMove, onPointerOut: handlePointerOut }), interactiveItems?.length ? (_jsx(GlbInteractive, { actions: actions, identity: identity, items: interactiveItems, levelOrder: levelOrder, zones: zoneEntries })) : null, referenceNodes?.length ? (_jsx(GlbReferenceNodes, { identity: identity, nodes: referenceNodes })) : null, replaceNodes?.length ? (_jsx(GlbReplaceInstances, { identity: identity, nodes: replaceNodes })) : null] }));
+    return (_jsxs("group", { ref: rootRef, children: [walkingOnFoot && shuttersInView ? _jsx(GlbShuttersPrompt, {}) : null, _jsx("primitive", { object: gltf.scene, onClick: handleClick, onPointerMissed: handlePointerMissed, onPointerMove: handlePointerMove, onPointerOut: handlePointerOut }), _jsx(GlbSelectionCallout, { identity: identity, isOpen: isOpen, items: interactiveItems, loopMechanisms: loopMechanisms, sceneNodes: sceneNodes, toggleOpen: toggleOpenable }), interactiveItems?.length ? (_jsx(GlbInteractive, { actions: actions, identity: identity, items: interactiveItems })) : null, referenceNodes?.length ? (_jsx(GlbReferenceNodes, { identity: identity, nodes: referenceNodes })) : null, replaceNodes?.length ? (_jsx(GlbReplaceInstances, { identity: identity, nodes: replaceNodes, resolve: resolveNode })) : null, _jsx(GlbDaylightGround, { root: gltf.scene })] }));
+}
+function playShutterSound(node) {
+    const id = node.userData.pascalId;
+    const open = id && useInteractive.getState().mechanismParts[`${id}:shutters`];
+    emitter.emit('interaction:sound', open ? OPEN_SOUNDS.shutters.off : OPEN_SOUNDS.shutters.on);
 }
 const NO_MODIFIERS = {
     alt: false,
@@ -833,3 +1004,73 @@ const NO_MODIFIERS = {
 function modifiersOf(event) {
     return { alt: event.altKey, ctrl: event.ctrlKey, meta: event.metaKey, shift: event.shiftKey };
 }
+const NO_RAYCAST = () => { };
+/** A merged batch shows its baked material, or in monochrome the themed clay of its role. */
+function applyBatchLook(batch, textures, sceneTheme) {
+    const { role, bakedMaterial } = batch.userData;
+    disposeBatchLook(batch);
+    batch.material =
+        textures || !role
+            ? bakedMaterial
+            : createSurfaceRoleMaterial(role, 'clay', THREE.DoubleSide, sceneTheme);
+}
+function disposeBatchLook(batch) {
+    const material = batch.material;
+    if (material !== batch.userData.bakedMaterial)
+        material.dispose();
+}
+/**
+ * The colored appearance's ground under a baked artifact (the bake strips the live horizon
+ * disc): the squared daylight ground just under the baked site fill, so the parcel keeps its own
+ * surface; the atmosphere's fog takes it to the horizon.
+ */
+function GlbDaylightGround({ root }) {
+    const atmosphere = useSceneAtmosphere();
+    const daylight = isDaylightAtmosphere(atmosphere);
+    // The baked site fill (the site's own opaque surface) becomes the daylight parcel: a neutral,
+    // slightly lighter surface so the lot reads as its own place on the squared ground.
+    useEffect(() => {
+        if (!daylight)
+            return;
+        const parcel = createDaylightGroundMaterial(false, { color: DAYLIGHT_PARCEL });
+        const swapped = [];
+        root.traverse((object) => {
+            if (object.userData.kind !== 'site')
+                return;
+            for (const child of object.children) {
+                const mesh = child;
+                const material = mesh.material;
+                if (!mesh.isMesh || mesh.userData.pascalId || !material)
+                    continue;
+                if (Array.isArray(material) || material.transparent)
+                    continue;
+                swapped.push([mesh, mesh.material]);
+                mesh.material = parcel;
+            }
+        });
+        return () => {
+            for (const [mesh, material] of swapped)
+                mesh.material = material;
+            parcel.dispose();
+        };
+    }, [daylight, root]);
+    const solid = useViewer((state) => state.shading === 'solid');
+    const material = useMemo(() => {
+        if (!daylight)
+            return null;
+        const ground = createDaylightGroundMaterial(solid, { horizon: atmosphere?.fogRadiance });
+        ground.polygonOffset = true;
+        ground.polygonOffsetFactor = 2;
+        ground.polygonOffsetUnits = 4;
+        return ground;
+    }, [atmosphere, daylight, solid]);
+    useEffect(() => () => material?.dispose(), [material]);
+    if (!material)
+        return null;
+    return (_jsx("mesh", { material: material, position: [0, -0.07, 0], raycast: NO_RAYCAST, receiveShadow: true, rotation: [-Math.PI / 2, 0, 0], children: _jsx("planeGeometry", { args: [12_000, 12_000] }) }));
+}
+/** Match the walkthrough HUD's secondary key prompt, without requiring host wiring. */
+function GlbShuttersPrompt() {
+    const i18n = usePascalI18n();
+    return (_jsx(Html, { fullscreen: true, style: { pointerEvents: 'none' }, children: _jsx("div", { className: "dark pointer-events-none absolute top-1/2 left-1/2 mt-16 -translate-x-1/2 whitespace-nowrap text-foreground", children: _jsxs("div", { className: "corner-smooth flex items-center gap-1.5 rounded-full border border-border/40 bg-background/80 px-3 py-1 text-xs shadow-elevation-3 backdrop-blur-xl", children: [_jsx("kbd", { className: "rounded border border-border/60 bg-white/10 px-1.5 py-0.5 font-mono text-[10px]", children: "F" }), _jsx("span", { className: "font-medium", children: i18n._({ id: 'viewer.walkthrough.shutters', message: 'Shutters' }) })] }) }) }));
+}

package/dist/components/viewer/glb-selection-callout.d.ts

@@ -0,0 +1,17 @@
+import { type AnyNode } from '@pascal-app/core';
+import type { Object3D } from 'three';
+import type { GlbInteractiveItem } from './glb-interactive';
+/**
+ * The baked viewer's callout on the one selected element. The controls drive
+ * the same baked clips and interactive state the walkthrough does.
+ */
+export declare function GlbSelectionCallout({ identity, items, sceneNodes, loopMechanisms, isOpen, toggleOpen, }: {
+    identity: ReadonlyMap<string, Object3D>;
+    items: GlbInteractiveItem[] | undefined;
+    sceneNodes: Readonly<Record<string, AnyNode>> | undefined;
+    loopMechanisms: ReadonlyMap<string, unknown>;
+    /** Baked doors and windows open through their `: open` clip, tracked by the scene. */
+    isOpen: (id: string) => boolean;
+    toggleOpen: (object: Object3D) => void | Promise<void>;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=glb-selection-callout.d.ts.map

package/dist/components/viewer/glb-selection-callout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glb-selection-callout.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-selection-callout.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAAkC,MAAM,kBAAkB,CAAA;AAE/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAarC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAa3D;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,KAAK,EACL,UAAU,EACV,cAAc,EACd,MAAM,EACN,UAAU,GACX,EAAE;IACD,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IACvC,KAAK,EAAE,kBAAkB,EAAE,GAAG,SAAS,CAAA;IACvC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAA;IACzD,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC5C,sFAAsF;IACtF,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAA;IAC/B,UAAU,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACvD,sCA0FA"}

package/dist/components/viewer/glb-selection-callout.js

@@ -0,0 +1,54 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useInteractive } from '@pascal-app/core';
+import { useCallback } from 'react';
+import useViewer from '../../store/use-viewer';
+import { calloutSubtitle, calloutToggle, hasCallout, interactiveActions, OPEN_SOUNDS, openingSound, proceduralActions, SHUTTERS, } from '../../systems/interactive/callout-actions';
+import { toggleGlbShutters } from './glb-scene-motion';
+import { SelectionCallout } from './selection-callout';
+/**
+ * The baked viewer's callout on the one selected element. The controls drive
+ * the same baked clips and interactive state the walkthrough does.
+ */
+export function GlbSelectionCallout({ identity, items, sceneNodes, loopMechanisms, isOpen, toggleOpen, }) {
+    const selectedIds = useViewer((s) => s.selection.selectedIds);
+    const walkthrough = useViewer((s) => s.walkthroughMode);
+    const id = selectedIds.length === 1 ? selectedIds[0] : null;
+    const object = id ? identity.get(id) : undefined;
+    const interactive = useInteractive();
+    const dismiss = useCallback(() => {
+        const { selection, setSelection } = useViewer.getState();
+        if (id && selection.selectedIds.includes(id))
+            setSelection({ selectedIds: [] });
+    }, [id]);
+    if (walkthrough || !id || !object)
+        return null;
+    const extras = object.userData;
+    if (!hasCallout(extras.kind))
+        return null;
+    const node = sceneNodes?.[id];
+    const title = extras.label ?? node?.name ?? 'Item';
+    const opening = (node ?? { type: extras.kind ?? 'item' });
+    const actions = [];
+    const item = items?.find((candidate) => candidate.pascalId === id);
+    if (item?.procedural) {
+        actions.push(...proceduralActions(id, title, item.procedural.recipe ?? { parts: item.procedural.parts }, interactive));
+    }
+    else if (item) {
+        actions.push(...interactiveActions(title, item.interactive, interactive.items[item.pascalId]?.controlValues, (index, value) => useInteractive.getState().setControlValue(item.pascalId, index, value), opening));
+    }
+    else if (extras.openable && extras.clips?.some((clip) => clip.endsWith(': open'))) {
+        actions.push(calloutToggle('open', extras.kind === 'window' ? 'window' : 'door', isOpen(id), title, openingSound(opening), () => toggleOpen(object)));
+    }
+    else if (loopMechanisms.has(id)) {
+        actions.push(calloutToggle('mechanism', 'power', Boolean(interactive.mechanisms[id]), title, OPEN_SOUNDS.switch, () => {
+            const state = useInteractive.getState();
+            state.setMechanism(id, !state.mechanisms[id]);
+        }));
+    }
+    if (extras.shutters)
+        actions.push(calloutToggle('shutters', 'shutters', Boolean(interactive.mechanismParts[`${id}:shutters`]), title, OPEN_SOUNDS.shutters, () => {
+            toggleGlbShutters(object);
+        }, SHUTTERS));
+    return (_jsx(SelectionCallout, { actions: actions, object: object, onDismiss: dismiss, subtitle: calloutSubtitle(node ?? { type: extras.kind }, title), title: title }, id));
+}

package/dist/components/viewer/glb-walkthrough-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glb-walkthrough-controller.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-walkthrough-controller.tsx"],"names":[],"mappings":"AAkCA,eAAO,MAAM,eAAe,KAAK,CAAA;AAkBjC,eAAO,MAAM,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AAChF,eAAO,MAAM,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AACjF,eAAO,MAAM,kBAAkB,MAAM,CAAA;AACrC,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,eAAO,MAAM,iBAAiB,MAAM,CAAA;AACpC,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAInC,eAAO,MAAM,eAAe,OAAO,CAAA;AACnC,eAAO,MAAM,cAAc,KAAK,CAAA;AAiMhC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,GAAG,EAAE,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,sCA0PhE"}
+{"version":3,"file":"glb-walkthrough-controller.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-walkthrough-controller.tsx"],"names":[],"mappings":"AAkCA,eAAO,MAAM,eAAe,KAAK,CAAA;AAkBjC,eAAO,MAAM,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AAChF,eAAO,MAAM,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AACjF,eAAO,MAAM,kBAAkB,MAAM,CAAA;AACrC,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,eAAO,MAAM,iBAAiB,MAAM,CAAA;AACpC,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAInC,eAAO,MAAM,eAAe,OAAO,CAAA;AACnC,eAAO,MAAM,cAAc,KAAK,CAAA;AAmMhC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,GAAG,EAAE,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,sCA0PhE"}

package/dist/components/viewer/glb-walkthrough-controller.js

@@ -7,7 +7,7 @@ import { Box3, BoxGeometry, BufferGeometry, Euler, Float32BufferAttribute, Matri
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { acceleratedRaycast, computeBoundsTree, disposeBoundsTree } from 'three-mesh-bvh';
 import { useGLTFKTX2 } from '../../hooks/use-gltf-ktx2';
-import { SCENE_LAYER } from '../../lib/layers';
+import { BATCHED_LAYER, SCENE_LAYER } from '../../lib/layers';
 import useViewer from '../../store/use-viewer';
 import BVHEcctrl, {} from './bvh-ecctrl';
 import { applyWalkthroughCameraClipping } from './viewer-camera';
@@ -141,8 +141,11 @@ function buildGlbColliderWorld(scene) {
         const mesh = object;
         if (!mesh.isMesh)
             return;
-        // Zone fills live on a separate layer (and never collide).
-        if (!mesh.layers.isEnabled(SCENE_LAYER))
+        // Zone fills live on a separate layer (and never collide). Merged originals sit on the
+        // batched layer and still collide; their batches don't (each original keeps its kind rules).
+        if (mesh.userData.glbBatch)
+            return;
+        if (!mesh.layers.isEnabled(SCENE_LAYER) && !mesh.layers.isEnabled(BATCHED_LAYER))
             return;
         if (!isEffectivelyVisible(mesh))
             return;

package/dist/components/viewer/index.d.ts

@@ -42,6 +42,11 @@ interface ViewerProps {
     };
     /** Saved site appearance when rendering a baked asset without its graph. Null ignores it. */
     presentation?: SitePresentation | null;
+    /**
+     * The colored appearance's built-in daylight (sun, sky, ground, time and weather presets).
+     * Default on; canonical renders (bake) turn it off and keep the neutral studio look.
+     */
+    daylight?: boolean;
     /**
      * Visibility filter on the live canvas. When non-null, every registered
      * node group whose id is not in `isolate` (or in the isolated set's

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,SAAS,EAGd,KAAK,gBAAgB,EAKtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAkB,KAAK,YAAY,EAAsB,MAAM,oBAAoB,CAAA;AAC1F,OAAO,EACL,KAAK,aAAa,EAOnB,MAAM,OAAO,CAAA;AACd,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAKrC,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACrE,OAAO,EAAuB,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAI5F,OAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAA;AActE,OAAuB,EAAwB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAa1F,OAAO,QAAQ,oBAAoB,CAAC;IAOlC,UAAU,aAAa;QACrB,qBAAqB,EAAE,YAAY,CAAC,OAAO,KAAK,CAAC,qBAAqB,CAAC,CAAA;KACxE;CACF;AAsPD;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAS/C;AAsED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAA;IACrD,KAAK,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAA;IACnD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACnC;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,gBAAgB,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAA;IACvC,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,aAAa,CAAC,EAAE;QACd,OAAO,CAAC,EAAE,aAAa,CAAA;QACvB,QAAQ,CAAC,EAAE,OAAO,CAAA;QAClB,WAAW,CAAC,EAAE,WAAW,CAAA;KAC1B,CAAA;IACD,6FAA6F;IAC7F,YAAY,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAA;IACtC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAA;IAC5B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IACtC,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IAC7C;;;;;OAKG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IACxC;;;;OAIG;IACH,YAAY,CAAC,EAAE,uBAAuB,CAAA;IACtC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,sEAAsE;IACtE,SAAS,CAAC,EAAE,sBAAsB,CAAA;CACnC;AAED,yDAAyD;AACzD,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;OAKG;IACH,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,GAAG,IAAI,CAAA;CAC3C,CAAA;AAED,QAAA,MAAM,MAAM,sGA2RV,CAAA;eAyEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,SAAS,EAId,KAAK,gBAAgB,EAKtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAkB,KAAK,YAAY,EAAsB,MAAM,oBAAoB,CAAA;AAC1F,OAAO,EACL,KAAK,aAAa,EAOnB,MAAM,OAAO,CAAA;AACd,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAMrC,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACrE,OAAO,EAAuB,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAK5F,OAAkB,EAAE,KAAK,aAAa,EAAsB,MAAM,wBAAwB,CAAA;AAe1F,OAAuB,EAAwB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAa1F,OAAO,QAAQ,oBAAoB,CAAC;IAOlC,UAAU,aAAa;QACrB,qBAAqB,EAAE,YAAY,CAAC,OAAO,KAAK,CAAC,qBAAqB,CAAC,CAAA;KACxE;CACF;AAsPD;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAS/C;AAsED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAA;IACrD,KAAK,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAA;IACnD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACnC;AASD,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,gBAAgB,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAA;IACvC,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,aAAa,CAAC,EAAE;QACd,OAAO,CAAC,EAAE,aAAa,CAAA;QACvB,QAAQ,CAAC,EAAE,OAAO,CAAA;QAClB,WAAW,CAAC,EAAE,WAAW,CAAA;KAC1B,CAAA;IACD,6FAA6F;IAC7F,YAAY,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAA;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAA;IAC5B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IACtC,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IAC7C;;;;;OAKG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IACxC;;;;OAIG;IACH,YAAY,CAAC,EAAE,uBAAuB,CAAA;IACtC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,sEAAsE;IACtE,SAAS,CAAC,EAAE,sBAAsB,CAAA;CACnC;AAED,yDAAyD;AACzD,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;OAKG;IACH,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,GAAG,IAAI,CAAA;CAC3C,CAAA;AAED,QAAA,MAAM,MAAM,sGA+SV,CAAA;eA+Ea,MAAM"}