@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/site/renderer.js

@@ -1,19 +1,24 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { terrainFieldOf, unionPolygons, useLiveNodeOverrides, useLiveTerrain, useRegistry, useScene, } from '@pascal-app/core';
-import { backdropGradient, deepSkyColor, getSceneTheme, horizonHazeColor, NodeRenderer, useImmersiveXRPresentation, useNodeEvents, useSceneAtmosphere, useSceneGroundReplacement, useViewer, } from '@pascal-app/viewer';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { belowGradeFloorY, belowGradeFootprints, coveredBelowGradeFootprints, groundPitFloorY, intersection, sightTriangle, siteFrontEdge, siteSetbackEnvelope, streetCorners, surfaceHeightAt, terrainContours, terrainFieldOf, union, unionPolygons, useLiveNodeOverrides, useLiveTerrain, useRegistry, useScene, } from '@pascal-app/core';
+import { backdropColors, backdropGradient, groundWindowMaskNode, NodeRenderer, SITE_GROUND, siteGroundShown, UNDERGROUND_RIM, useImmersiveXRPresentation, useNodeEvents, useSceneAtmosphere, useSceneGroundReplacement, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef } from 'react';
-import { BufferAttribute, BufferGeometry, Path, Shape, ShapeGeometry } from 'three';
+import { BufferAttribute, BufferGeometry, DoubleSide, Path, Shape, ShapeGeometry, } from 'three';
 import { cameraPosition, color, mix, positionWorld, smoothstep, float as tslFloat, vec2, } from 'three/tsl';
 import { MeshLambertNodeMaterial } from 'three/webgpu';
-import { getRecessedSlabGroundHoles } from './recessed-slab-ground-holes';
-import { buildDrapedPolyline, terrainGridKey, updateDrapedHeights, } from './terrain-drape';
-import { HORIZON_PLANE_Y, terrainFootprint } from './terrain-geometry';
-import { TerrainRenderer } from './terrain-renderer';
+import { GenericFoundation } from './generic-foundation.js';
+import { GroundHole, groundHoleColorNode, groundHoleShadowNode, solidGroundMaskNode, } from './ground-hole.js';
+import { GroundVeil, gradeRingGeometry, gradeRingMaterial, groundVeilMaterial, horizonVeilMaterial, noopRaycast, } from './ground-veil.js';
+import { GroundWindowSystem } from './ground-window-system.js';
+import { buildPatternedRibbon, PROPERTY_LINE_PATTERN, SETBACK_LINE_PATTERN, updateRibbonHeights, } from './line-ribbon.js';
+import { getRecessedSlabGroundHoles } from './recessed-slab-ground-holes.js';
+import { buildDrapedPolyline, terrainGridKey, updateDrapedHeights, } from './terrain-drape.js';
+import { HORIZON_PLANE_Y, terrainBlockBase } from './terrain-geometry.js';
+import { TerrainRenderer } from './terrain-renderer.js';
 const Y_OFFSET = 0.01;
-// The horizon disc is presentation-only — clicks must fall through to the
-// real site polygon / grid, so its raycast is a no-op.
-const noopRaycast = () => { };
+/** The flat lot's fill, just under grade; the plan's shapes lie in XY, turned to lie flat. */
+const GROUND_FILL_POSITION = [0, -0.05, 0];
+const FLAT_ON_THE_GROUND = [-Math.PI / 2, 0, 0];
 /**
  * The site boundary line, laid on the ground rather than across it.
  *
@@ -41,13 +46,15 @@ const createBoundaryLineGeometry = (points, field) => {
     geometry.setAttribute('uv', new BufferAttribute(uvs, 2));
     return { geometry, ring };
 };
-/**
- * Re-upload a draped ring's positions after an in-place height rewrite.
- *
- * No `addUpdateRange`: a dab can move any subset of the ring's vertices (the brush
- * is a disc, the ring is a loop, and the two intersect in up to four arcs), so a
- * range would either be the whole buffer or a list. The whole buffer is a few KB.
- */
+function redrapeRibbons(r, field) {
+    if (!r)
+        return;
+    updateRibbonHeights(r.property, field, Y_OFFSET);
+    if (r.envelope)
+        updateRibbonHeights(r.envelope, field, Y_OFFSET + 0.01);
+    for (const g of r.triangles)
+        updateRibbonHeights(g, field, Y_OFFSET + 0.012);
+}
 function markPositionsDirty(geometry) {
     const attribute = geometry.getAttribute('position');
     attribute.needsUpdate = true;
@@ -79,14 +86,10 @@ export const SiteRenderer = ({ node }) => {
     const atmosphere = useSceneAtmosphere();
     const groundReplaced = useSceneGroundReplacement();
     useRegistry(node.id, 'site', ref);
-    const bgColor = useViewer((state) => getSceneTheme(state.sceneTheme).ground);
-    const backgroundColor = useViewer((state) => getSceneTheme(state.sceneTheme).background);
-    const skyColor = useViewer((state) => {
-        const theme = getSceneTheme(state.sceneTheme);
-        return theme.backgroundSky ?? theme.background;
-    });
-    const appearance = useViewer((state) => getSceneTheme(state.sceneTheme).appearance);
-    const maxLightIntensity = useViewer((state) => Math.max(1, ...getSceneTheme(state.sceneTheme).lights.map((light) => light.intensity)));
+    const theme = useViewer((state) => state.sceneAppearance);
+    const bgColor = theme.ground;
+    const { background: backgroundColor, sky: skyColor, haze, skyDeep } = backdropColors(theme);
+    const maxLightIntensity = Math.max(1, ...theme.lights.map((light) => light.intensity));
     const livePolygon = useLiveNodeOverrides((state) => state.overrides.get(node.id)?.polygon ?? null);
     const polygonPoints = livePolygon?.points ?? node.polygon?.points;
     // Persisted terrain only. A stroke is applied imperatively further down, for the
@@ -119,16 +122,73 @@ export const SiteRenderer = ({ node }) => {
         }
         return { cx, cz, radius };
     }, [polygonPoints]);
+    // Where the ground meets the levels below grade. `all` says whether the scene has any (the
+    // ground materials carry the hole's mask from then on); `shown` is what the hole is cut over and
+    // the grade ring runs along under the veil: the level shown and the ones between it and grade, as
+    // the level display hides them. While the level shown is not below grade the last such set is
+    // kept, so a hole easing shut keeps its shape. `covered` is the part of them under the house
+    // itself, whatever level is shown: the ground stands open there (see `holes`).
+    const shownLevelId = useViewer((state) => state.hideLevelsAboveSelection ? state.selection.levelId : null);
+    const belowGrade = useViewer((state) => state.belowGrade);
+    const groundMode = useViewer((state) => state.groundMode);
+    const buriedCache = useRef({ all: [], shown: [], floorY: null, drawnFloorY: null, covered: [] });
+    const buried = useScene((state) => {
+        const prev = buriedCache.current;
+        const found = belowGradeFootprints(state.nodes);
+        const all = polygonsMatch(found, prev.all) ? prev.all : found;
+        const foundCovered = all.length > 0 ? coveredBelowGradeFootprints(state.nodes) : [];
+        const covered = polygonsMatch(foundCovered, prev.covered) ? prev.covered : foundCovered;
+        let shown = [];
+        let floorY = null;
+        let drawnFloorY = null;
+        if (all.length > 0) {
+            shown = shownLevelId ? belowGradeFootprints(state.nodes, shownLevelId) : [];
+            floorY = shownLevelId ? belowGradeFloorY(state.nodes, shownLevelId) : null;
+            drawnFloorY = shownLevelId ? groundPitFloorY(state.nodes, shownLevelId) : null;
+            if (shown.length === 0)
+                shown = prev.shown.length > 0 ? prev.shown : all;
+            floorY ??= prev.floorY;
+            drawnFloorY ??= prev.drawnFloorY;
+        }
+        if (polygonsMatch(shown, prev.shown))
+            shown = prev.shown;
+        if (all === prev.all &&
+            shown === prev.shown &&
+            floorY === prev.floorY &&
+            drawnFloorY === prev.drawnFloorY &&
+            covered === prev.covered)
+            return prev;
+        buriedCache.current = { all, shown, floorY, drawnFloorY, covered };
+        return buriedCache.current;
+    });
+    // Where the pit's walls start: the ground itself, flat or the sculpted terrain.
+    const groundTopAt = useMemo(() => (x, z) => persistedField ? surfaceHeightAt(persistedField, x, z) : GROUND_FILL_POSITION[1], [persistedField]);
     // Lit (not Basic) so the site ground receives the directional shadow — Basic
     // is unlit, which is why shadows used to stop dead at the slab edge. polygonOffset
     // keeps it tucked behind the grid/slab as before.
+    // The hole's nodes are in the material from the moment the scene has a level below grade (once,
+    // not when a floor is picked), the opening a uniform; without one the materials stay plain.
+    const hasBasement = buried.all.length > 0;
     const groundMaterial = useMemo(() => {
         const material = new MeshLambertNodeMaterial({ color: bgColor });
         material.polygonOffset = true;
         material.polygonOffsetFactor = 1;
         material.polygonOffsetUnits = 1;
+        // The ground window cuts the solid ground where it stands in the eye's way (viewer
+        // lib/ground-window), and the hole opens over a level below grade (ground-hole.tsx), its
+        // edge a noise threshold with a thin slate rim; with both closed the mask passes everywhere.
+        if (hasBasement) {
+            ;
+            material.maskNode = solidGroundMaskNode();
+            material.colorNode = groundHoleColorNode(UNDERGROUND_RIM);
+            material.receivedShadowNode = groundHoleShadowNode();
+        }
+        else {
+            ;
+            material.maskNode = groundWindowMaskNode();
+        }
         return material;
-    }, [bgColor]);
+    }, [bgColor, hasBasement]);
     // Presentation horizon: a large ground disc under the lot, fading into the
     // active fog radiance (or the theme backdrop when there is no atmosphere) so
     // the scene sits on an "infinite" plane instead of a hard-edged plate. Never pickable.
@@ -160,25 +220,43 @@ export const SiteRenderer = ({ node }) => {
             : backdropGradient({
                 dirY: viewDir.y,
                 background: color(backgroundColor),
-                haze: color(horizonHazeColor(skyColor, appearance)),
+                haze: color(haze),
                 sky: color(skyColor),
-                skyDeep: color(deepSkyColor(skyColor)),
+                skyDeep: color(skyDeep),
             });
         material.emissiveNode = mix(color('#000000'), backdrop, fade).mul(haloFactor);
         material.polygonOffset = true;
         material.polygonOffsetFactor = 2;
         material.polygonOffsetUnits = 2;
+        if (hasBasement) {
+            ;
+            material.maskNode = solidGroundMaskNode();
+            material.receivedShadowNode = groundHoleShadowNode();
+        }
+        else {
+            ;
+            material.maskNode = groundWindowMaskNode();
+        }
         return material;
     }, [
+        hasBasement,
         atmosphere,
         bgColor,
         backgroundColor,
         skyColor,
-        appearance,
+        haze,
+        skyDeep,
         maxLightIntensity,
         fadeBounds,
         groundReplaced,
     ]);
+    // Over a level below grade the ground is drawn as a veil (ground-veil.tsx).
+    const groundVeil = useMemo(() => groundVeilMaterial(bgColor), [bgColor]);
+    useEffect(() => () => groundVeil.dispose(), [groundVeil]);
+    const horizonVeil = useMemo(() => fadeBounds && polygonPoints && !groundReplaced
+        ? horizonVeilMaterial(bgColor, polygonPoints, fadeBounds)
+        : null, [bgColor, fadeBounds, polygonPoints, groundReplaced]);
+    useEffect(() => () => horizonVeil?.dispose(), [horizonVeil]);
     // Cache computed polygons to keep the selector stable across unrelated store updates.
     const slabPolygonsCache = useRef([]);
     const slabPolygons = useScene((state) => {
@@ -189,6 +267,30 @@ export const SiteRenderer = ({ node }) => {
         slabPolygonsCache.current = next;
         return next;
     });
+    // What the ground is cut open over: the recessed slabs, and the basement under the house. The
+    // house covers that part of a basement, so the ground there is open whatever level is shown:
+    // from outside nothing changes, and a stairwell, a floor opening or a walkthrough on the stair
+    // meets the basement, not a sheet of ground across it. A basement reaching out under the garden
+    // stays closed past the house (no pit in the garden) until its level is shown, and the hole of
+    // the level shown does the rest as it does. The one case it closes: the level display has the
+    // storeys away over a level below grade and the person keeps the ground Solid, nothing covers
+    // it then and Solid asks for solid ground. Clipped to the lot, as a hole past its line breaks
+    // the triangulation.
+    const coverOpen = !(belowGrade && groundMode === 'solid');
+    const holes = useMemo(() => {
+        if (!coverOpen || buried.covered.length === 0 || !polygonPoints || polygonPoints.length < 3)
+            return slabPolygons;
+        const inLot = intersection(union(buried.covered), polygonPoints);
+        const covered = inLot.filter((piece) => piece.holes.length === 0).map((piece) => piece.outer);
+        return covered.length > 0 ? [...slabPolygons, ...covered] : slabPolygons;
+    }, [coverOpen, buried.covered, polygonPoints, slabPolygons]);
+    const gradeRings = useMemo(() => buried.shown.map((outline) => gradeRingGeometry(outline, persistedField)), [buried.shown, persistedField]);
+    useEffect(() => () => {
+        for (const ring of gradeRings)
+            ring.dispose();
+    }, [gradeRings]);
+    const gradeRing = useMemo(gradeRingMaterial, []);
+    useEffect(() => () => gradeRing.dispose(), [gradeRing]);
     // Ground shape: site polygon with slab footprints punched as holes
     const groundShape = useMemo(() => {
         if (!polygonPoints || polygonPoints.length < 3)
@@ -199,13 +301,14 @@ export const SiteRenderer = ({ node }) => {
         for (let i = 1; i < pts.length; i++)
             shape.lineTo(pts[i][0], -pts[i][1]);
         shape.closePath();
-        addSlabHoles(shape, slabPolygons);
+        addSlabHoles(shape, holes);
         return shape;
-    }, [polygonPoints, slabPolygons]);
-    // The terrain footprint is punched out alongside the recessed slabs, and for the
-    // same reason: the disc must not cap ground that is modelled below it.
-    //
-    // biome-ignore lint/correctness/useExhaustiveDependencies: `terrainKey` is the grid signature the footprint is a function of; depending on the field itself would rebuild an 800 m disc every dab.
+    }, [polygonPoints, holes]);
+    // With terrain the lot is a block — its ground cut to the property line, its
+    // skirt dropping to one flat base — and the disc lies just under that base, so
+    // nothing of it caps the lot and nothing of the block stands proud of it from
+    // the far side. The recessed slabs are still punched: a basement can go deeper.
+    const horizonY = useMemo(() => (terrainGrid ? terrainBlockBase(terrainGrid) - 0.02 : HORIZON_PLANE_Y), [terrainGrid]);
     const horizonGeometry = useMemo(() => {
         if (!fadeBounds || groundReplaced)
             return null;
@@ -218,10 +321,9 @@ export const SiteRenderer = ({ node }) => {
             shape.lineTo(Math.cos(angle) * radius, Math.sin(angle) * radius);
         }
         shape.closePath();
-        const holes = terrainGrid ? [...slabPolygons, terrainFootprint(terrainGrid)] : slabPolygons;
         addSlabHoles(shape, holes, fadeBounds.cx, fadeBounds.cz);
         return new ShapeGeometry(shape);
-    }, [fadeBounds, slabPolygons, terrainKey, groundReplaced]);
+    }, [fadeBounds, holes, groundReplaced]);
     useEffect(() => () => horizonGeometry?.dispose(), [horizonGeometry]);
     useEffect(() => () => horizonMaterial?.dispose(), [horizonMaterial]);
     // Boundary line geometry, subdivided against the terrain grid when there is one.
@@ -243,6 +345,72 @@ export const SiteRenderer = ({ node }) => {
     }, [polygonPoints, terrainKey, node.id]);
     useEffect(() => () => boundary?.geometry.dispose(), [boundary]);
     const lineGeometry = boundary?.geometry ?? null;
+    // A site with drafted setbacks draws the PROPERTY LINE as the standard line —
+    // dark, thick, a long dash and two dots — and the SETBACK lines in black
+    // dashes, both ribbons lying on the draped ground (line-ribbon.ts). Any other
+    // site keeps the plain amber boundary. Keyed on the same grid as the
+    // boundary; a dab mid-stroke moves the thin ring only, the ribbons follow
+    // on the commit.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: keyed on the grid, not the field — see above.
+    const ribbons = useMemo(() => {
+        const setbacks = node.setbacks;
+        if (!setbacks || !boundary || !polygonPoints || polygonPoints.length < 3)
+            return null;
+        const field = useLiveTerrain.getState().fieldOf(node.id) ?? persistedField;
+        const property = buildPatternedRibbon(boundary.ring.positions, PROPERTY_LINE_PATTERN, 0.22);
+        let envelopeGeometry = null;
+        const triangleGeometries = [];
+        const points = polygonPoints.map(([x, z]) => [x ?? 0, z ?? 0]);
+        // the live ring, measured the one way the site plan and the agents measure it
+        const lot = { ...node, polygon: { type: 'polygon', points } };
+        const front = siteFrontEdge(lot);
+        const streetEdges = node.streetEdges ?? [];
+        const sightTriangleM = typeof node.sightTriangleFt === 'number' && node.sightTriangleFt > 0
+            ? node.sightTriangleFt * 0.3048
+            : 0;
+        const envelope = siteSetbackEnvelope(lot);
+        if (envelope.length >= 3) {
+            const draped = buildDrapedPolyline({
+                points: envelope,
+                field,
+                lift: Y_OFFSET + 0.01,
+                closed: true,
+            });
+            envelopeGeometry = buildPatternedRibbon(draped.positions, SETBACK_LINE_PATTERN, 0.1);
+        }
+        // the corner sight triangles, dashed like the setbacks
+        if (sightTriangleM > 0) {
+            for (const [a, b] of streetCorners(points, [front, ...streetEdges])) {
+                const tri = sightTriangle(points, a, b, sightTriangleM);
+                if (!tri)
+                    continue;
+                const draped = buildDrapedPolyline({
+                    points: [tri.corner, tri.a, tri.b],
+                    field,
+                    lift: Y_OFFSET + 0.012,
+                    closed: true,
+                });
+                triangleGeometries.push(buildPatternedRibbon(draped.positions, SETBACK_LINE_PATTERN, 0.08));
+            }
+        }
+        return { property, envelope: envelopeGeometry, triangles: triangleGeometries };
+    }, [
+        boundary,
+        polygonPoints,
+        node.setbacks,
+        node.frontEdge,
+        node.streetEdges,
+        node.sightTriangleFt,
+        node.northRotation,
+        terrainKey,
+        node.id,
+    ]);
+    useEffect(() => () => {
+        ribbons?.property.dispose();
+        ribbons?.envelope?.dispose();
+        for (const g of ribbons?.triangles ?? [])
+            g.dispose();
+    }, [ribbons]);
     // Per-dab height rewrite, imperative for the same reason `TerrainRenderer`'s
     // upload is: a stroke pushes dozens of patches a second, and routing each through
     // a React render would rebuild the ring's buffers at pointer rate. The XZ of every
@@ -252,6 +420,8 @@ export const SiteRenderer = ({ node }) => {
     // polygon edit without resubscribing.
     const boundaryRef = useRef(null);
     boundaryRef.current = boundary;
+    const ribbonsRef = useRef(null);
+    ribbonsRef.current = ribbons;
     useEffect(() => {
         let lastPatch = useLiveTerrain.getState().strokeOf(node.id)?.lastPatch ?? null;
         return useLiveTerrain.subscribe((state) => {
@@ -268,6 +438,7 @@ export const SiteRenderer = ({ node }) => {
                     const field = terrainFieldOf({ id: node.id, terrain: node.terrain });
                     updateDrapedHeights(current.ring, field, Y_OFFSET);
                     markPositionsDirty(current.geometry);
+                    redrapeRibbons(ribbonsRef.current, field);
                 }
                 return;
             }
@@ -276,8 +447,68 @@ export const SiteRenderer = ({ node }) => {
             lastPatch = stroke.lastPatch;
             updateDrapedHeights(current.ring, stroke.field, Y_OFFSET);
             markPositionsDirty(current.geometry);
+            // the property and setback ribbons follow the same dab
+            redrapeRibbons(ribbonsRef.current, stroke.field);
         });
     }, [node.id, node.terrain]);
+    // The CONTOUR LINES on the ground (toggleable in 3D, drawn as faint,
+    // translucent near-black lines): the site's surveyed lines (the dossier's 3DEP set) at the
+    // site-plan interval, else the heightfield's own contours; each draped
+    // on the ground and merged into one line-segments buffer. Rebuilt on the
+    // terrain COMMIT (the persisted field), not per dab.
+    const contourGeometry = useMemo(() => {
+        if (!node.contours3d)
+            return null;
+        const intervalIn = node.contourIntervalIn ?? 12;
+        if (!(intervalIn > 0))
+            return null;
+        const field = persistedField;
+        const lot = (polygonPoints ?? []);
+        const stepFt = intervalIn / 12;
+        const surveyed = node.terrainContours;
+        const multiple = (a, b) => Math.abs(a / b - Math.round(a / b)) < 1e-9;
+        let lines = [];
+        if (surveyed && surveyed.lines.length > 0 && multiple(stepFt, surveyed.intervalFt)) {
+            lines = surveyed.lines.filter((l) => multiple(l.elevationFt, stepFt)).map((l) => l.points);
+        }
+        else if (field) {
+            lines = terrainContours(field, intervalIn * 0.0254, lot).map((c) => c.points);
+        }
+        const chunks = [];
+        let total = 0;
+        for (const points of lines) {
+            if (points.length < 2)
+                continue;
+            const draped = buildDrapedPolyline({ points, field, lift: Y_OFFSET + 0.005, closed: false });
+            const n = draped.positions.length / 3;
+            if (n < 2)
+                continue;
+            const seg = new Float32Array((n - 1) * 6);
+            for (let i = 0; i < n - 1; i++) {
+                seg[i * 6] = draped.positions[i * 3] ?? 0;
+                seg[i * 6 + 1] = draped.positions[i * 3 + 1] ?? 0;
+                seg[i * 6 + 2] = draped.positions[i * 3 + 2] ?? 0;
+                seg[i * 6 + 3] = draped.positions[i * 3 + 3] ?? 0;
+                seg[i * 6 + 4] = draped.positions[i * 3 + 4] ?? 0;
+                seg[i * 6 + 5] = draped.positions[i * 3 + 5] ?? 0;
+            }
+            chunks.push(seg);
+            total += seg.length;
+        }
+        if (total === 0)
+            return null;
+        const merged = new Float32Array(total);
+        let at = 0;
+        for (const c of chunks) {
+            merged.set(c, at);
+            at += c.length;
+        }
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new BufferAttribute(merged, 3));
+        geometry.computeBoundingSphere();
+        return geometry;
+    }, [node.contours3d, node.contourIntervalIn, node.terrainContours, persistedField, polygonPoints]);
+    useEffect(() => () => contourGeometry?.dispose(), [contourGeometry]);
     const groundGeometry = useMemo(() => {
         if (!groundShape)
             return null;
@@ -295,11 +526,15 @@ export const SiteRenderer = ({ node }) => {
     // drops the parcel's own presentation — ground fill, sculpted ground, lot
     // line — while everything standing on the site keeps its own flag (the
     // exporter and the 2D plan draw the same line). The horizon disc is a world
-    // backdrop rather than part of the parcel, so it stays either way.
+    // backdrop rather than part of the parcel, so `visible` does not hide it.
+    // `showGround` hides both ground and horizon when authored geometry supplies them, unless a level
+    // below grade is shown: the level display hides that geometry then, and the ground stands in.
     const showSiteSurfaces = node.visible !== false;
+    const showGround = siteGroundShown(node, { belowGrade });
     if (!(node && lineGeometry)) {
         return null;
     }
-    return (_jsxs("group", { ref: ref, ...handlers, children: [(node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))), showSiteSurfaces && showTerrain && _jsx(TerrainRenderer, { material: groundMaterial, site: node }), showSiteSurfaces && groundGeometry && !showTerrain && (_jsx("mesh", { geometry: groundGeometry, material: groundMaterial, position: [0, -0.05, 0], receiveShadow: true, rotation: [-Math.PI / 2, 0, 0] })), !immersiveXR && horizonGeometry && horizonMaterial && fadeBounds && (_jsx("mesh", { geometry: horizonGeometry, material: horizonMaterial, position: [fadeBounds.cx, HORIZON_PLANE_Y, fadeBounds.cz], raycast: noopRaycast, receiveShadow: true, rotation: [-Math.PI / 2, 0, 0], userData: { pascalExport: 'strip' } })), showSiteSurfaces && (_jsx("line", { frustumCulled: false, geometry: lineGeometry, renderOrder: 9, children: _jsx("lineBasicMaterial", { color: "#f59e0b", linewidth: 2, opacity: 0.6, transparent: true }) }))] }));
+    return (_jsxs("group", { ref: ref, ...handlers, children: [_jsx(GroundWindowSystem, {}), _jsx(GenericFoundation, {}), _jsx(GroundHole, { drawnFloorY: buried.drawnFloorY, floorY: buried.floorY, footprints: buried.shown, present: hasBasement, topAt: groundTopAt, topsoil: bgColor, topY: GROUND_FILL_POSITION[1] }), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))), showSiteSurfaces && showGround && showTerrain && (_jsx(TerrainRenderer, { holes: holes, material: groundMaterial, polygon: polygonPoints, site: node, veil: groundVeil })), showSiteSurfaces && showGround && groundGeometry && !showTerrain && (_jsxs(_Fragment, { children: [_jsx("mesh", { geometry: groundGeometry, material: groundMaterial, position: GROUND_FILL_POSITION, receiveShadow: true, rotation: FLAT_ON_THE_GROUND, userData: { [SITE_GROUND]: 'solid' } }), _jsx(GroundVeil, { geometry: groundGeometry, material: groundVeil, position: GROUND_FILL_POSITION, rotation: FLAT_ON_THE_GROUND })] })), showGround && !immersiveXR && horizonGeometry && horizonMaterial && fadeBounds && (_jsx("mesh", { geometry: horizonGeometry, material: horizonMaterial, position: [fadeBounds.cx, horizonY, fadeBounds.cz], raycast: noopRaycast, receiveShadow: true, rotation: FLAT_ON_THE_GROUND, userData: { pascalExport: 'strip', [SITE_GROUND]: 'solid' } })), showGround && !immersiveXR && horizonGeometry && horizonVeil && fadeBounds && (_jsx(GroundVeil, { geometry: horizonGeometry, material: horizonVeil, position: [fadeBounds.cx, horizonY, fadeBounds.cz], rotation: FLAT_ON_THE_GROUND })), showSiteSurfaces &&
+                gradeRings.map((geometry, index) => (_jsx(GroundVeil, { geometry: geometry, material: gradeRing, shows: "veiled" }, index))), showSiteSurfaces && ribbons && (_jsxs(_Fragment, { children: [_jsx("mesh", { frustumCulled: false, geometry: ribbons.property, raycast: noopRaycast, renderOrder: 9, children: _jsx("meshBasicMaterial", { color: "#1c1917", depthWrite: false, side: DoubleSide, toneMapped: false }) }), ribbons.envelope && (_jsx("mesh", { frustumCulled: false, geometry: ribbons.envelope, raycast: noopRaycast, renderOrder: 9, children: _jsx("meshBasicMaterial", { color: "#000000", depthWrite: false, opacity: 0.85, side: DoubleSide, toneMapped: false, transparent: true }) })), ribbons.triangles.map((g, i) => (_jsx("mesh", { frustumCulled: false, geometry: g, raycast: noopRaycast, renderOrder: 9, children: _jsx("meshBasicMaterial", { color: "#000000", depthWrite: false, opacity: 0.85, side: DoubleSide, toneMapped: false, transparent: true }) }, i))), _jsx("line", { frustumCulled: false, geometry: lineGeometry, renderOrder: 8, children: _jsx("lineBasicMaterial", { color: "#1c1917", opacity: 0.5, transparent: true }) })] })), showSiteSurfaces && !ribbons && (_jsx("line", { frustumCulled: false, geometry: lineGeometry, renderOrder: 9, children: _jsx("lineBasicMaterial", { color: "#f59e0b", linewidth: 2, opacity: 0.6, transparent: true }) })), showSiteSurfaces && contourGeometry && (_jsx("lineSegments", { frustumCulled: false, geometry: contourGeometry, raycast: noopRaycast, renderOrder: 8, children: _jsx("lineBasicMaterial", { color: "#000000", depthWrite: false, opacity: 0.22, toneMapped: false, transparent: true }) }))] }));
 };
 export default SiteRenderer;

package/dist/site/terrain-geometry.d.ts

@@ -32,6 +32,14 @@ import { type HeightPatch, type TerrainField } from '@pascal-app/core';
  * one. Two readers, one number.
  */
 export declare const HORIZON_PLANE_Y = -0.07;
+/**
+ * How far the skirt's base hangs below the lowest thing it must close over.
+ *
+ * Only the top edge is visually load-bearing; the base just has to be out of sight
+ * under the horizon disc. A metre reads as earth thickness from a grazing camera
+ * without being tall enough to poke out of a neighbouring excavation.
+ */
+export declare const SKIRT_DROP = 1;
 /** One vertex per sample, row-major — index `r * cols + c` matches the field. */
 export type TerrainMeshBuffers = {
     /** xyz per sample, length `cols * rows * 3`. */
@@ -68,6 +76,11 @@ export type TerrainSkirtBuffers = {
     positions: Float32Array;
     normals: Float32Array;
     indices: Uint32Array;
+    /**
+     * When the skirt follows the lot's property line (`skirtRing`): its x, z pairs,
+     * counter-clockwise. Absent, the skirt runs round the field's own rectangle.
+     */
+    ring?: Float32Array;
 };
 /**
  * The field's own footprint, as a polygon to punch out of the horizon disc.
@@ -89,7 +102,21 @@ export type TerrainSkirtBuffers = {
  * decides whether a pit is visible, and that is a property to assert, not to eyeball.
  */
 export declare function terrainFootprint(field: TerrainField): Array<[number, number]>;
-export declare function buildTerrainSkirt(field: TerrainField): TerrainSkirtBuffers;
+/**
+ * The base of the lot as a block: one flat level under the field's lowest
+ * point (and under the horizon plane), so the skirt along the property line
+ * reads as earth whose thickness follows the slope, and the horizon disc can
+ * sit just beneath it without cutting into the lot anywhere.
+ */
+export declare function terrainBlockBase(field: TerrainField): number;
+/**
+ * The lot's property line as the skirt walks it: counter-clockwise in x, z (the
+ * field perimeter's own direction, so one winding and one normal formula serve
+ * both), a point at least every half grid cell so the top edge follows the
+ * ground between samples. Empty when the polygon is not a ring.
+ */
+export declare function skirtRing(field: TerrainField, polygon: ReadonlyArray<readonly [number, number]>): Float32Array;
+export declare function buildTerrainSkirt(field: TerrainField, ring?: Float32Array | null): TerrainSkirtBuffers;
 /**
  * Rewrite the whole skirt in place.
  *

package/dist/site/terrain-geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terrain-geometry.d.ts","sourceRoot":"","sources":["../../src/site/terrain-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAA4B,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEhG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAAQ,CAAA;AAWpC,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gDAAgD;IAChD,SAAS,EAAE,YAAY,CAAA;IACvB,gDAAgD;IAChD,OAAO,EAAE,YAAY,CAAA;IACrB,+CAA+C;IAC/C,GAAG,EAAE,YAAY,CAAA;IACjB,2CAA2C;IAC3C,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAOD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,kBAAkB,CAkCxE;AA8BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,+EAA+E;IAC/E,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,EAAE,YAAY,CAAA;IACrB,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAY7E;AAwBD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,mBAAmB,CAsB1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAyB1F;AAmBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,GACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAoBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,WAAW,GACjB,IAAI,CA8BN"}
+{"version":3,"file":"terrain-geometry.d.ts","sourceRoot":"","sources":["../../src/site/terrain-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAIhB,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAAQ,CAAA;AAEpC;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,IAAI,CAAA;AAE3B,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gDAAgD;IAChD,SAAS,EAAE,YAAY,CAAA;IACvB,gDAAgD;IAChD,OAAO,EAAE,YAAY,CAAA;IACrB,+CAA+C;IAC/C,GAAG,EAAE,YAAY,CAAA;IACjB,2CAA2C;IAC3C,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAOD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,kBAAkB,CAkCxE;AA8BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,+EAA+E;IAC/E,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,EAAE,YAAY,CAAA;IACrB,OAAO,EAAE,WAAW,CAAA;IACpB;;;OAGG;IACH,IAAI,CAAC,EAAE,YAAY,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAY7E;AAwBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAO5D;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAChD,YAAY,CAmBd;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,IAAI,CAAC,EAAE,YAAY,GAAG,IAAI,GACzB,mBAAmB,CAwBrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CA6B1F;AAgDD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,GACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAoBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,WAAW,GACjB,IAAI,CA8BN"}

package/dist/site/terrain-geometry.js

@@ -1,4 +1,4 @@
-import { heightAtSample, normalAt } from '@pascal-app/core';
+import { heightAt, heightAtSample, normalAt, } from '@pascal-app/core';
 /**
  * Builds the terrain mesh buffers from a `TerrainField`.
  *
@@ -39,7 +39,7 @@ export const HORIZON_PLANE_Y = -0.07;
  * under the horizon disc. A metre reads as earth thickness from a grazing camera
  * without being tall enough to poke out of a neighbouring excavation.
  */
-const SKIRT_DROP = 1;
+export const SKIRT_DROP = 1;
 /** Vertex index of sample [c,r]. */
 function vertexIndex(field, col, row) {
     return row * field.cols + col;
@@ -148,13 +148,58 @@ function boundarySample(field, i) {
         return { col: 2 * lastCol + lastRow - i, row: lastRow };
     return { col: 0, row: 2 * (lastCol + lastRow) - i };
 }
-export function buildTerrainSkirt(field) {
-    const count = perimeterCount(field);
+/**
+ * The base of the lot as a block: one flat level under the field's lowest
+ * point (and under the horizon plane), so the skirt along the property line
+ * reads as earth whose thickness follows the slope, and the horizon disc can
+ * sit just beneath it without cutting into the lot anywhere.
+ */
+export function terrainBlockBase(field) {
+    let minH = 0;
+    for (let i = 0; i < field.heights.length; i++) {
+        const h = field.heights[i] ?? 0;
+        if (h < minH)
+            minH = h;
+    }
+    return Math.min(minH * field.step, HORIZON_PLANE_Y) - SKIRT_DROP;
+}
+/**
+ * The lot's property line as the skirt walks it: counter-clockwise in x, z (the
+ * field perimeter's own direction, so one winding and one normal formula serve
+ * both), a point at least every half grid cell so the top edge follows the
+ * ground between samples. Empty when the polygon is not a ring.
+ */
+export function skirtRing(field, polygon) {
+    const points = polygon.filter(([x, z]) => Number.isFinite(x) && Number.isFinite(z));
+    if (points.length < 3 || field.cols < 2 || field.rows < 2)
+        return new Float32Array(0);
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const [x0, z0] = points[i];
+        const [x1, z1] = points[(i + 1) % points.length];
+        area += x0 * z1 - x1 * z0;
+    }
+    const ordered = area > 0 ? points : [...points].reverse();
+    const step = field.spacing / 2;
+    const out = [];
+    for (let i = 0; i < ordered.length; i++) {
+        const [ax, az] = ordered[i];
+        const [bx, bz] = ordered[(i + 1) % ordered.length];
+        const n = Math.max(1, Math.ceil(Math.hypot(bx - ax, bz - az) / step));
+        for (let k = 0; k < n; k++)
+            out.push(ax + ((bx - ax) * k) / n, az + ((bz - az) * k) / n);
+    }
+    return Float32Array.from(out);
+}
+export function buildTerrainSkirt(field, ring) {
+    const onRing = !!ring && ring.length >= 6;
+    const count = onRing ? ring.length / 2 : perimeterCount(field);
     const vertices = count === 0 ? 0 : (count + 1) * 2;
     const buffers = {
         positions: new Float32Array(vertices * 3),
         normals: new Float32Array(vertices * 3),
         indices: new Uint32Array(count * 6),
+        ...(onRing ? { ring: ring } : {}),
     };
     for (let i = 0; i < count; i++) {
         const base = i * 6;
@@ -181,6 +226,10 @@ export function buildTerrainSkirt(field) {
  * complexity because it saves 400 KB a dab; here there is nothing to save.
  */
 export function updateTerrainSkirt(field, buffers) {
+    if (buffers.ring) {
+        updateRingSkirt(field, buffers, buffers.ring);
+        return;
+    }
     const count = perimeterCount(field);
     if (count === 0)
         return;
@@ -204,6 +253,31 @@ export function updateTerrainSkirt(field, buffers) {
         writeSkirtVertex(buffers, bottomIndex, x, Math.min(h, HORIZON_PLANE_Y) - SKIRT_DROP, z, nx, nz);
     }
 }
+/**
+ * The property-line skirt: its top on the rendered ground (`heightAt`, the
+ * surface's own triangles), its bottom on the block's flat base — never above
+ * the ground it closes, so nothing stands proud of the lot from any side.
+ */
+function updateRingSkirt(field, buffers, ring) {
+    const count = ring.length / 2;
+    if (count < 3)
+        return;
+    const base = terrainBlockBase(field);
+    for (let i = 0; i <= count; i++) {
+        const at = i % count;
+        const x = ring[at * 2] ?? 0;
+        const z = ring[at * 2 + 1] ?? 0;
+        const prev = (at - 1 + count) % count;
+        const next = (at + 1) % count;
+        const tx = (ring[next * 2] ?? 0) - (ring[prev * 2] ?? 0);
+        const tz = (ring[next * 2 + 1] ?? 0) - (ring[prev * 2 + 1] ?? 0);
+        const tLength = Math.hypot(tx, tz) || 1;
+        const nx = tz / tLength;
+        const nz = -tx / tLength;
+        writeSkirtVertex(buffers, i * 2, x, heightAt(field, x, z), z, nx, nz);
+        writeSkirtVertex(buffers, i * 2 + 1, x, base, z, nx, nz);
+    }
+}
 function writeSkirtVertex(buffers, index, x, y, z, nx, nz) {
     buffers.positions[index * 3] = x;
     buffers.positions[index * 3 + 1] = y;

package/dist/site/terrain-holes.d.ts

@@ -0,0 +1,15 @@
+import { type Ring } from '@pascal-app/core';
+import { BufferGeometry } from 'three';
+import type { TerrainMeshBuffers } from './terrain-geometry.js';
+type Sample = {
+    indices: number[];
+    weights: number[];
+};
+export type TerrainHoleBoundary = {
+    geometry: BufferGeometry;
+    samples: Sample[];
+};
+export declare function cutTerrainHoles(buffers: TerrainMeshBuffers, holes: Ring[]): TerrainHoleBoundary | null;
+export declare function updateTerrainHoleBoundary(boundary: TerrainHoleBoundary, buffers: TerrainMeshBuffers): void;
+export {};
+//# sourceMappingURL=terrain-holes.d.ts.map

package/dist/site/terrain-holes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-holes.d.ts","sourceRoot":"","sources":["../../src/site/terrain-holes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,IAAI,EAAS,MAAM,kBAAkB,CAAA;AAC/D,OAAO,EAAmB,cAAc,EAAyC,MAAM,OAAO,CAAA;AAC9F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAE5D,KAAK,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AACtD,MAAM,MAAM,mBAAmB,GAAG;IAAE,QAAQ,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAIjF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,IAAI,EAAE,GACZ,mBAAmB,GAAG,IAAI,CAkE5B;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,kBAAkB,GAC1B,IAAI,CAkBN"}