@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/slab/geometry.js

@@ -1,8 +1,9 @@
-import { getLevelElevations, getMaterialPresetByRef, getRenderableSlabPolygon, slabPolygonContextFromGeometry, surfaceHeightAt, terrainFieldOf, useScene, } from '@pascal-app/core';
+import { area, computePlateSurfacePartition, cutterContextNodes, FenceNode, FOUNDATION_SLOT_DEFAULT, getLevelElevations, getMaterialPresetByRef, getRenderableSlabPolygon, intersection, isFloorPlate, levelBaseElevationAt, liftedManualSlab, parseFloorStepRole, plateFinishKey, plateLevelContext, resolveFloorStepFinish, SLAB_SIDE_SLOT_DEFAULT, SLAB_TOP_SLOT_DEFAULT, slabPolygonContextFromGeometry, surfaceHeightAt, terrainFieldOf, useScene, withHostedCutterHoles, } from '@pascal-app/core';
 import { applyMaterialPresetToMaterials, buildTerrainPerimeterFillGeometry, createDefaultMaterial, createMaterial, createSurfaceRoleMaterial, generateSlabGeometry, registerMaterialCacheCleanup, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
-import { BufferGeometry, Float32BufferAttribute, FrontSide, Group, Mesh, Vector3, } from 'three';
+import { FrontSide, Group, Mesh } from 'three';
+import { generateFenceSlotGeometries } from '../fence/geometry-parts';
 import { creaseCrossings } from '../site/terrain-drape';
-import { SLAB_SIDE_SLOT_DEFAULT, SLAB_TOP_SLOT_DEFAULT } from './slots';
+import { clipPlateTerrainFill, splitPlateFaces, splitSlabFacesByFacing } from './surface-split';
 const slabMaterialCache = new Map();
 registerMaterialCacheCleanup(() => {
     const previous = [...slabMaterialCache.values()];
@@ -26,8 +27,19 @@ function getSlabSlotMaterial(node, slotId, shading, textures, colorPreset, scene
     if (!textures) {
         return createSurfaceRoleMaterial('floor', colorPreset, FrontSide, sceneTheme);
     }
+    if (slotId === 'foundation') {
+        const finish = node.foundation?.material ?? FOUNDATION_SLOT_DEFAULT;
+        return typeof finish === 'string'
+            ? (resolveMaterialRef(finish, sceneMaterials, shading) ??
+                resolveSlotDefaultMaterial(finish, shading, 0.8))
+            : createMaterial(finish, shading);
+    }
     // Unified slot override — shared scene material or catalog `library:` finish.
-    const slotRef = node.slots?.[slotId];
+    // `side` is the pre-split key: it answers for any face when it is the only
+    // one set, and each split key answers for its own face when it is.
+    const slotRef = slotId === 'side'
+        ? (node.slots?.side ?? node.slots?.edge ?? node.slots?.riser ?? node.slots?.underside)
+        : (node.slots?.[slotId] ?? (slotId === 'surface' ? undefined : node.slots?.side));
     if (slotRef) {
         const resolved = resolveMaterialRef(slotRef, sceneMaterials, shading);
         if (resolved)
@@ -39,57 +51,9 @@ function getSlabSlotMaterial(node, slotId, shading, textures, colorPreset, scene
         return getLegacySlabMaterial(node, shading);
     }
     // Declared slot default — a catalog `library:` finish or a flat colour.
-    const slotDefault = slotId === 'side' ? SLAB_SIDE_SLOT_DEFAULT : SLAB_TOP_SLOT_DEFAULT;
+    const slotDefault = slotId === 'surface' ? SLAB_TOP_SLOT_DEFAULT : SLAB_SIDE_SLOT_DEFAULT;
     return resolveSlotDefaultMaterial(slotDefault, shading, 0.8);
 }
-// Split the merged slab buffer into top-facing (floor) and everything-else
-// (vertical walls + underside) sub-geometries by per-triangle face normal, so
-// the two paintable slots get distinct materials + raycast tags. De-indexes
-// into per-face triangles (slabs are flat-shaded, so no shared-vertex seams).
-function splitSlabFacesByFacing(geometry) {
-    const position = geometry.getAttribute('position');
-    const uv = geometry.getAttribute('uv');
-    const index = geometry.getIndex();
-    const triangleCount = index ? index.count / 3 : position.count / 3;
-    const top = { pos: [], uv: [] };
-    const side = { pos: [], uv: [] };
-    const a = new Vector3();
-    const b = new Vector3();
-    const c = new Vector3();
-    const ab = new Vector3();
-    const ac = new Vector3();
-    const normal = new Vector3();
-    for (let t = 0; t < triangleCount; t += 1) {
-        const i0 = index ? index.getX(t * 3) : t * 3;
-        const i1 = index ? index.getX(t * 3 + 1) : t * 3 + 1;
-        const i2 = index ? index.getX(t * 3 + 2) : t * 3 + 2;
-        a.fromBufferAttribute(position, i0);
-        b.fromBufferAttribute(position, i1);
-        c.fromBufferAttribute(position, i2);
-        ab.subVectors(b, a);
-        ac.subVectors(c, a);
-        normal.crossVectors(ab, ac);
-        const lengthSq = normal.lengthSq();
-        const isTop = lengthSq > 1e-12 && normal.y / Math.sqrt(lengthSq) > 0.5;
-        const target = isTop ? top : side;
-        for (const i of [i0, i1, i2]) {
-            target.pos.push(position.getX(i), position.getY(i), position.getZ(i));
-            if (uv)
-                target.uv.push(uv.getX(i), uv.getY(i));
-        }
-    }
-    const build = (data) => {
-        const geo = new BufferGeometry();
-        geo.setAttribute('position', new Float32BufferAttribute(data.pos, 3));
-        if (data.uv.length > 0) {
-            geo.setAttribute('uv', new Float32BufferAttribute(data.uv, 2));
-            geo.setAttribute('uv2', new Float32BufferAttribute(data.uv.slice(), 2));
-        }
-        geo.computeVertexNormals();
-        return geo;
-    };
-    return { top: build(top), side: build(side) };
-}
 function getLegacySlabMaterial(node, shading) {
     // Cached by `{material, materialPreset}` signature so slabs sharing settings
     // share the GPU resource; cached entry mutation (preset apply) is preserved
@@ -125,7 +89,7 @@ function getLegacySlabMaterial(node, shading) {
     slabMaterialCache.set(cacheKey, material);
     return material;
 }
-function terrainFillContext(ctx) {
+function terrainFillContext(ctx, foundation) {
     if (!ctx)
         return null;
     const level = ctx.parent;
@@ -152,7 +116,7 @@ function terrainFillContext(ctx) {
     if (!elevation)
         return null;
     const baseWorldY = (building.position?.[1] ?? 0) + elevation.baseY;
-    if (Math.abs(baseWorldY) >= 1e-4)
+    if (Math.abs(baseWorldY) >= 1e-4 && !(foundation && level.level === 0))
         return null;
     return {
         baseWorldY,
@@ -160,8 +124,8 @@ function terrainFillContext(ctx) {
         field,
     };
 }
-function buildSlabTerrainFillGeometry(node, polygon, ctx) {
-    const terrain = terrainFillContext(ctx);
+function buildSlabTerrainFillGeometry(node, polygon, ctx, partition) {
+    const terrain = terrainFillContext(ctx, node.plateRole === 'base');
     if (!terrain || polygon.length < 3)
         return null;
     let area2 = 0;
@@ -199,41 +163,187 @@ function buildSlabTerrainFillGeometry(node, polygon, ctx) {
         const ground = terrain.field ? surfaceHeightAt(terrain.field, siteX, siteZ) : 0;
         return Math.min(top, ground - terrain.baseWorldY);
     });
-    return buildTerrainPerimeterFillGeometry(localPoints, bottomY, top, 1e-4);
+    const geometry = buildTerrainPerimeterFillGeometry(localPoints, bottomY, top, 1e-4);
+    if (!geometry || !partition?.sides.some((side) => side.dropTo !== undefined))
+        return geometry;
+    const clipped = clipPlateTerrainFill(geometry, partition);
+    geometry.dispose();
+    return clipped;
+}
+/**
+ * Material for one partition cell of a plate top: the room's finish when the
+ * cell has one, the plate's own `surface` slot when it does not. Identical
+ * finishes resolve to the same cached instance, so two rooms painted alike stay
+ * in one batch bucket.
+ */
+function getPlateCellMaterial(node, cell, shading, textures, colorPreset, sceneTheme, sceneMaterials) {
+    if (!textures)
+        return createSurfaceRoleMaterial('floor', colorPreset, FrontSide, sceneTheme);
+    const finish = cell.finish;
+    if (typeof finish === 'string') {
+        const resolved = resolveMaterialRef(finish, sceneMaterials, shading);
+        if (resolved)
+            return resolved;
+    }
+    else if (finish) {
+        return createMaterial(finish, shading);
+    }
+    return getSlabSlotMaterial(node, 'surface', shading, textures, colorPreset, sceneTheme, sceneMaterials);
+}
+/**
+ * A floor plate's partition, or `null` when this slab is not a plate (or the
+ * level neighbourhood is unavailable, as in a bare geometry test). Memoised in
+ * core on the topology + finish signature; never recomputed per frame.
+ */
+function platePartitionOf(node, ctx, platform) {
+    if (!isFloorPlate(node) || !ctx)
+        return null;
+    const context = plateLevelContext(ctx.parent, ctx.resolve);
+    return computePlateSurfacePartition(node, { ...context, platform });
 }
 export function buildSlabGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+    if (ctx)
+        node = withHostedCutterHoles(node, cutterContextNodes(node, ctx));
+    if (ctx && !node.plateRole && !node.autoFromWalls)
+        node = liftedManualSlab(plateLevelContext(ctx.parent, ctx.resolve).nodes ?? {}, node);
     const group = new Group();
     const polygonContext = slabPolygonContextFromGeometry(ctx);
-    const merged = generateSlabGeometry(node, polygonContext);
-    const { top, side } = splitSlabFacesByFacing(merged);
-    merged.dispose();
+    const polygon = getRenderableSlabPolygon(node, polygonContext);
+    const baseNodes = {};
+    if (ctx?.parent && !ctx.levelBaseAt && isFloorPlate(node)) {
+        let ancestor = ctx.parent;
+        while (ancestor && !baseNodes[ancestor.id]) {
+            baseNodes[ancestor.id] = ancestor;
+            if ('children' in ancestor)
+                for (const id of ancestor.children) {
+                    const child = ctx.resolve(id);
+                    if (child?.type === 'level')
+                        baseNodes[id] = child;
+                }
+            ancestor = ancestor.parentId
+                ? ctx.resolve(ancestor.parentId)
+                : undefined;
+        }
+    }
+    const levelBaseAt = ctx?.levelBaseAt ??
+        ((x, z) => node.parentId ? levelBaseElevationAt(baseNodes, node.parentId, x, z) : 0);
+    const platform = isFloorPlate(node) &&
+        node.support !== 'open' &&
+        !node.plateRole &&
+        !node.recessed &&
+        node.elevation - node.thickness > 1e-4 &&
+        [polygon, ...(node.holes ?? [])].some((ring) => ring.some(([x, z], i) => {
+            const [endX, endZ] = ring[(i + 1) % ring.length];
+            const count = Math.max(1, Math.ceil(Math.hypot(endX - x, endZ - z) / 0.25));
+            for (let j = 0; j < count; j++)
+                if (node.elevation - node.thickness >
+                    levelBaseAt(x + ((endX - x) * j) / count, z + ((endZ - z) * j) / count) + 1e-4)
+                    return true;
+            return false;
+        }));
+    const merged = generateSlabGeometry(node, polygonContext, platform ? levelBaseAt : undefined);
     const elevation = node.elevation ?? 0.05;
-    // One mesh per slot, each tagged with its slot id so the unified slot paint
-    // resolves the hit (`resolveRole` reads `userData.slotId`) and previews it.
-    for (const [slotId, geometry] of [
-        ['surface', top],
-        ['side', side],
-    ]) {
-        const material = getSlabSlotMaterial(node, slotId, shading, textures, colorPreset, sceneTheme, ctx?.materials);
+    const partition = platePartitionOf(node, ctx, platform || node.plateRole === 'platform');
+    const addMesh = (geometry, slotId, material) => {
+        // A slot with no triangles (collapsed or fully holed polygon) gets no mesh,
+        // so the build settles instead of emitting empty buffers.
+        if (geometry.getAttribute('position').count === 0) {
+            geometry.dispose();
+            return;
+        }
         const mesh = new Mesh(geometry, material);
         mesh.castShadow = true;
         mesh.receiveShadow = true;
-        mesh.userData.slotId = slotId;
+        const step = parseFloorStepRole(slotId);
+        const edgeOwner = /^edge:(.+)$/.exec(slotId)?.[1];
+        mesh.userData.slotId = step ? 'riser' : edgeOwner ? 'edge' : slotId;
+        mesh.userData.paintRole = slotId;
+        if (step || edgeOwner)
+            mesh.userData.ownerZoneId = step?.zoneId ?? edgeOwner;
         // Solid slabs bake [elevation − thickness, elevation] into the geometry;
         // recessed shells are authored from floor to rim and translated so the
         // floor sits at `elevation`.
         if (node.recessed)
             mesh.position.y = elevation;
         group.add(mesh);
+    };
+    if (partition) {
+        // A plate draws one mesh per partition cell and one per exposure role. Each
+        // mesh keeps a single material, so node batching still buckets them by
+        // material uuid and repeated finishes share one bucket.
+        const cellByRole = new Map(partition.cells.map((cell) => [cell.role, cell]));
+        const levelZones = ctx ? plateLevelContext(ctx.parent, ctx.resolve).zones : [];
+        for (const { role, geometry } of splitPlateFaces(merged, partition, node)) {
+            const step = parseFloorStepRole(role);
+            const zoneId = step?.zoneId ?? /^edge:(.+)$/.exec(role)?.[1];
+            const zone = zoneId ? ctx?.resolve(zoneId) : undefined;
+            const base = ctx
+                ? plateLevelContext(ctx.parent, ctx.resolve)
+                    .slabs.filter((slab) => slab.plateRole === 'base')
+                    .sort((a, b) => area(intersection({ outer: b.polygon, holes: b.holes }, { outer: node.polygon, holes: node.holes })) -
+                    area(intersection({ outer: a.polygon, holes: a.holes }, { outer: node.polygon, holes: node.holes })) || a.id.localeCompare(b.id))[0]
+                : undefined;
+            const finish = zone?.type === 'zone'
+                ? step
+                    ? resolveFloorStepFinish(zone, step.key, step.step, levelZones)
+                    : (zone.floorEdgeFinish ?? base?.slots?.edge)
+                : undefined;
+            const cell = cellByRole.get(role) ??
+                (zone?.type === 'zone' && (step || finish !== undefined)
+                    ? {
+                        role,
+                        finish: finish ?? SLAB_TOP_SLOT_DEFAULT,
+                        materialKey: plateFinishKey(finish ?? SLAB_TOP_SLOT_DEFAULT),
+                        polygons: [],
+                    }
+                    : undefined);
+            const material = cell
+                ? getPlateCellMaterial(node, cell, shading, textures, colorPreset, sceneTheme, ctx?.materials)
+                : getSlabSlotMaterial(node, role, shading, textures, colorPreset, sceneTheme, ctx?.materials);
+            addMesh(geometry, role, material);
+        }
     }
-    if (node.fillToTerrain && !node.recessed) {
-        const terrainFill = buildSlabTerrainFillGeometry(node, getRenderableSlabPolygon(node, polygonContext), ctx);
+    else {
+        const { top, side } = splitSlabFacesByFacing(merged);
+        // One mesh per slot, each tagged with its slot id so the unified slot paint
+        // resolves the hit (`resolveRole` reads `userData.slotId`) and previews it.
+        for (const [slotId, geometry] of [
+            ['surface', top],
+            ['side', side],
+        ]) {
+            addMesh(geometry, slotId, getSlabSlotMaterial(node, slotId, shading, textures, colorPreset, sceneTheme, ctx?.materials));
+        }
+    }
+    merged.dispose();
+    const foundation = node.plateRole === 'base' && node.foundation?.type === 'solid';
+    if ((foundation || (!node.plateRole && node.fillToTerrain)) &&
+        !node.recessed &&
+        !platform &&
+        group.children.length > 0) {
+        const terrainFill = buildSlabTerrainFillGeometry(node, getRenderableSlabPolygon(node, polygonContext), ctx, partition);
         if (terrainFill) {
-            const mesh = new Mesh(terrainFill, getSlabSlotMaterial(node, 'side', shading, textures, colorPreset, sceneTheme, ctx?.materials));
-            mesh.castShadow = true;
-            mesh.receiveShadow = true;
-            mesh.userData.slotId = 'side';
-            group.add(mesh);
+            // The skirt hangs below the plate perimeter and always faces out.
+            const slotId = foundation ? 'foundation' : partition ? 'edge' : 'side';
+            addMesh(terrainFill, slotId, getSlabSlotMaterial(node, slotId, shading, textures, colorPreset, sceneTheme, ctx?.materials));
+        }
+    }
+    for (const [index, segment] of (node.railing ?? []).entries()) {
+        const geometries = generateFenceSlotGeometries(FenceNode.parse({
+            id: `fence_${index}`,
+            ...segment,
+            height: 1.1,
+            style: 'rail',
+            baseStyle: 'floating',
+            baseHeight: 0,
+            postCap: 'none',
+        }));
+        for (const geometry of Object.values(geometries)) {
+            if (!geometry.getAttribute('position')) {
+                geometry.dispose();
+                continue;
+            }
+            geometry.translate(0, elevation, 0);
+            addMesh(geometry, 'edge', getSlabSlotMaterial(node, 'edge', shading, textures, colorPreset, sceneTheme, ctx?.materials));
         }
     }
     return group;

package/dist/slab/move-tool.js

@@ -1,9 +1,10 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { collectAlignmentAnchors, emitter, polygonAnchors, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
-import { CursorSphere, consumePlacementDragRelease, getSegmentGridStep, isAlignmentGuideActive, isMagneticSnapActive, markToolCancelConsumed, projectAlignmentGuidesWorldToActiveBuildingLocal, resolveAlignmentForActiveBuilding, snapBuildingLocalToWorldGrid, snapFenceDraftPoint, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { CursorSphere, consumePlacementDragRelease, getSegmentGridStep, isAlignmentGuideActive, isMagneticSnapActive, markToolCancelConsumed, projectAlignmentGuidesWorldToActiveBuildingLocal, resolveAlignmentForActiveBuilding, snapBuildingLocalToWorldGrid, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { snapFenceDraftPoint } from '../fence/drafting';
 /**
  * Phase 5 Stage D — slab whole-move tool.
  *
@@ -177,10 +178,10 @@ export const MoveSlabTool = ({ node }) => {
                 // Single scene.update — recorded as one undo step (history was
                 // never paused). GeometrySystem rebuilds polygon-driven geometry
                 // and resets the group's transform on the next frame.
-                useScene.getState().updateNode(slabId, {
+                // Dragging a plate by hand converts it to an authored slab.
+                useScene.getState().detachDerivedNode(slabId, {
                     polygon: translatePolygon(originalPolygon, deltaX, deltaZ),
                     holes: originalHoles.map((h) => translatePolygon(h, deltaX, deltaZ)),
-                    autoFromWalls: false,
                 });
                 useScene.getState().markDirty(slabId);
             }
@@ -215,11 +216,11 @@ export const MoveSlabTool = ({ node }) => {
         window.addEventListener('pointerup', onPlacementDragPointerUp);
         return () => {
             useAlignmentGuides.getState().clear();
-            if (!wasCommitted) {
-                clearPreview();
+            if (wasCommitted) {
+                useLiveTransforms.getState().clear(slabId);
             }
             else {
-                useLiveTransforms.getState().clear(slabId);
+                clearPreview();
             }
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);

package/dist/slab/paint.d.ts

@@ -1,8 +1,21 @@
+import { type FloorPlatePaintRefusal, type PaintCapability, type PaintPatchArgs, type PaintPreviewArgs } from '@pascal-app/core';
+import { type PaintLook } from '../shared/slot-paint';
 /**
- * Slab paint on the unified slot model. A slab exposes two faces — `surface`
- * (top) and `side` (walls + underside) — each its own mesh tagged with
- * `userData.slotId`, so the clicked face resolves to its slot; commit writes
- * `node.slots[slotId]` (a shared scene-material or `library:` ref) like the shelf.
+ * Write a room finish in one history step, minting the shared scene material
+ * the same way `commitSlotPaint` does so a one-off colour is stored once.
  */
-export declare const slabPaint: import("@pascal-app/core").PaintCapability;
+/** The region id a room-scope floor role carries: the whole room, every finish source. */
+export declare const ROOM_WIDE = "*";
+/** The zone a room-scope floor role (`room:<zoneId>/*`) names. */
+export declare function roomWideZone(role: string): string | null;
+/**
+ * What a floor surface shows once erased: a region falls to its room's floor
+ * finish, a room's floor finish to the plate's own top, the room's steps to its
+ * floor, its edge to the footprint's edge band, a plate's side faces to their
+ * bare look, a slot to its declared default.
+ */
+export declare function erasedSlabLook({ node, role }: PaintPreviewArgs): PaintLook | null;
+export declare const slabPaint: PaintCapability & {
+    commit: (args: PaintPatchArgs) => undefined | FloorPlatePaintRefusal;
+};
 //# sourceMappingURL=paint.d.ts.map

package/dist/slab/paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/slab/paint.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,SAAS,4CAiBpB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/slab/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,sBAAsB,EAQ3B,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EAetB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAIL,KAAK,SAAS,EAGf,MAAM,sBAAsB,CAAA;AA6F7B;;;GAGG;AACH,0FAA0F;AAC1F,eAAO,MAAM,SAAS,MAAM,CAAA;AAE5B,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGxD;AAqQD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,gBAAgB,GAAG,SAAS,GAAG,IAAI,CAmBjF;AA8CD,eAAO,MAAM,SAAS,EAAE,eAAe,GAAG;IACxC,MAAM,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,SAAS,GAAG,sBAAsB,CAAA;CAiGrE,CAAA"}