@pascal-app/nodes 1.0.4 → 1.0.6

package/dist/site/ground-pit.d.ts

@@ -0,0 +1,45 @@
+import type { PitWalls } from './ground-pit-geometry.js';
+import type { EdgeLook } from './underground-edge.js';
+/**
+ * The pit under the hole, seen from above: over a level that lies deep, the hole in the ground
+ * reads as the ground cut open, not as a white plate. Its sides are a section — the topsoil's
+ * layer, then strata of two anthracites cut by the same noisy threshold as the rim, darkening
+ * with depth — standing from grade down to the shown level's floor, and at the bottom a dark
+ * floor under the part of the hole the level does not fill. The levels between stay hidden: the
+ * level display still hides them, the pit only says there is a drop.
+ *
+ * Everything that moves is a uniform (the pit's floor, how far the hole is open); the walls'
+ * geometry is cut once per footprint change, as the hole's own field is, and rides the same
+ * contour (`ground-pit-geometry.ts`). The materials exist from the moment the scene has a level
+ * below grade, so a floor switch compiles nothing.
+ */
+/**
+ * The two looks: `true` the section walls and a dark floor under the hole's unbuilt part, `false`
+ * the walls alone (the level is then seen over the backdrop, as the hole always showed it).
+ */
+export declare const PIT_FLOOR = true;
+/** Sets the walls' look for an edge look (uniforms: nothing recompiles). */
+export declare function setGroundPitEdge(look: EdgeLook): void;
+/** The floor the pit goes down to now, world Y (the last level shown below grade). */
+export declare function groundPitFloorNow(): number;
+/** Where the pit draws its dark floor now, world Y: under the plate of that floor. */
+export declare function groundPitDrawnFloorNow(): number;
+/**
+ * The pit's walls and floor. `walls` is the cut contour (null: no hole), `box` the field's
+ * footprint the floor covers, `topY` the grade, `floorY` the shown level's floor and `drawnFloorY`
+ * where the dark floor is drawn (`groundPitFloorY`), all world Y.
+ */
+export declare function GroundPit({ walls, box, topY, floorY, drawnFloorY, topsoil, inHole, }: {
+    walls: PitWalls | null;
+    box: {
+        originX: number;
+        originZ: number;
+        span: number;
+    } | null;
+    topY: number;
+    floorY: number | null;
+    drawnFloorY: number | null;
+    topsoil: string;
+    inHole: unknown;
+}): import("react").JSX.Element;
+//# sourceMappingURL=ground-pit.d.ts.map

package/dist/site/ground-pit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-pit.d.ts","sourceRoot":"","sources":["../../src/site/ground-pit.tsx"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAElD;;;;;;;;;;;;GAYG;AAEH;;;GAGG;AACH,eAAO,MAAM,SAAS,OAAO,CAAA;AA0C7B,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAGrD;AAED,sFAAsF;AACtF,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED,sFAAsF;AACtF,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAqFD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,GAAG,EACH,IAAI,EACJ,MAAM,EACN,WAAW,EACX,OAAO,EACP,MAAM,GACP,EAAE;IACD,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAA;IACtB,GAAG,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAC9D,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;CAChB,+BAwEA"}

package/dist/site/ground-pit.js

@@ -0,0 +1,175 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { groundHoleOpenNode, useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo } from 'react';
+import { BufferAttribute, BufferGeometry, FrontSide } from 'three';
+import { attribute, color, float, mix, mx_noise_float, normalize, normalLocal, positionLocal, positionWorld, smoothstep, transformNormalToView, uniform, vec3, } from 'three/tsl';
+import { MeshLambertNodeMaterial } from 'three/webgpu';
+import { noopRaycast } from './ground-veil.js';
+/**
+ * The pit under the hole, seen from above: over a level that lies deep, the hole in the ground
+ * reads as the ground cut open, not as a white plate. Its sides are a section — the topsoil's
+ * layer, then strata of two anthracites cut by the same noisy threshold as the rim, darkening
+ * with depth — standing from grade down to the shown level's floor, and at the bottom a dark
+ * floor under the part of the hole the level does not fill. The levels between stay hidden: the
+ * level display still hides them, the pit only says there is a drop.
+ *
+ * Everything that moves is a uniform (the pit's floor, how far the hole is open); the walls'
+ * geometry is cut once per footprint change, as the hole's own field is, and rides the same
+ * contour (`ground-pit-geometry.ts`). The materials exist from the moment the scene has a level
+ * below grade, so a floor switch compiles nothing.
+ */
+/**
+ * The two looks: `true` the section walls and a dark floor under the hole's unbuilt part, `false`
+ * the walls alone (the level is then seen over the backdrop, as the hole always showed it).
+ */
+export const PIT_FLOOR = true;
+const TOPSOIL_DEPTH = 0.5;
+const STRATA = { light: '#6e6e6e', dark: '#5e5e5e' };
+const PIT_FOOT = '#2a2a2a';
+const PIT_FLOOR_COLOR = '#4a4a4a';
+/** How far (m) the strata's undulation lifts and sinks the layers along the wall. */
+const STRATA_WAVE = 0.6;
+/** Strata noise per metre along the wall: low, so a layer runs long. */
+const STRATA_RUN = 0.05;
+/** Layers per metre of height. */
+const STRATA_FREQUENCY = 1.6;
+/** How far the walls' normals ease toward up, 0 the contour's own shading, 1 none. */
+const WALL_SHADE_EASE = 0.75;
+/** How far (m) the cut's roughness pushes a wall sideways, outward (into the earth) or inward. */
+const CRUMBLE = 0.9;
+/** The roughness's noise per metre along the wall and per metre of depth. */
+const CRUMBLE_RUN = 0.55;
+const CRUMBLE_DEPTH = 0.45;
+/** Depth (m) below the rim where the roughness starts, and above the foot where it ends. */
+const CRUMBLE_RIM = 0.25;
+const CRUMBLE_FOOT = 0.9;
+/** The walls' foot goes this far under the pit's floor, so no gap shows between them. */
+const FOOT_TUCK = 0.03;
+/**
+ * The section cut's face (`EdgeLook.section`): one flat tone and a darker line at grade. Without
+ * it (`section-earth` too) the wall is the earth's: topsoil band, strata, a low crumble that is
+ * zero at the rim.
+ */
+const SECTION_TONE = '#747474';
+const SECTION_LINE = '#1e1e1e';
+const SECTION_LINE_DEPTH = 0.07;
+const pitTopY = uniform(0);
+const pitFloorY = uniform(0);
+// Where the dark floor is drawn: under the plate (`groundPitFloorY` in core), clear of the
+// plane the foundation stops on.
+const pitDrawnFloorY = uniform(0);
+const pitCrumble = uniform(CRUMBLE);
+const pitSection = uniform(0);
+/** Sets the walls' look for an edge look (uniforms: nothing recompiles). */
+export function setGroundPitEdge(look) {
+    pitCrumble.value = look.crumble;
+    pitSection.value = look.section;
+}
+/** The floor the pit goes down to now, world Y (the last level shown below grade). */
+export function groundPitFloorNow() {
+    return pitFloorY.value;
+}
+/** Where the pit draws its dark floor now, world Y: under the plate of that floor. */
+export function groundPitDrawnFloorNow() {
+    return pitDrawnFloorY.value;
+}
+function pitEase() {
+    return smoothstep(float(0), float(1), groundHoleOpenNode());
+}
+function wallMaterial(topsoil, foot) {
+    const material = new MeshLambertNodeMaterial({ side: FrontSide });
+    const drop = attribute('drop', 'float');
+    const slide = drop.mul(pitEase());
+    const drawnY = mix(positionLocal.y, pitDrawnFloorY.sub(FOOT_TUCK), slide);
+    // An earth cut is rough in depth: past the rim's own cut the wall is pushed sideways by a 3D
+    // noise that changes with depth, so a wiggle of the rim does not run straight down as a fold.
+    // Nothing at the rim (the top stays on the shader's cut) nor at the foot (it stays under the
+    // floor's plate), both eased in over a few tenths of a metre.
+    const belowRim = positionLocal.y.sub(drawnY);
+    const aboveFoot = drawnY.sub(pitDrawnFloorY.sub(FOOT_TUCK));
+    const rough = smoothstep(float(CRUMBLE_RIM), float(CRUMBLE_RIM * 5), belowRim).mul(smoothstep(float(0), float(CRUMBLE_FOOT), aboveFoot));
+    const crumble = (scale) => mx_noise_float(vec3(positionLocal.x.mul(CRUMBLE_RUN * scale), drawnY.mul(CRUMBLE_DEPTH * scale), positionLocal.z.mul(CRUMBLE_RUN * scale)));
+    // A broad lump and a finer one over it.
+    const bulge = crumble(1).add(crumble(2.7).mul(0.4)).mul(pitCrumble).mul(rough);
+    material.positionNode = vec3(positionLocal.x.sub(normalLocal.x.mul(bulge)), drawnY, positionLocal.z.sub(normalLocal.z.mul(bulge)));
+    // `positionWorld` is the displaced vertex (the position node feeds it), so `.y` is the height the
+    // wall is drawn at. Layers run long and flat: a wide, slow wave lifts and sinks them along the
+    // wall, and the strata's own noise is stretched along it so a band reads as a band, not a patch.
+    const wave = mx_noise_float(positionWorld.mul(vec3(0.07, 0, 0.07))).mul(STRATA_WAVE);
+    const sample = vec3(positionWorld.x.mul(STRATA_RUN), positionWorld.y.add(wave).mul(STRATA_FREQUENCY), positionWorld.z.mul(STRATA_RUN));
+    // The contour's folds are real, but lit as a wall each fold is a light or dark column. The pit
+    // is in shade: the normal is eased toward up so the folds shade softly and the strata lead.
+    material.normalNode = transformNormalToView(normalize(mix(normalLocal, vec3(0, 1, 0), WALL_SHADE_EASE)));
+    const strata = smoothstep(float(-0.06), float(0.06), mx_noise_float(sample));
+    const layers = mix(color(STRATA.dark), color(STRATA.light), strata);
+    const toFoot = mix(layers, color(foot), drop.mul(0.6).mul(float(1).sub(pitSection)));
+    // The ground's own layer along the cut, its lower edge a noise threshold like the rim.
+    const depthBelowTop = drop.mul(pitTopY.sub(pitFloorY)).mul(pitEase());
+    const edge = float(TOPSOIL_DEPTH).add(mx_noise_float(positionWorld.mul(vec3(1.3, 0, 1.3))).mul(0.12));
+    const soil = float(1)
+        .sub(smoothstep(edge.sub(0.04), edge, depthBelowTop))
+        .mul(float(1).sub(pitSection));
+    const earth = mix(toFoot, color(topsoil), soil);
+    // The section cut: a flat face and a thin dark line where it meets grade.
+    const gradeLine = float(1).sub(smoothstep(float(SECTION_LINE_DEPTH), float(SECTION_LINE_DEPTH * 1.6), depthBelowTop));
+    const section = mix(color(SECTION_TONE), color(SECTION_LINE), gradeLine);
+    material.colorNode = mix(earth, section, pitSection);
+    return material;
+}
+function floorMaterial(inHole) {
+    const material = new MeshLambertNodeMaterial({ side: FrontSide });
+    material.positionNode = vec3(positionLocal.x, mix(pitTopY, pitDrawnFloorY, pitEase()), positionLocal.z);
+    const grain = mx_noise_float(positionWorld.mul(vec3(0.8, 0, 0.8)))
+        .mul(0.5)
+        .add(0.5);
+    material.colorNode = mix(color(PIT_FLOOR_COLOR), color(PIT_FOOT), grain.mul(0.5));
+    material.maskNode = inHole;
+    return material;
+}
+/**
+ * The pit's walls and floor. `walls` is the cut contour (null: no hole), `box` the field's
+ * footprint the floor covers, `topY` the grade, `floorY` the shown level's floor and `drawnFloorY`
+ * where the dark floor is drawn (`groundPitFloorY`), all world Y.
+ */
+export function GroundPit({ walls, box, topY, floorY, drawnFloorY, topsoil, inHole, }) {
+    const wall = useMemo(() => wallMaterial(topsoil, PIT_FOOT), [topsoil]);
+    const floor = useMemo(() => (PIT_FLOOR ? floorMaterial(inHole) : null), [inHole]);
+    useEffect(() => () => {
+        wall.dispose();
+        floor?.dispose();
+    }, [wall, floor]);
+    const wallGeometry = useMemo(() => {
+        if (!walls)
+            return null;
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new BufferAttribute(walls.positions, 3));
+        geometry.setAttribute('normal', new BufferAttribute(walls.normals, 3));
+        geometry.setAttribute('drop', new BufferAttribute(walls.drops, 1));
+        geometry.setIndex(new BufferAttribute(walls.indices, 1));
+        return geometry;
+    }, [walls]);
+    const floorGeometry = useMemo(() => {
+        if (!box)
+            return null;
+        const { originX: x0, originZ: z0, span } = box;
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new BufferAttribute(new Float32Array([x0, 0, z0, x0, 0, z0 + span, x0 + span, 0, z0 + span, x0 + span, 0, z0]), 3));
+        geometry.setAttribute('normal', new BufferAttribute(new Float32Array([0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0]), 3));
+        geometry.setIndex([0, 1, 2, 0, 2, 3]);
+        return geometry;
+    }, [box]);
+    useEffect(() => () => wallGeometry?.dispose(), [wallGeometry]);
+    useEffect(() => () => floorGeometry?.dispose(), [floorGeometry]);
+    // Under the ground the hole stays open but its pit does not: the eye there sees the earth's
+    // dark mode, not the cut walls hanging in it. A flag, not a uniform: nothing recompiles.
+    const eyeAbove = useViewer((state) => !state.eyeUnderGround);
+    useEffect(() => {
+        pitTopY.value = topY;
+        if (floorY !== null)
+            pitFloorY.value = floorY;
+        if (drawnFloorY !== null)
+            pitDrawnFloorY.value = drawnFloorY;
+    }, [topY, floorY, drawnFloorY]);
+    return (_jsxs(_Fragment, { children: [wallGeometry && (_jsx("mesh", { frustumCulled: false, geometry: wallGeometry, material: wall, raycast: noopRaycast, userData: { groundPit: 'walls', pascalExport: 'strip' }, visible: eyeAbove })), floorGeometry && floor && (_jsx("mesh", { frustumCulled: false, geometry: floorGeometry, material: floor, raycast: noopRaycast, userData: { groundPit: 'floor', pascalExport: 'strip' }, visible: eyeAbove }))] }));
+}

package/dist/site/ground-veil.d.ts

@@ -0,0 +1,39 @@
+import type { TerrainField } from '@pascal-app/core';
+import { type BufferGeometry, type Material } from 'three';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+/** Presentation-only meshes are never picked: clicks fall through to what lies under them. */
+export declare const noopRaycast: () => void;
+type Point = readonly [number, number];
+/** The veil of the lot's own ground: its fill, or its sculpted terrain. */
+export declare function groundVeilMaterial(groundColor: string): MeshBasicNodeMaterial;
+/**
+ * The veil of the horizon disc: the ground past the lot only (under the lot's own veil a second
+ * one would read as a step at the property line), dissolving into the backdrop by twice the lot's
+ * radius.
+ */
+export declare function horizonVeilMaterial(groundColor: string, lot: ReadonlyArray<Point>, bounds: {
+    cx: number;
+    cz: number;
+    radius: number;
+}): MeshBasicNodeMaterial;
+/** The grade ring's ribbon along one outline where the ground meets a level below grade. */
+export declare function gradeRingGeometry(outline: ReadonlyArray<Point>, field: TerrainField | null): BufferGeometry;
+export declare function gradeRingMaterial(): MeshBasicNodeMaterial;
+/**
+ * Drawn only while the ground is veiled: the veil of one solid ground surface (the same geometry
+ * in the same place), or the grade ring. A direct child of the site, as the surfaces are, so the
+ * captures find it (`siteGround`) and hide it with the site's other surfaces.
+ *
+ * `shows` says when a live view draws it: `'window'` (a sheet: only where the ground window veils
+ * a hillside in the eye's way; wholesale the ground is a hole, not a sheet) or `'veiled'` (the
+ * ring: wherever any ground is veiled). A capture shows both by setting `visible` itself.
+ */
+export declare function GroundVeil({ geometry, material, position, rotation, shows, }: {
+    geometry: BufferGeometry;
+    material: Material;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    shows?: 'window' | 'veiled';
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=ground-veil.d.ts.map

package/dist/site/ground-veil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-veil.d.ts","sourceRoot":"","sources":["../../src/site/ground-veil.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAUpD,OAAO,EAAE,KAAK,cAAc,EAAc,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAatE,OAAO,EAAE,qBAAqB,EAAa,MAAM,cAAc,CAAA;AAW/D,8FAA8F;AAC9F,eAAO,MAAM,WAAW,YAAW,CAAA;AAKnC,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AA6BtC,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,yBAErD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,EACzB,MAAM,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,yBAMnD;AASD,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAC7B,KAAK,EAAE,YAAY,GAAG,IAAI,GACzB,cAAc,CAGhB;AAED,wBAAgB,iBAAiB,0BAShC;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,KAAgB,GACjB,EAAE;IACD,QAAQ,EAAE,cAAc,CAAA;IACxB,QAAQ,EAAE,QAAQ,CAAA;IAClB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAC5B,+BAiBA"}

package/dist/site/ground-veil.js

@@ -0,0 +1,86 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { anyGroundVeiled, groundWindowEnabledNode, inGroundWindowNode, SITE_GROUND, UNDERGROUND_RING, undergroundAmbianceNode, useViewer, } from '@pascal-app/viewer';
+import { DoubleSide } from 'three';
+import { color, float, mix, mrt, output, positionWorld, select, smoothstep, vec2, vec4, } from 'three/tsl';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+import { buildPatternedRibbon } from './line-ribbon.js';
+import { insideLotNode } from './lot-mask.js';
+import { buildDrapedPolyline } from './terrain-drape.js';
+// The ground over a level below grade. Wholesale (a level fully below grade, the ground on Auto)
+// the solid ground stays and a hole opens in it (`ground-hole.ts`); the veil sheets here are the
+// faint see-through ground of the ground window (a hillside in the eye's way) and of a capture
+// (which sets the solid ground aside and shows them), and the grade ring is drawn where the ground
+// meets the level below grade, in either.
+/** Presentation-only meshes are never picked: clicks fall through to what lies under them. */
+export const noopRaycast = () => { };
+/** How much of the ground shows as a veil: enough to read where grade is, and no more. */
+const VEIL_OPACITY = 0.1;
+/**
+ * Unlit and seen from both sides (an eye under grade sees it overhead), drawn over what lies under
+ * it without hiding it: no depth, and nothing written to the scene pass's normals and diffuse
+ * colour, or the screen-space ink would outline the whole sheet. `coverage` (0 to 1) is how much
+ * of the ground this sheet draws.
+ */
+function veilMaterial(groundColor, coverage) {
+    const material = new MeshBasicNodeMaterial({
+        transparent: true,
+        depthWrite: false,
+        side: DoubleSide,
+    });
+    material.colorNode = color(groundColor);
+    // Wholesale, the veil is the whole ground at `VEIL_OPACITY`. While the ground window is open
+    // (the hillside in the way, not a floor under it), only the ground in the window veils —
+    // at the same faintness — and the rest of this sheet draws nothing over the solid ground.
+    material.opacityNode = select(groundWindowEnabledNode(), select(inGroundWindowNode(), float(VEIL_OPACITY), float(0)), coverage.mul(VEIL_OPACITY));
+    // The plain field too: Follow's sight reads it, not the node, to tell what it sees through.
+    material.opacity = VEIL_OPACITY;
+    material.mrtNode = mrt({ output, diffuseColor: vec4(0), normal: vec4(0) });
+    return material;
+}
+/** The veil of the lot's own ground: its fill, or its sculpted terrain. */
+export function groundVeilMaterial(groundColor) {
+    return veilMaterial(groundColor, float(1));
+}
+/**
+ * The veil of the horizon disc: the ground past the lot only (under the lot's own veil a second
+ * one would read as a step at the property line), dissolving into the backdrop by twice the lot's
+ * radius.
+ */
+export function horizonVeilMaterial(groundColor, lot, bounds) {
+    const distance = positionWorld.xz.sub(vec2(bounds.cx, bounds.cz)).length();
+    const fade = float(1).sub(smoothstep(float(bounds.radius), float(bounds.radius * 2), distance));
+    const outsideLot = insideLotNode(lot, positionWorld.xz).not();
+    return veilMaterial(groundColor, select(outsideLot, fade, float(0)));
+}
+/** The grade ring: dark as the lot line, a little narrower, just over the ground. */
+const GRADE_RING_COLOR = '#1c1917';
+const GRADE_RING_WIDTH = 0.16;
+const GRADE_RING_LIFT = 0.015;
+/** One run, never broken: a ribbon pattern with no gap. */
+const UNBROKEN = [Number.POSITIVE_INFINITY, 0];
+/** The grade ring's ribbon along one outline where the ground meets a level below grade. */
+export function gradeRingGeometry(outline, field) {
+    const drape = buildDrapedPolyline({ points: outline, field, lift: GRADE_RING_LIFT, closed: true });
+    return buildPatternedRibbon(drape.positions, UNBROKEN, GRADE_RING_WIDTH);
+}
+export function gradeRingMaterial() {
+    const material = new MeshBasicNodeMaterial({ color: GRADE_RING_COLOR, side: DoubleSide });
+    // Under the ground's ambiance the ring is a light rim: a dark ring would vanish in the dark mode.
+    material.colorNode = mix(color(GRADE_RING_COLOR), color(UNDERGROUND_RING), undergroundAmbianceNode());
+    return material;
+}
+/**
+ * Drawn only while the ground is veiled: the veil of one solid ground surface (the same geometry
+ * in the same place), or the grade ring. A direct child of the site, as the surfaces are, so the
+ * captures find it (`siteGround`) and hide it with the site's other surfaces.
+ *
+ * `shows` says when a live view draws it: `'window'` (a sheet: only where the ground window veils
+ * a hillside in the eye's way; wholesale the ground is a hole, not a sheet) or `'veiled'` (the
+ * ring: wherever any ground is veiled). A capture shows both by setting `visible` itself.
+ */
+export function GroundVeil({ geometry, material, position, rotation, shows = 'window', }) {
+    const veiled = useViewer((state) => shows === 'veiled'
+        ? anyGroundVeiled(state)
+        : state.groundMode === 'auto' && state.groundWindowVeiled);
+    return (_jsx("mesh", { geometry: geometry, material: material, position: position, raycast: noopRaycast, rotation: rotation, userData: { [SITE_GROUND]: 'veil', pascalExport: 'strip' }, visible: veiled }));
+}

package/dist/site/ground-window-system.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Keeps the ground window (viewer `lib/ground-window`) matched to the eye: a few throttled
+ * CPU sight lines decide whether sculpted ground stands between the camera and the shown
+ * box at all — that word opens the window (`Ground: Auto` permitting) and is what the view
+ * bar reports — while the window's shape is drawn per fragment in TSL. Re-asked when the
+ * eye moves, the scene or the box changes, or the person flips the ground mode.
+ */
+export declare function GroundWindowSystem(): null;
+//# sourceMappingURL=ground-window-system.d.ts.map

package/dist/site/ground-window-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-window-system.d.ts","sourceRoot":"","sources":["../../src/site/ground-window-system.tsx"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,wBAAgB,kBAAkB,SA0DjC"}

package/dist/site/ground-window-system.js

@@ -0,0 +1,108 @@
+'use client';
+import { terrainBetweenEyeAndBox, useScene } from '@pascal-app/core';
+import { groundVeiled, groundWindowBoxNow, groundWindowContains, setGroundWindow, siteGround, useViewer, } from '@pascal-app/viewer';
+import { useFrame } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
+import { Vector3 } from 'three';
+import { groundHoleContains } from './ground-hole.js';
+/** How often the CPU word is re-asked, and how far the eye must move to ask it sooner. */
+const CHECK_INTERVAL_S = 0.2;
+const EYE_MOVE_M = 0.25;
+/**
+ * Keeps the ground window (viewer `lib/ground-window`) matched to the eye: a few throttled
+ * CPU sight lines decide whether sculpted ground stands between the camera and the shown
+ * box at all — that word opens the window (`Ground: Auto` permitting) and is what the view
+ * bar reports — while the window's shape is drawn per fragment in TSL. Re-asked when the
+ * eye moves, the scene or the box changes, or the person flips the ground mode.
+ */
+export function GroundWindowSystem() {
+    const last = useRef({
+        at: Number.NEGATIVE_INFINITY,
+        eye: new Vector3(Number.POSITIVE_INFINITY, 0, 0),
+        box: null,
+        mode: '',
+        walking: false,
+        veiled: false,
+        nodes: null,
+    });
+    const picks = useRef(new Map());
+    useFrame(({ camera, clock }) => {
+        const viewer = useViewer.getState();
+        const nodes = useScene.getState().nodes;
+        const box = viewer.groundWindowBox;
+        const check = last.current;
+        const due = clock.elapsedTime - check.at > CHECK_INTERVAL_S ||
+            camera.position.distanceTo(check.eye) > EYE_MOVE_M ||
+            box !== check.box ||
+            nodes !== check.nodes ||
+            viewer.groundMode !== check.mode ||
+            viewer.walkthroughMode !== check.walking ||
+            groundVeiled(viewer) !== check.veiled;
+        if (!due)
+            return;
+        check.at = clock.elapsedTime;
+        check.eye.copy(camera.position);
+        check.box = box;
+        check.mode = viewer.groundMode;
+        check.walking = viewer.walkthroughMode;
+        check.veiled = groundVeiled(viewer);
+        check.nodes = nodes;
+        const eye = [camera.position.x, camera.position.y, camera.position.z];
+        // The walkthrough walks on solid ground: no window, whatever the hillside. A level shown fully
+        // below grade is seen through the hole in the ground (`groundVeiled`), solid round it: no
+        // window opens over it, which would cut the solid ground in the box's silhouette and show the
+        // level through a translucent sheet in front of the opening. Any terrain field asks for one (a
+        // custom terrain, a pad, a retaining break), not only a hillside.
+        const inTheWay = !groundVeiled(viewer) &&
+            box !== null &&
+            !viewer.walkthroughMode &&
+            terrainBetweenEyeAndBox(nodes, eye, box);
+        if (viewer.groundWindowVeiled !== inTheWay)
+            useViewer.setState({ groundWindowVeiled: inTheWay });
+        const open = inTheWay && viewer.groundMode === 'auto' ? box : null;
+        if (groundWindowBoxNow() !== open)
+            setGroundWindow(open);
+        // Picks follow the window, and the hole over a level below grade seen as a whole.
+        keepPicksHonest(picks.current, open !== null || check.veiled);
+    });
+    useEffect(() => () => {
+        keepPicksHonest(picks.current, false);
+        setGroundWindow(null);
+        if (useViewer.getState().groundWindowVeiled)
+            useViewer.setState({ groundWindowVeiled: false });
+    }, []);
+    return null;
+}
+/**
+ * Picks agree with the window and the hole: while either is open, a hit on solid ground that
+ * is cut away is dropped, so the click (or Follow's sight) reaches what lies under it. The wrap
+ * reads the window's own CPU word (`groundWindowContains`) against the picking ray, and the
+ * hole's (`groundHoleContains`, its guaranteed core) at the hit, and every original raycast is
+ * given back when both close.
+ */
+function keepPicksHonest(wrapped, open) {
+    if (!open) {
+        for (const [mesh, raycast] of wrapped)
+            mesh.raycast = raycast;
+        wrapped.clear();
+        return;
+    }
+    for (const surface of siteGround().solid) {
+        const mesh = surface;
+        if (!mesh.isMesh || wrapped.has(mesh))
+            continue;
+        const original = mesh.raycast;
+        wrapped.set(mesh, original);
+        mesh.raycast = (raycaster, intersects) => {
+            const before = intersects.length;
+            original.call(mesh, raycaster, intersects);
+            for (let index = intersects.length - 1; index >= before; index -= 1) {
+                const hit = intersects[index];
+                if (hit &&
+                    (groundWindowContains(raycaster.ray.origin, hit.point) ||
+                        groundHoleContains(hit.point.x, hit.point.z)))
+                    intersects.splice(index, 1);
+            }
+        };
+    }
+}

package/dist/site/hole-noise.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The hole's edge noise on the CPU: the same fractal perlin the ground's shader reads
+ * (`mx_fractal_noise_float` of three's MaterialX lib, 3 octaves, 3D, the third axis constant), so
+ * the pit's walls can be laid along the very contour the ground's mask cuts. Integer hash and
+ * gradients as in `MaterialXNoise.js`, in unsigned 32-bit arithmetic.
+ */
+/** Three's `mx_perlin_noise_float` at a 3D point. */
+export declare function perlin3(px: number, py: number, pz: number): number;
+/** Three's `mx_fractal_noise_float` (octaves summed, each `diminish` weaker and `lacunarity` finer). */
+export declare function fractalNoise3(px: number, py: number, pz: number, octaves: number, lacunarity: number, diminish: number): number;
+//# sourceMappingURL=hole-noise.d.ts.map

package/dist/site/hole-noise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hole-noise.d.ts","sourceRoot":"","sources":["../../src/site/hole-noise.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAsCH,qDAAqD;AACrD,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CA6BlE;AAED,wGAAwG;AACxG,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,MAAM,CAWR"}

package/dist/site/hole-noise.js

@@ -0,0 +1,79 @@
+/**
+ * The hole's edge noise on the CPU: the same fractal perlin the ground's shader reads
+ * (`mx_fractal_noise_float` of three's MaterialX lib, 3 octaves, 3D, the third axis constant), so
+ * the pit's walls can be laid along the very contour the ground's mask cuts. Integer hash and
+ * gradients as in `MaterialXNoise.js`, in unsigned 32-bit arithmetic.
+ */
+const SEED = (0xdeadbeef + (3 << 2) + 13) >>> 0;
+function rotl(x, k) {
+    return ((x << k) | (x >>> (32 - k))) >>> 0;
+}
+function hash(x, y, z) {
+    let a = (SEED + x) >>> 0;
+    let b = (SEED + y) >>> 0;
+    let c = (SEED + z) >>> 0;
+    c = (c ^ b) >>> 0;
+    c = (c - rotl(b, 14)) >>> 0;
+    a = (a ^ c) >>> 0;
+    a = (a - rotl(c, 11)) >>> 0;
+    b = (b ^ a) >>> 0;
+    b = (b - rotl(a, 25)) >>> 0;
+    c = (c ^ b) >>> 0;
+    c = (c - rotl(b, 16)) >>> 0;
+    a = (a ^ c) >>> 0;
+    a = (a - rotl(c, 4)) >>> 0;
+    b = (b ^ a) >>> 0;
+    b = (b - rotl(a, 14)) >>> 0;
+    c = (c ^ b) >>> 0;
+    c = (c - rotl(b, 24)) >>> 0;
+    return c;
+}
+function gradient(h, x, y, z) {
+    const g = h & 15;
+    const u = g < 8 ? x : y;
+    const v = g < 4 ? y : g === 12 || g === 14 ? x : z;
+    return (g & 1 ? -u : u) + (g & 2 ? -v : v);
+}
+const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+/** Three's `mx_perlin_noise_float` at a 3D point. */
+export function perlin3(px, py, pz) {
+    const X = Math.floor(px);
+    const Y = Math.floor(py);
+    const Z = Math.floor(pz);
+    const fx = px - X;
+    const fy = py - Y;
+    const fz = pz - Z;
+    const gx = fx - 1;
+    const gy = fy - 1;
+    const gz = fz - 1;
+    const u = fade(fx);
+    const v = fade(fy);
+    const w = fade(fz);
+    const s1 = 1 - u;
+    const t1 = 1 - v;
+    const r1 = 1 - w;
+    const lowZ = t1 * (gradient(hash(X, Y, Z), fx, fy, fz) * s1 + gradient(hash(X + 1, Y, Z), gx, fy, fz) * u) +
+        v *
+            (gradient(hash(X, Y + 1, Z), fx, gy, fz) * s1 +
+                gradient(hash(X + 1, Y + 1, Z), gx, gy, fz) * u);
+    const highZ = t1 *
+        (gradient(hash(X, Y, Z + 1), fx, fy, gz) * s1 +
+            gradient(hash(X + 1, Y, Z + 1), gx, fy, gz) * u) +
+        v *
+            (gradient(hash(X, Y + 1, Z + 1), fx, gy, gz) * s1 +
+                gradient(hash(X + 1, Y + 1, Z + 1), gx, gy, gz) * u);
+    return 0.982 * (r1 * lowZ + w * highZ);
+}
+/** Three's `mx_fractal_noise_float` (octaves summed, each `diminish` weaker and `lacunarity` finer). */
+export function fractalNoise3(px, py, pz, octaves, lacunarity, diminish) {
+    let sum = 0;
+    let amplitude = 1;
+    for (let i = 0; i < octaves; i += 1) {
+        sum += amplitude * perlin3(px, py, pz);
+        amplitude *= diminish;
+        px *= lacunarity;
+        py *= lacunarity;
+        pz *= lacunarity;
+    }
+    return sum;
+}

package/dist/site/index.d.ts

@@ -1,2 +1,2 @@
-export { siteDefinition } from './definition';
+export { siteDefinition } from './definition.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/site/index.js

@@ -1 +1 @@
-export { siteDefinition } from './definition';
+export { siteDefinition } from './definition.js';

package/dist/site/lot-mask.d.ts

@@ -3,10 +3,12 @@ import type { Node } from 'three/webgpu';
 type Point = readonly [number, number];
 /**
  * True for a fragment inside the lot polygon (even-odd crossing count on its
- * local x, z). Unrolled edge by edge into the graph: a parcel has tens of
- * corners, so a loop and a uniform array would buy nothing.
+ * x, z: local, where the geometry is laid out in the site's plan as the
+ * terrain is; world for a mesh placed and turned there). Unrolled edge by edge
+ * into the graph: a parcel has tens of corners, so a loop and a uniform array
+ * would buy nothing.
  */
-export declare function insideLotNode(polygon: ReadonlyArray<Point>): Node<"bool">;
+export declare function insideLotNode(polygon: ReadonlyArray<Point>, at?: Node<'vec2'>): Node<"bool">;
 /**
  * The ground material cut to the lot: the terrain field is the padded,
  * north-up box around the parcel, and only the parcel itself is ground the

package/dist/site/lot-mask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lot-mask.d.ts","sourceRoot":"","sources":["../../src/site/lot-mask.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAErC,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,cAAc,CAAA;AAEtD,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEtC;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,gBAgB1D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,QAAQ,CAI7F"}
+{"version":3,"file":"lot-mask.d.ts","sourceRoot":"","sources":["../../src/site/lot-mask.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAErC,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,cAAc,CAAA;AAEtD,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEtC;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,EAAE,GAAE,IAAI,CAAC,MAAM,CAAoB,gBAe/F;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,QAAQ,CAO7F"}

package/dist/site/lot-mask.js

@@ -1,11 +1,12 @@
 import { float, mod, positionLocal, select } from 'three/tsl';
 /**
  * True for a fragment inside the lot polygon (even-odd crossing count on its
- * local x, z). Unrolled edge by edge into the graph: a parcel has tens of
- * corners, so a loop and a uniform array would buy nothing.
+ * x, z: local, where the geometry is laid out in the site's plan as the
+ * terrain is; world for a mesh placed and turned there). Unrolled edge by edge
+ * into the graph: a parcel has tens of corners, so a loop and a uniform array
+ * would buy nothing.
  */
-export function insideLotNode(polygon) {
-    const at = positionLocal.xz;
+export function insideLotNode(polygon, at = positionLocal.xz) {
     let crossings = float(0);
     for (let i = 0; i < polygon.length; i++) {
         const [ax, az] = polygon[i];
@@ -30,6 +31,9 @@ export function insideLotNode(polygon) {
  */
 export function lotMaskedMaterial(material, polygon) {
     const masked = material.clone();
-    masked.maskNode = insideLotNode(polygon);
+    // Keep a mask the material already carries (the ground window's): the ground is cut to
+    // the lot AND out of the window, not one instead of the other.
+    const inside = insideLotNode(polygon);
+    masked.maskNode = masked.maskNode ? masked.maskNode.and(inside) : inside;
     return masked;
 }

package/dist/site/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/site/panel.tsx"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,wBAAgB,aAAa,uCA8T5B;AAWD,eAAe,aAAa,CAAA"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/site/panel.tsx"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,wBAAgB,aAAa,uCA+W5B;eAWc,aAAa"}