@pascal-app/nodes 1.0.5 → 1.0.7

package/dist/slab/deck-geometry.js

@@ -0,0 +1,320 @@
+import { area, BEAM_MATERIAL_LIBRARY_REFS, deckBoardRun, deckBoardThickness, deckSlabBoards, getLevelElevations, intersection, layoutDeckBoards, planDeckFraming, plateLevelContext, SITE_DATUM_Y, surfaceHeightAt, terrainFieldOf, } from '@pascal-app/core';
+import { createSurfaceRoleMaterial, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
+import { BufferGeometry, Float32BufferAttribute, FrontSide, Group, Mesh, ShapeUtils, Vector2, } from 'three';
+/**
+ * A deck's floor (`isDeckSlab`: a deck room's floor plate, a generated deck) drawn as a deck is
+ * built, never as a solid slab: its boards (`layoutDeckBoards`), the room's finish on them, each
+ * painted part of the floor its own boards with its own paint role, over its frame
+ * (`planDeckFraming`), the same plan the framing plugin books: ledger, joists, rims, beams and
+ * posts in treated wood, a concrete pier under each post at the ground. The boards' top is the
+ * slab's top, so items, the room label and clicks find the floor where they did. Each material is
+ * one merged mesh, so the deck batches like any slab.
+ */
+const IN = 0.0254;
+/** A post's pier: 12 in square, standing 2 in out of the ground, 10 in into it. */
+const PIER_SIDE = 12 * IN;
+const PIER_ABOVE = 2 * IN;
+const PIER_BELOW = 10 * IN;
+/** The level-local ground under a plan point: the site's terrain, or the datum, wherever the storey stands. */
+function groundUnder(ctx) {
+    const level = ctx?.parent;
+    if (!ctx || level?.type !== 'level' || !level.parentId)
+        return () => 0;
+    const building = ctx.resolve(level.parentId);
+    if (building?.type !== 'building')
+        return () => 0;
+    const site = building.parentId ? ctx.resolve(building.parentId) : undefined;
+    const nodes = { [building.id]: building, [level.id]: level };
+    if (site?.type === 'site')
+        nodes[site.id] = site;
+    for (const childId of building.children) {
+        const child = ctx.resolve(childId);
+        if (child)
+            nodes[child.id] = child;
+    }
+    const elevation = getLevelElevations(nodes).get(level.id);
+    if (!elevation)
+        return () => 0;
+    const baseWorldY = (building.position?.[1] ?? 0) + elevation.baseY;
+    const field = site?.type === 'site' ? terrainFieldOf(site) : null;
+    if (!field)
+        return () => SITE_DATUM_Y - baseWorldY;
+    const angle = building.rotation?.[1] ?? 0;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const [px, , pz] = building.position ?? [0, 0, 0];
+    return (x, z) => surfaceHeightAt(field, cos * x + sin * z + px, -sin * x + cos * z + pz) - baseWorldY;
+}
+/** The house walls a deck edge may hang its ledger on: no railing, no hidden wall. */
+function ledgerWalls(ctx) {
+    if (!ctx)
+        return [];
+    return plateLevelContext(ctx.parent, ctx.resolve)
+        .walls.filter((wall) => wall.visible !== false && wall.wallType !== 'railing')
+        .map((wall) => ({
+        start: wall.start,
+        end: wall.end,
+        thickness: wall.thickness ?? 0.1,
+        curved: Math.abs(wall.curveOffset ?? 0) > 1e-6,
+    }));
+}
+/**
+ * Posts already standing on the ground by the deck (a generated porch's, hosted on the ground and
+ * passing through the deck): a beam two of them stand on is theirs to carry.
+ */
+function carriersBy(node, ctx) {
+    const level = ctx?.parent;
+    if (!ctx || !level || !('children' in level))
+        return [];
+    const out = [];
+    for (const id of level.children) {
+        const column = ctx.resolve(id);
+        if (column?.type !== 'column' || column.visible === false || column.supportSlabId === node.id)
+            continue;
+        const support = column.supportSlabId
+            ? ctx.resolve(column.supportSlabId)
+            : undefined;
+        const base = column.position[1] + (support?.type === 'slab' ? support.elevation : 0);
+        if (base < node.elevation - 0.3)
+            out.push([column.position[0], column.position[2]]);
+    }
+    return out;
+}
+/** A material's surface: the treated wood of the frame, the piers' concrete. */
+function frameMaterial(ref, role, look) {
+    return look.textures
+        ? resolveSlotDefaultMaterial(ref, look.shading)
+        : createSurfaceRoleMaterial(role, look.colorPreset, FrontSide, look.sceneTheme);
+}
+const buffers = () => ({ positions: [], normals: [], uvs: [], indices: [] });
+function toGeometry({ positions, normals, uvs, indices }) {
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
+    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+    geometry.setIndex(indices);
+    return geometry;
+}
+/** A box (centre, [run, height, across], yaw), flat-shaded with metre UVs on every face. */
+function pushBox(out, piece) {
+    const [cx, cy, cz] = piece.position;
+    const [hx, hy, hz] = piece.dims.map((value) => value / 2);
+    const cos = Math.cos(piece.yaw);
+    const sin = Math.sin(piece.yaw);
+    // three.js Y rotation: local +x → (cos, 0, −sin), local +z → (sin, 0, cos)
+    const world = (x, y, z) => [
+        cx + x * cos + z * sin,
+        cy + y,
+        cz - x * sin + z * cos,
+    ];
+    const turn = (x, z) => [
+        x * cos + z * sin,
+        0,
+        -x * sin + z * cos,
+    ];
+    // each face: its normal (local), and two edge axes (local) with their half lengths
+    const faces = [
+        { n: [1, 0, 0], a: [0, 0, -1], b: [0, 1, 0] },
+        { n: [-1, 0, 0], a: [0, 0, 1], b: [0, 1, 0] },
+        { n: [0, 1, 0], a: [1, 0, 0], b: [0, 0, -1] },
+        { n: [0, -1, 0], a: [1, 0, 0], b: [0, 0, 1] },
+        { n: [0, 0, 1], a: [1, 0, 0], b: [0, 1, 0] },
+        { n: [0, 0, -1], a: [-1, 0, 0], b: [0, 1, 0] },
+    ];
+    const half = [hx, hy, hz];
+    for (const { n, a, b } of faces) {
+        const base = out.positions.length / 3;
+        const span = (axis) => Math.abs(axis[0]) * half[0] + Math.abs(axis[1]) * half[1] + Math.abs(axis[2]) * half[2];
+        const ha = span(a);
+        const hb = span(b);
+        const normal = n[1] !== 0 ? [0, n[1], 0] : turn(n[0], n[2]);
+        for (const [sa, sb] of [
+            [-1, -1],
+            [1, -1],
+            [1, 1],
+            [-1, 1],
+        ]) {
+            const x = n[0] * half[0] + a[0] * ha * sa + b[0] * hb * sb;
+            const y = n[1] * half[1] + a[1] * ha * sa + b[1] * hb * sb;
+            const z = n[2] * half[2] + a[2] * ha * sa + b[2] * hb * sb;
+            out.positions.push(...world(x, y, z));
+            out.normals.push(...normal);
+            out.uvs.push(ha * (sa + 1), hb * (sb + 1));
+        }
+        out.indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+    }
+}
+function signedArea2(ring) {
+    let twice = 0;
+    for (let i = 0; i < ring.length; i++) {
+        const [ax, az] = ring[i];
+        const [bx, bz] = ring[(i + 1) % ring.length];
+        twice += ax * bz - bx * az;
+    }
+    return twice;
+}
+/**
+ * One board: its top at `top`, its bottom `thickness` under, its sides; the top's grain along
+ * the board (`along`), shifted by `shift` so neighbouring boards read as boards.
+ */
+function pushBoard(out, board, top, thickness, along, shift) {
+    const outer = signedArea2(board.outer) < 0 ? [...board.outer].reverse() : board.outer;
+    const holes = board.holes.filter((hole) => hole.length >= 3);
+    const contour = outer.map(([x, z]) => new Vector2(x, z));
+    const holeRings = holes.map((hole) => hole.map(([x, z]) => new Vector2(x, z)));
+    const bottom = top - thickness;
+    const grain = (x, z) => [
+        x * along[0] + z * along[1] + shift,
+        -x * along[1] + z * along[0],
+    ];
+    const cap = [...contour, ...holeRings.flat()];
+    const topBase = out.positions.length / 3;
+    for (const p of cap) {
+        out.positions.push(p.x, top, p.y);
+        out.normals.push(0, 1, 0);
+        out.uvs.push(...grain(p.x, p.y));
+    }
+    const bottomBase = out.positions.length / 3;
+    for (const p of cap) {
+        out.positions.push(p.x, bottom, p.y);
+        out.normals.push(0, -1, 0);
+        out.uvs.push(...grain(p.x, p.y));
+    }
+    for (const [a, b, c] of ShapeUtils.triangulateShape(contour, holeRings)) {
+        out.indices.push(topBase + a, topBase + c, topBase + b);
+        out.indices.push(bottomBase + a, bottomBase + b, bottomBase + c);
+    }
+    // the board's edges, outward on the outline; a hole's both ways
+    const side = (a, b, flipped) => {
+        const length = Math.hypot(b.x - a.x, b.y - a.y);
+        if (length < 1e-9)
+            return;
+        const nx = (b.y - a.y) / length;
+        const nz = -(b.x - a.x) / length;
+        const base = out.positions.length / 3;
+        for (const [p, y, u, v] of [
+            [a, bottom, 0, 0],
+            [b, bottom, length, 0],
+            [b, top, length, thickness],
+            [a, top, 0, thickness],
+        ]) {
+            out.positions.push(p.x, y, p.y);
+            out.normals.push(flipped ? -nx : nx, 0, flipped ? -nz : nz);
+            out.uvs.push(u, v);
+        }
+        if (flipped)
+            out.indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+        else
+            out.indices.push(base, base + 2, base + 1, base, base + 3, base + 2);
+    };
+    for (let i = 0; i < contour.length; i++)
+        side(contour[i], contour[(i + 1) % contour.length], false);
+    for (const ring of holeRings)
+        for (let i = 0; i < ring.length; i++) {
+            side(ring[i], ring[(i + 1) % ring.length], false);
+            side(ring[i], ring[(i + 1) % ring.length], true);
+        }
+}
+/** A board's own shift along its grain, the same every build. */
+const shiftOf = (index) => {
+    const x = Math.sin(index * 12.9898 + 78.233) * 43758.5453;
+    return (x - Math.floor(x)) * 3;
+};
+/** The deck's frame as the engine draws it: a joist a side rim stands in for is the rim. */
+export function deckFramePieces(plan) {
+    return [
+        ...(plan.ledger ? [plan.ledger] : []),
+        ...plan.rims,
+        ...plan.joists.filter((joist) => !joist.atRim),
+        ...plan.beams,
+        ...plan.posts,
+    ];
+}
+/** The deck's frame plan and boards, as drawn for `node`. */
+export function planDeck(node, ctx, polygon) {
+    const boards = deckSlabBoards(node, (id) => {
+        const zone = ctx?.resolve(id);
+        return zone?.type === 'zone' ? zone : undefined;
+    });
+    const thickness = deckBoardThickness(boards);
+    const ground = groundUnder(ctx);
+    let cx = 0;
+    let cz = 0;
+    for (const [x, z] of polygon) {
+        cx += x;
+        cz += z;
+    }
+    const n = Math.max(polygon.length, 1);
+    const plan = planDeckFraming({
+        polygon,
+        top: node.elevation,
+        decking: thickness,
+        walls: ledgerWalls(ctx),
+        boards,
+        gradeY: ground(cx / n, cz / n),
+        gradeAt: ground,
+        carriers: carriersBy(node, ctx),
+    });
+    return { boards, thickness, plan };
+}
+export function buildDeckGeometry(node, ctx, options) {
+    const group = new Group();
+    const { polygon, partition, look } = options;
+    if (polygon.length < 3)
+        return group;
+    const { boards, thickness, plan } = planDeck(node, ctx, polygon);
+    const addMesh = (geometry, material, role) => {
+        if (geometry.getAttribute('position').count === 0) {
+            geometry.dispose();
+            return;
+        }
+        const mesh = new Mesh(geometry, material);
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        if (role) {
+            mesh.userData.slotId = role;
+            mesh.userData.paintRole = role;
+        }
+        group.add(mesh);
+    };
+    // ---- the boards: a set for each painted part of the floor, cut along it ----
+    const axes = plan.axes ?? {
+        origin: polygon[0],
+        u: [1, 0],
+        v: [0, 1],
+    };
+    const joists = plan.stationAxis && plan.axes
+        ? { origin: plan.axes.origin, axis: plan.stationAxis, stations: plan.stations }
+        : undefined;
+    // One set of rows over the whole deck, so a painted part's boards line up with the rest.
+    const top = [{ outer: polygon, holes: node.holes ?? [] }];
+    const laid = layoutDeckBoards(top, axes, boards, joists);
+    const cells = partition
+        ? partition.cells.map((cell) => ({ cell, role: cell.role, outline: cell.polygons }))
+        : [{ cell: null, role: 'surface', outline: top }];
+    const whole = area(top);
+    const { along } = deckBoardRun(axes, boards.direction);
+    for (const { cell, role, outline } of cells) {
+        const out = buffers();
+        const all = cells.length === 1 && Math.abs(area(outline) - whole) < 1e-4;
+        laid.forEach((board, index) => {
+            for (const part of all ? [board] : intersection(board, outline))
+                pushBoard(out, part, node.elevation, thickness, along, shiftOf(index));
+        });
+        addMesh(toGeometry(out), options.boardMaterial(cell), role);
+    }
+    // ---- the frame, and a pier under each post ----
+    const frame = buffers();
+    for (const piece of deckFramePieces(plan))
+        pushBox(frame, piece);
+    addMesh(toGeometry(frame), frameMaterial(BEAM_MATERIAL_LIBRARY_REFS['pressure-treated'], 'wall', look));
+    const piers = buffers();
+    for (const post of plan.posts)
+        pushBox(piers, {
+            position: [post.position[0], post.bottom + (PIER_ABOVE - PIER_BELOW) / 2, post.position[2]],
+            dims: [PIER_SIDE, PIER_ABOVE + PIER_BELOW, PIER_SIDE],
+            yaw: post.yaw,
+        });
+    addMesh(toGeometry(piers), frameMaterial('library:concrete-raw', 'floor', look));
+    return group;
+}

package/dist/slab/definition.d.ts

@@ -3,7 +3,8 @@ import { SlabNode } from './schema.js';
 /**
  * Slab — Phase 5 batch kind, polygon-based. Stage B: `def.geometry`
  * drives the rebuild via generic <GeometrySystem>; <ParametricNodeRenderer>
- * mounts the empty group. No per-kind renderer or system file.
+ * mounts the empty group, which the slab's renderer composes with the build
+ * of its surface script.
  *
  * Capabilities:
  *  - **No `movable`**: slab's "move" today is whole-slab translation via

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,cAAc,EAMpB,MAAM,kBAAkB,CAAA;AA+BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAyNnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAkJ1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,cAAc,EAMpB,MAAM,kBAAkB,CAAA;AA+BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAyNnC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAsJ1D,CAAA"}

package/dist/slab/definition.js

@@ -183,7 +183,8 @@ function slabHandles(node) {
 /**
  * Slab — Phase 5 batch kind, polygon-based. Stage B: `def.geometry`
  * drives the rebuild via generic <GeometrySystem>; <ParametricNodeRenderer>
- * mounts the empty group. No per-kind renderer or system file.
+ * mounts the empty group, which the slab's renderer composes with the build
+ * of its surface script.
  *
  * Capabilities:
  *  - **No `movable`**: slab's "move" today is whole-slab translation via
@@ -283,6 +284,10 @@ export const slabDefinition = {
         'hole-edit': () => import('./hole-editor.js'),
         move: () => import('./move-tool.js'),
     },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
     // Stage B: pure geometry function.
     geometry: buildSlabGeometry,
     // Dependency tracker only — dirties level slabs when walls / sibling

package/dist/slab/dependency-tracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dependency-tracker.d.ts","sourceRoot":"","sources":["../../src/slab/dependency-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAYf,MAAM,kBAAkB,CAAA;AAsBzB,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAwDxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,SAAS,EAAE,CAoH7D"}
+{"version":3,"file":"dependency-tracker.d.ts","sourceRoot":"","sources":["../../src/slab/dependency-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAYf,MAAM,kBAAkB,CAAA;AAsBzB,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WA2DxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,SAAS,EAAE,CAoH7D"}

package/dist/slab/dependency-tracker.js

@@ -51,6 +51,9 @@ export function createSlabDependencyTracker(initialNodes) {
                             node.floorStepFinish,
                             node.floorStepOverrides,
                             node.floorEdgeFinish,
+                            // a deck's plate is its boards and frame (`buildDeckGeometry`)
+                            node.roomType,
+                            node.decking,
                         ]
                         : null);
         nodeInputs.set(node, value);