@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/store/use-viewer.js

@@ -1,7 +1,7 @@
 'use client';
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
-import { SCENE_THEME_IDS } from '../lib/scene-themes';
+import { getSceneTheme, projectSceneTheme, SCENE_THEME_IDS, } from '../lib/scene-themes';
 const CAMERA_MODES = ['perspective', 'orthographic'];
 const RENDER_SHADINGS = ['solid', 'rendered'];
 const COLOR_PRESETS = ['clay', 'white', 'mono', 'blueprint'];
@@ -89,7 +89,24 @@ function normalizeProjectPreferences(value) {
         if (!preferences || typeof preferences !== 'object' || Array.isArray(preferences))
             continue;
         const record = preferences;
+        const look = record.look && typeof record.look === 'object'
+            ? record.look
+            : undefined;
         next[projectId] = {
+            ...(look
+                ? {
+                    look: {
+                        ...(typeof look.theme === 'string' && SCENE_THEME_IDS.includes(look.theme)
+                            ? { theme: look.theme }
+                            : {}),
+                        ...(typeof look.edges === 'string' && EDGE_MODES.includes(look.edges)
+                            ? { edges: look.edges }
+                            : {}),
+                        ...(typeof look.shadows === 'boolean' ? { shadows: look.shadows } : {}),
+                        shadingByContext: normalizeShadingByContext(look.shadingByContext),
+                    },
+                }
+                : {}),
             ...(typeof record.showScans === 'boolean' ? { showScans: record.showScans } : {}),
             ...(typeof record.showGuides === 'boolean' ? { showGuides: record.showGuides } : {}),
             ...(typeof record.showGrid === 'boolean' ? { showGrid: record.showGrid } : {}),
@@ -120,6 +137,47 @@ function normalizePersistedViewerState(value) {
         projectPreferences: normalizeProjectPreferences(state.projectPreferences),
     };
 }
+/** The owner's pick (16 Oct): the section cut's clean edge over earth walls, and the simple fade. */
+export const DEFAULT_UNDERGROUND_LOOK = {
+    edge: 'section-earth',
+    transition: 'fade',
+};
+function resolveLook(state, patch) {
+    const next = { ...state, ...patch };
+    const local = next.projectPreferences[next.projectId ?? '']?.look;
+    const savedTheme = local?.theme ?? next.projectPresentation?.theme ?? next.lookDefaults.theme;
+    const theme = getSceneTheme(next.previewSceneTheme ?? savedTheme);
+    return {
+        ...patch,
+        savedSceneTheme: savedTheme,
+        sceneTheme: theme.id,
+        sceneAppearance: projectSceneTheme(theme, next.previewSceneTheme === null && !local?.theme ? next.projectPresentation : undefined),
+        shading: local?.shadingByContext?.[next.renderContext] ??
+            next.projectPresentation?.shading ??
+            next.shadingByContext[next.renderContext] ??
+            next.contextDefaultShading,
+        edges: local?.edges ?? next.projectPresentation?.edges ?? next.lookDefaults.edges,
+        shadows: local?.shadows ?? next.projectPresentation?.shadows ?? next.lookDefaults.shadows,
+    };
+}
+function chooseLook(state, look) {
+    const key = state.projectId ?? '';
+    const previous = state.projectPreferences[key];
+    const { shadingByContext, ...defaults } = look;
+    return resolveLook(state, {
+        ...(!state.projectId
+            ? {
+                lookDefaults: { ...state.lookDefaults, ...defaults },
+                shadingByContext: { ...state.shadingByContext, ...shadingByContext },
+            }
+            : {}),
+        projectPreferences: {
+            ...state.projectPreferences,
+            [key]: { ...previous, look: { ...previous?.look, ...look } },
+        },
+        ...('theme' in look ? { previewSceneTheme: null } : {}),
+    });
+}
 const useViewer = create()(persist((set) => ({
     selection: { buildingId: null, levelId: null, zoneId: null, selectedIds: [] },
     focusedUnitId: null,
@@ -134,6 +192,15 @@ const useViewer = create()(persist((set) => ({
         }
         return { externalSelectedIds: ids };
     }),
+    pointedIds: [],
+    setPointedIds: (ids) => set((state) => {
+        const next = ids ?? [];
+        if (state.pointedIds.length === next.length &&
+            state.pointedIds.every((id, index) => id === next[index])) {
+            return state;
+        }
+        return { pointedIds: next };
+    }),
     hoverHighlightMode: 'default',
     setHoverHighlightMode: (mode) => set((state) => (state.hoverHighlightMode === mode ? state : { hoverHighlightMode: mode })),
     hoveredId: null,
@@ -141,9 +208,24 @@ const useViewer = create()(persist((set) => ({
     cameraMode: 'perspective',
     setCameraMode: (mode) => set({ cameraMode: mode }),
     sceneTheme: 'studio',
-    setSceneTheme: (id) => set({ sceneTheme: id }),
+    sceneAppearance: getSceneTheme('studio'),
+    lookDefaults: { theme: 'studio', edges: 'soft', shadows: true },
+    projectPresentation: undefined,
+    setProjectPresentation: (projectPresentation) => set((state) => resolveLook(state, { projectPresentation })),
+    resetProjectLook: () => set((state) => {
+        const projectPreferences = { ...state.projectPreferences };
+        const key = state.projectId ?? '';
+        const { look: _look, ...rest } = projectPreferences[key] ?? {};
+        projectPreferences[key] = rest;
+        return resolveLook(state, { projectPreferences, previewSceneTheme: null });
+    }),
+    previewSceneTheme: null,
+    contextDefaultShading: 'rendered',
+    savedSceneTheme: 'studio',
+    setSceneTheme: (id) => set((state) => chooseLook(state, { theme: id })),
+    showSceneTheme: (id) => set((state) => resolveLook(state, { previewSceneTheme: id })),
     renderContext: 'editor',
-    setRenderContext: (context) => set({ renderContext: context }),
+    setRenderContext: (context, defaultShading = 'rendered') => set((state) => resolveLook(state, { renderContext: context, contextDefaultShading: defaultShading })),
     isExporting: false,
     setExporting: (value) => set({ isExporting: value }),
     itemLoadFailures: {},
@@ -161,18 +243,20 @@ const useViewer = create()(persist((set) => ({
     setRenderPaused: (value) => set({ renderPaused: value }),
     shading: 'rendered',
     shadingByContext: {},
-    setShading: (shading) => set((state) => ({
-        shading,
-        shadingByContext: { ...state.shadingByContext, [state.renderContext]: shading },
+    setShading: (shading) => set((state) => chooseLook(state, {
+        shadingByContext: {
+            ...state.projectPreferences[state.projectId ?? '']?.look?.shadingByContext,
+            [state.renderContext]: shading,
+        },
     })),
     textures: true,
     setTextures: (textures) => set({ textures }),
     colorPreset: 'clay',
     setColorPreset: (preset) => set({ colorPreset: preset }),
     edges: 'soft',
-    setEdges: (edges) => set({ edges }),
+    setEdges: (edges) => set((state) => chooseLook(state, { edges })),
     shadows: true,
-    setShadows: (shadows) => set({ shadows }),
+    setShadows: (shadows) => set((state) => chooseLook(state, { shadows })),
     unit: detectDefaultUnit(),
     metricNotation: 'meters',
     unitExplicit: false,
@@ -180,6 +264,22 @@ const useViewer = create()(persist((set) => ({
     setMetricNotation: (metricNotation) => set({ unit: 'metric', metricNotation, unitExplicit: true }),
     levelMode: 'stacked',
     setLevelMode: (mode) => set({ levelMode: mode }),
+    hideLevelsAboveSelection: false,
+    levelsRevealing: [],
+    nodesRevealing: [],
+    belowGrade: false,
+    gradeStanding: 'at-grade',
+    groundWindowBox: null,
+    groundWindowVeiled: false,
+    groundMode: 'auto',
+    setGroundMode: (mode) => set({ groundMode: mode }),
+    hasLevelBelowGrade: false,
+    diveAvailable: false,
+    eyeUnderGround: false,
+    pluginFoundationLevelIds: [],
+    ambianceActive: false,
+    undergroundLook: DEFAULT_UNDERGROUND_LOOK,
+    setUndergroundLook: (look) => set((state) => ({ undergroundLook: { ...state.undergroundLook, ...look } })),
     wallMode: 'up',
     setWallMode: (mode) => set({ wallMode: mode }),
     showScans: true,
@@ -234,16 +334,20 @@ const useViewer = create()(persist((set) => ({
     setInkOpacity: (opacity) => set({ inkOpacity: opacity }),
     projectId: null,
     setProjectId: (id) => set((state) => {
-        if (!id)
-            return { projectId: id };
-        const prefs = state.projectPreferences?.[id] || {};
-        return {
+        if (id === state.projectId)
+            return state;
+        const prefs = (id && state.projectPreferences?.[id]) || {};
+        const { '': _unscoped, ...projectPreferences } = state.projectPreferences;
+        return resolveLook(state, {
             projectId: id,
+            projectPreferences,
+            projectPresentation: undefined,
+            previewSceneTheme: null,
             showScans: prefs.showScans ?? true,
             showGuides: prefs.showGuides ?? true,
             showGrid: prefs.showGrid ?? true,
             showMeasurements: prefs.showMeasurements ?? true,
-        };
+        });
     }),
     projectPreferences: {},
     setSelection: (updates) => set((state) => {
@@ -295,25 +399,64 @@ const useViewer = create()(persist((set) => ({
     setInputDragging: (dragging) => set({ inputDragging: dragging }),
 }), {
     name: 'viewer-preferences',
-    merge: (persistedState, currentState) => ({
-        ...currentState,
-        ...normalizePersistedViewerState(persistedState),
-    }),
+    merge: (persistedState, currentState) => {
+        const persisted = normalizePersistedViewerState(persistedState);
+        return {
+            ...currentState,
+            ...persisted,
+            ...resolveLook(currentState, {
+                ...persisted,
+                lookDefaults: {
+                    theme: persisted.sceneTheme ?? currentState.lookDefaults.theme,
+                    edges: persisted.edges ?? currentState.lookDefaults.edges,
+                    shadows: persisted.shadows ?? currentState.lookDefaults.shadows,
+                },
+            }),
+        };
+    },
     partialize: (state) => ({
         cameraMode: state.cameraMode,
-        sceneTheme: state.sceneTheme,
+        sceneTheme: state.lookDefaults.theme,
         shadingByContext: state.shadingByContext,
         textures: state.textures,
         colorPreset: state.colorPreset,
-        edges: state.edges,
-        shadows: state.shadows,
+        edges: state.lookDefaults.edges,
+        shadows: state.lookDefaults.shadows,
         ...(state.unitExplicit ? { unit: state.unit } : {}),
         metricNotation: state.metricNotation,
         levelMode: state.levelMode,
         wallMode: state.wallMode,
-        projectPreferences: state.projectPreferences,
+        projectPreferences: Object.fromEntries(Object.entries(state.projectPreferences).filter(([key]) => key !== '')),
     }),
 }));
+/**
+ * Whether the site's ground is drawn as a veil wholesale: a level below grade is shown, the
+ * ground on auto. A level only partly below grade is the exception — there the ground window
+ * veils just the ground in the way, and the rest stays solid. The walkthrough walks on its
+ * floors: its ground is always solid, whatever level the overview had shown.
+ */
+export function groundVeiled(state) {
+    return (state.belowGrade &&
+        state.groundMode === 'auto' &&
+        state.gradeStanding !== 'partly-below-grade' &&
+        state.walkthroughMode !== true);
+}
+/** Whether any ground is veiled now, wholesale or through the eye's window. */
+export function anyGroundVeiled(state) {
+    return (groundVeiled(state) ||
+        (state.groundMode === 'auto' && state.groundWindowVeiled && state.walkthroughMode !== true));
+}
+/**
+ * Whether the site draws its own ground. `showGround: false` says other geometry supplies the
+ * ground (an authored landscape), which stands on a level above a basement; while a level below
+ * grade is shown, the level display hides the storeys above it (`belowGrade`) and the landscape
+ * with them. The site's ground stands in then, with its veil, hole and pit, so the basement is
+ * seen through an opening and not through nothing. With a level at or above grade shown, the
+ * landscape is shown and `showGround` is the author's.
+ */
+export function siteGroundShown(site, state) {
+    return site.showGround !== false || state.belowGrade;
+}
 /** Apply an authoritative country code (e.g. IP-derived by the host app) as
  * the unit default. Stronger signal than the timezone heuristic used at store
  * creation, but still a default: it never overrides an explicit user choice

package/dist/systems/ceiling/ceiling-system.d.ts

@@ -1,6 +1,19 @@
-import { type CeilingNode } from '@pascal-app/core';
+import { type CeilingNode, type CeilingSurfaceCell, useScene } from '@pascal-app/core';
 import * as THREE from 'three';
+/** Name of the meshes a ceiling draws its paint regions with, one per region. */
+export declare const CEILING_REGION_MESH = "ceiling-region";
+/**
+ * The material a ceiling draws a region finish with. The ceiling's renderer
+ * owns materials (theme, textures, scene materials) and leaves this on the
+ * registered mesh; the system builds geometry and asks it.
+ */
+export type CeilingRegionMaterial = (finish: CeilingSurfaceCell['finish']) => THREE.Material;
+type SceneNodes = ReturnType<typeof useScene.getState>['nodes'];
 export declare const CeilingSystem: () => null;
+/**
+ * Updates the geometry for a single ceiling
+ */
+export declare function updateCeilingGeometry(node: CeilingNode, mesh: THREE.Mesh, extraHoles?: Array<Array<[number, number]>>, nodes?: SceneNodes): void;
 /**
  * Generates flat ceiling geometry from polygon (no extrusion).
  *
@@ -9,4 +22,5 @@ export declare const CeilingSystem: () => null;
  * stored on the node — they are recomputed on every rebuild.
  */
 export declare function generateCeilingGeometry(ceilingNode: CeilingNode, extraHoles?: Array<Array<[number, number]>>): THREE.BufferGeometry;
+export {};
 //# sourceMappingURL=ceiling-system.d.ts.map

package/dist/systems/ceiling/ceiling-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ceiling-system.d.ts","sourceRoot":"","sources":["../../../src/systems/ceiling/ceiling-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAgB9B,eAAO,MAAM,aAAa,YA4BzB,CAAA;AAgED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAM,GAC9C,KAAK,CAAC,cAAc,CA6DtB"}
+{"version":3,"file":"ceiling-system.d.ts","sourceRoot":"","sources":["../../../src/systems/ceiling/ceiling-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,kBAAkB,EAYvB,QAAQ,EACT,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,iFAAiF;AACjF,eAAO,MAAM,mBAAmB,mBAAmB,CAAA;AAEnD;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,QAAQ,CAAC,KAAK,KAAK,CAAC,QAAQ,CAAA;AAE5F,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAA;AAa/D,eAAO,MAAM,aAAa,YA4BzB,CAAA;AAsCD;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,KAAK,CAAC,IAAI,EAChB,UAAU,GAAE,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAM,EAC/C,KAAK,GAAE,UAAsC,QA8C9C;AAuDD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAM,GAC9C,KAAK,CAAC,cAAc,CA6DtB"}

package/dist/systems/ceiling/ceiling-system.js

@@ -1,7 +1,10 @@
-import { getEffectiveNode, nodeRegistry, resolveCeilingHeight, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { CEILING_DRAW_OFFSET, CEILING_SURFACE_ROLE, ceilingPaintRegions, computeCeilingSurfaceCells, getEffectiveCutterNode, getEffectiveNode, hostedCutterHoles, isScriptedNode, nodeRegistry, resolveCeilingHeight, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { mergeSurfaceHolePolygons } from '../surface-hole-geometry';
+/** Name of the meshes a ceiling draws its paint regions with, one per region. */
+export const CEILING_REGION_MESH = 'ceiling-region';
 function ensureUv2Attribute(geometry) {
     const uv = geometry.getAttribute('uv');
     if (!uv)
@@ -49,29 +52,53 @@ export const CeilingSystem = () => {
  * participate just by declaring `capabilities.ceilingCut` on its definition.
  */
 function collectCeilingHoles(ceiling, nodes) {
-    const holes = [];
+    // Only the ceiling's own children can bind to it.
+    const hosted = { [ceiling.id]: ceiling };
+    for (const childId of ceiling.children ?? []) {
+        const child = nodes[childId];
+        if (child)
+            hosted[child.id] = getEffectiveCutterNode(child);
+    }
+    const holes = hostedCutterHoles(ceiling, hosted);
     for (const childId of ceiling.children ?? []) {
         const child = nodes[childId];
         if (!child)
             continue;
+        if (isScriptedNode(child) && child.source.manifest.cutters?.length)
+            continue;
         const def = nodeRegistry.get(child.type);
         const hole = def?.capabilities?.ceilingCut?.buildCeilingHole(child);
         if (hole)
             holes.push(hole);
     }
+    for (const [, def] of nodeRegistry.entries())
+        holes.push(...(def.capabilities?.ceilingCut?.holesFor?.(ceiling) ?? []));
     return holes;
 }
 /**
  * Updates the geometry for a single ceiling
  */
-function updateCeilingGeometry(node, mesh, extraHoles = [], nodes = useScene.getState().nodes) {
+export function updateCeilingGeometry(node, mesh, extraHoles = [], nodes = useScene.getState().nodes) {
     const newGeo = generateCeilingGeometry(node, extraHoles);
+    // Painted regions partition the underside: the ceiling's own mesh keeps what
+    // no region covers, and each region draws as its own single-material mesh,
+    // so batching buckets them by material like any other surface.
+    const regions = node.polygon.length >= 3 ? ceilingPaintRegions(node, nodes) : [];
+    const cells = regions.length
+        ? computeCeilingSurfaceCells(node.polygon, [...mergeSurfaceHolePolygons(node.holes || []), ...extraHoles], regions)
+        : null;
+    const surface = cells?.find((cell) => cell.role === CEILING_SURFACE_ROLE);
     mesh.geometry.dispose();
-    mesh.geometry = newGeo;
+    mesh.geometry = cells ? flatCeilingGeometry(surface?.polygons ?? []) : newGeo;
+    mesh.userData.paintRole = CEILING_SURFACE_ROLE;
+    syncCeilingRegionMeshes(mesh, (cells ?? []).filter((cell) => cell.role !== CEILING_SURFACE_ROLE));
     const gridMesh = mesh.getObjectByName('ceiling-grid');
     if (gridMesh) {
         gridMesh.geometry.dispose();
-        gridMesh.geometry = newGeo.clone();
+        gridMesh.geometry = cells ? newGeo : newGeo.clone();
+    }
+    else if (cells) {
+        newGeo.dispose();
     }
     // Position at the ceiling height and reset X/Z so live-drag mesh
     // offsets (set by move tools during the drag) don't leak into the
@@ -85,7 +112,62 @@ function updateCeilingGeometry(node, mesh, extraHoles = [], nodes = useScene.get
     // follows-mode ceiling re-parks under the current plane on every rebuild
     // (level-height edits / covering-slab changes dirty-mark ceilings).
     // Slight offset to avoid z-fighting with upper-level slabs.
-    mesh.position.y = resolveCeilingHeight(node, nodes) - 0.01 + (liveTransform?.position[1] ?? 0);
+    mesh.position.y =
+        resolveCeilingHeight(node, nodes) - CEILING_DRAW_OFFSET + (liveTransform?.position[1] ?? 0);
+}
+/**
+ * One child mesh per region cell, reused by position so a repaint keeps its
+ * mesh; surplus meshes go. The material comes from the renderer's resolver.
+ */
+function syncCeilingRegionMeshes(mesh, cells) {
+    const existing = mesh.children.filter((child) => child.isMesh && child.name === CEILING_REGION_MESH);
+    const resolve = mesh.userData.ceilingRegionMaterial;
+    cells.forEach((cell, index) => {
+        let region = existing[index];
+        if (!region) {
+            region = new THREE.Mesh();
+            region.name = CEILING_REGION_MESH;
+            region.castShadow = true;
+            region.receiveShadow = true;
+            mesh.add(region);
+        }
+        else
+            region.geometry.dispose();
+        region.geometry = flatCeilingGeometry(cell.polygons);
+        region.userData.paintRole = cell.role;
+        region.userData.finish = cell.finish;
+        region.userData.__fromGeometry = true;
+        region.material = resolve?.(cell.finish) ?? mesh.material;
+    });
+    for (const surplus of existing.slice(cells.length)) {
+        surplus.geometry.dispose();
+        surplus.removeFromParent();
+    }
+}
+/** Flat geometry for level-XZ pieces, laid out the way `generateCeilingGeometry` lays a ceiling. */
+function flatCeilingGeometry(pieces) {
+    const parts = pieces
+        .filter((piece) => piece.outer.length >= 3)
+        .map((piece) => {
+        const shape = new THREE.Shape(piece.outer.map(([x, z]) => new THREE.Vector2(x, -z)));
+        for (const hole of piece.holes)
+            if (hole.length >= 3)
+                shape.holes.push(new THREE.Path(hole.map(([x, z]) => new THREE.Vector2(x, -z))));
+        const geometry = new THREE.ShapeGeometry(shape);
+        geometry.rotateX(-Math.PI / 2);
+        geometry.computeVertexNormals();
+        ensureUv2Attribute(geometry);
+        return geometry;
+    });
+    if (parts.length === 0)
+        return generateCeilingGeometry({ polygon: [] });
+    if (parts.length === 1)
+        return parts[0];
+    const merged = mergeGeometries(parts) ?? parts[0];
+    for (const part of parts)
+        if (part !== merged)
+            part.dispose();
+    return merged;
 }
 /**
  * Generates flat ceiling geometry from polygon (no extrusion).

package/dist/systems/construction-reveal/construction-dust.d.ts

@@ -0,0 +1,16 @@
+import { type DustPool } from '../../lib/construction-dust';
+/**
+ * Draws a reveal's dust: one instanced mesh of camera-facing soft discs, as
+ * many as the pool holds, on the grid layer: inside the scene pass, so walls
+ * in front hide it (on the overlay layer it showed through them, Victor run
+ * 12), with no depth written, so the ink never outlines it; thumbnails leave
+ * it out. Renders nothing itself; it owns the mesh, adds it to the scene and
+ * disposes it on unmount.
+ */
+export declare function ConstructionDust({ pool, clock }: {
+    pool: DustPool;
+    clock: {
+        current: number;
+    };
+}): null;
+//# sourceMappingURL=construction-dust.d.ts.map

package/dist/systems/construction-reveal/construction-dust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construction-dust.d.ts","sourceRoot":"","sources":["../../../src/systems/construction-reveal/construction-dust.tsx"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,6BAA6B,CAAA;AAI3E;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,QA8E/F"}

package/dist/systems/construction-reveal/construction-dust.js

@@ -0,0 +1,92 @@
+'use client';
+import { emitter } from '@pascal-app/core';
+import { useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useMemo } from 'react';
+import { DynamicDrawUsage, InstancedBufferAttribute, InstancedMesh, Matrix4, PlaneGeometry, Quaternion, Vector3, } from 'three';
+import { dustSpriteSize } from '../../lib/construction-dust';
+import { GRID_LAYER } from '../../lib/layers';
+import { createDustMaterial } from './dust-material';
+/**
+ * Draws a reveal's dust: one instanced mesh of camera-facing soft discs, as
+ * many as the pool holds, on the grid layer: inside the scene pass, so walls
+ * in front hide it (on the overlay layer it showed through them, Victor run
+ * 12), with no depth written, so the ink never outlines it; thumbnails leave
+ * it out. Renders nothing itself; it owns the mesh, adds it to the scene and
+ * disposes it on unmount.
+ */
+export function ConstructionDust({ pool, clock }) {
+    const scene = useThree((state) => state.scene);
+    const camera = useThree((state) => state.camera);
+    const height = useThree((state) => state.size.height);
+    const dust = useMemo(() => {
+        const geometry = new PlaneGeometry(1, 1);
+        const alpha = new InstancedBufferAttribute(new Float32Array(pool.capacity), 1);
+        alpha.setUsage(DynamicDrawUsage);
+        const material = createDustMaterial(alpha);
+        const mesh = new InstancedMesh(geometry, material, pool.capacity);
+        mesh.name = 'construction-dust';
+        mesh.instanceMatrix.setUsage(DynamicDrawUsage);
+        mesh.layers.set(GRID_LAYER);
+        mesh.frustumCulled = false;
+        mesh.raycast = () => { };
+        mesh.count = 0;
+        mesh.visible = false;
+        return { mesh, alpha, geometry, material };
+    }, [pool]);
+    useEffect(() => {
+        scene.add(dust.mesh);
+        // A capture clones the scene in the same tick: no dust in it, whatever the camera layers.
+        const hide = () => {
+            dust.mesh.visible = false;
+            dust.mesh.count = 0;
+        };
+        emitter.on('thumbnail:before-capture', hide);
+        return () => {
+            emitter.off('thumbnail:before-capture', hide);
+            scene.remove(dust.mesh);
+            dust.geometry.dispose();
+            dust.material.dispose();
+            dust.mesh.dispose();
+        };
+    }, [dust, scene]);
+    const write = useMemo(() => {
+        const matrix = new Matrix4();
+        const position = new Vector3();
+        const size = new Vector3();
+        const facing = new Quaternion();
+        return {
+            facing,
+            sprite: (slot, x, y, z, scale, alpha) => {
+                position.set(x, y, z);
+                const drawn = dustSpriteSize(scale, camera, height, position);
+                size.set(drawn, drawn, drawn);
+                dust.mesh.setMatrixAt(slot, matrix.compose(position, facing, size));
+                dust.alpha.setX(slot, alpha);
+            },
+        };
+    }, [dust, camera, height]);
+    useFrame(() => {
+        const { mesh, alpha } = dust;
+        if (pool.takeWarm()) {
+            // One sprite with no size and no alpha: drawn, so its pipeline is built, and nothing to see.
+            write.facing.copy(camera.quaternion);
+            write.sprite(0, 0, 0, 0, 0, 0);
+            mesh.count = 1;
+            mesh.visible = true;
+            mesh.instanceMatrix.needsUpdate = true;
+            alpha.needsUpdate = true;
+            return;
+        }
+        if (!mesh.visible && pool.quietAt(clock.current))
+            return;
+        write.facing.copy(camera.quaternion);
+        const count = pool.step(clock.current, write.sprite);
+        mesh.count = count;
+        mesh.visible = count > 0;
+        if (count === 0)
+            return;
+        mesh.instanceMatrix.needsUpdate = true;
+        alpha.needsUpdate = true;
+    });
+    return null;
+}