@pascal-app/viewer 0.8.0 → 0.9.2

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

@@ -1,8 +1,10 @@
-import { type SlabNode } from '@pascal-app/core';
+import { type SlabNode, type SlabPolygonContext } from '@pascal-app/core';
 import * as THREE from 'three';
 export declare const SlabSystem: () => null;
 /**
- * Generates extruded slab geometry from polygon
+ * Generates extruded slab geometry from polygon. `context` carries the
+ * slab's level neighbourhood (walls + sibling slabs) driving the per-edge
+ * render offsets — see `getRenderableSlabPolygon`.
  */
-export declare function generateSlabGeometry(slabNode: SlabNode): THREE.BufferGeometry;
+export declare function generateSlabGeometry(slabNode: SlabNode, context: SlabPolygonContext): THREE.BufferGeometry;
 //# sourceMappingURL=slab-system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAa9B,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAkBD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAG7E"}
+{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAIxB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAe9B,eAAO,MAAM,UAAU,YA2CtB,CAAA;AAuCD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,GAC1B,KAAK,CAAC,cAAc,CAKtB"}

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

@@ -1,6 +1,9 @@
-import { getRenderableSlabPolygon, sceneRegistry, useScene, } from '@pascal-app/core';
+import { getEffectiveNode, getRenderableSlabPolygon, pointInPolygon2D, polygonsIntersect, sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
+import { useEffect } from 'react';
 import * as THREE from 'three';
+import { subtractPolygonsFromPolygon } from '../../lib/polygon-union';
+import { mergeSurfaceHolePolygons } from '../surface-hole-geometry';
 function ensureUv2Attribute(geometry) {
     const uv = geometry.getAttribute('uv');
     if (!uv)
@@ -13,18 +16,31 @@ function ensureUv2Attribute(geometry) {
 export const SlabSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
+    const markDirty = useScene((state) => state.markDirty);
+    useEffect(() => {
+        const nodes = useScene.getState().nodes;
+        for (const node of Object.values(nodes)) {
+            if (node.type === 'slab') {
+                markDirty(node.id);
+            }
+        }
+    }, [markDirty]);
     useFrame(() => {
         if (dirtyNodes.size === 0)
             return;
         const nodes = useScene.getState().nodes;
+        const contextByLevel = new Map();
         // Process dirty slabs
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
-            if (!node || node.type !== 'slab')
+            if (node?.type !== 'slab')
                 return;
             const mesh = sceneRegistry.nodes.get(id);
             if (mesh) {
-                updateSlabGeometry(node, mesh);
+                const slab = node;
+                const levelContext = contextByLevel.get(slab.parentId) ?? buildLevelSlabContext(slab.parentId, nodes);
+                contextByLevel.set(slab.parentId, levelContext);
+                updateSlabGeometry(getEffectiveNode(slab), excludeSlabFromContext(levelContext, slab.id), mesh);
                 clearDirty(id);
             }
             // If mesh not found, keep it dirty for next frame
@@ -32,11 +48,30 @@ export const SlabSystem = () => {
     }, 1);
     return null;
 };
+function buildLevelSlabContext(levelId, nodes) {
+    const walls = [];
+    const siblingSlabs = [];
+    for (const node of Object.values(nodes)) {
+        if (node.parentId !== levelId)
+            continue;
+        if (node.type === 'wall')
+            walls.push(node);
+        else if (node.type === 'slab')
+            siblingSlabs.push(node);
+    }
+    return { walls, siblingSlabs };
+}
+function excludeSlabFromContext(context, slabId) {
+    return {
+        walls: context.walls,
+        siblingSlabs: context.siblingSlabs.filter((slab) => slab.id !== slabId),
+    };
+}
 /**
  * Updates the geometry for a single slab
  */
-function updateSlabGeometry(node, mesh) {
-    const newGeo = generateSlabGeometry(node);
+function updateSlabGeometry(node, context, mesh) {
+    const newGeo = generateSlabGeometry(node, context);
     ensureUv2Attribute(newGeo);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
@@ -46,37 +81,143 @@ function updateSlabGeometry(node, mesh) {
     mesh.position.y = elevation < 0 ? elevation : 0;
 }
 /**
- * Generates extruded slab geometry from polygon
+ * Generates extruded slab geometry from polygon. `context` carries the
+ * slab's level neighbourhood (walls + sibling slabs) driving the per-edge
+ * render offsets — see `getRenderableSlabPolygon`.
  */
-export function generateSlabGeometry(slabNode) {
+export function generateSlabGeometry(slabNode, context) {
     const elevation = slabNode.elevation ?? 0.05;
-    return elevation < 0 ? generatePoolGeometry(slabNode) : generatePositiveSlabGeometry(slabNode);
+    return elevation < 0
+        ? generatePoolGeometry(slabNode, context)
+        : generatePositiveSlabGeometry(slabNode, context);
+}
+// Earcut normalizes cap triangulation regardless of input winding, but the side
+// walls below assume a CCW contour (the unflipped quad's right-hand normal faces
+// outward only for CCW). outsetPolygon and the slab tool preserve the drawn
+// winding, so a CW-drawn slab gets inward-facing walls that FrontSide culls and
+// the slab reads as see-through from the front. Normalize to CCW first.
+function ensureCounterClockwisePolygon(polygon) {
+    let area2 = 0;
+    for (let i = 0; i < polygon.length; i++) {
+        const j = (i + 1) % polygon.length;
+        area2 += polygon[i][0] * polygon[j][1] - polygon[j][0] * polygon[i][1];
+    }
+    return area2 < 0 ? [...polygon].reverse() : polygon;
+}
+function isStrictInteriorHole(contour, hole) {
+    return (hole.every((point) => pointInPolygon2D(point, contour, { includeBoundary: false })) &&
+        !polygonsIntersect(contour, hole));
+}
+function affectsContour(contour, hole) {
+    return (polygonsIntersect(contour, hole) ||
+        hole.some((point) => pointInPolygon2D(point, contour, { includeBoundary: false })) ||
+        contour.some((point) => pointInPolygon2D(point, hole, { includeBoundary: false })));
+}
+function buildSlabRegions(contour, holes) {
+    const containedHoles = [];
+    const edgeCutouts = [];
+    for (const hole of holes) {
+        if (hole.length < 3)
+            continue;
+        if (isStrictInteriorHole(contour, hole))
+            containedHoles.push(hole);
+        else if (affectsContour(contour, hole))
+            edgeCutouts.push(hole);
+    }
+    const contours = edgeCutouts.length > 0 ? subtractPolygonsFromPolygon(contour, edgeCutouts) : [contour];
+    return contours.map((regionContour) => ({
+        contour: regionContour,
+        holes: containedHoles.filter((hole) => isStrictInteriorHole(regionContour, hole)),
+    }));
 }
 /**
  * Standard slab: flat extrusion upward from Y=0 by elevation thickness.
+ *
+ * Built directly in 3D (Y-up) rather than via ExtrudeGeometry so the hole side
+ * walls can be emitted double-sided. The slab material is forced to FrontSide
+ * (DoubleSide on the floor-role NodeMaterial poisons the MRT scene pass — see
+ * nodes/slab/geometry.ts), and ExtrudeGeometry's hole walls are single-sided,
+ * so their interior faces get back-face culled and you see straight through the
+ * cut. Emitting each hole-wall quad twice with opposite winding makes the inner
+ * thickness visible from any angle: the two coincident triangles never z-fight
+ * because exactly one faces the camera under FrontSide culling.
  */
-function generatePositiveSlabGeometry(slabNode) {
-    const polygon = getRenderableSlabPolygon(slabNode);
+function generatePositiveSlabGeometry(slabNode, context) {
+    const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode, context));
     const elevation = slabNode.elevation ?? 0.05;
+    const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
     if (polygon.length < 3)
         return new THREE.BufferGeometry();
-    const shape = new THREE.Shape();
-    shape.moveTo(polygon[0][0], -polygon[0][1]);
-    for (let i = 1; i < polygon.length; i++)
-        shape.lineTo(polygon[i][0], -polygon[i][1]);
-    shape.closePath();
-    for (const holePolygon of slabNode.holes ?? []) {
-        if (holePolygon.length < 3)
-            continue;
-        const holePath = new THREE.Path();
-        holePath.moveTo(holePolygon[0][0], -holePolygon[0][1]);
-        for (let i = 1; i < holePolygon.length; i++)
-            holePath.lineTo(holePolygon[i][0], -holePolygon[i][1]);
-        holePath.closePath();
-        shape.holes.push(holePath);
+    const positions = [];
+    const uvs = [];
+    const indices = [];
+    // --- Side walls ---
+    // Each segment gets its own 4 verts so computeVertexNormals doesn't average
+    // across faces. Outer walls are single-sided with outward normals; hole walls
+    // emit a second flipped quad (own verts) so they read as double-sided.
+    const addWall = (a, b, flipped) => {
+        const base = positions.length / 3;
+        const len = Math.max(Math.hypot(b.x - a.x, b.y - a.y), 0.001);
+        positions.push(a.x, 0, a.y);
+        uvs.push(0, 0);
+        positions.push(b.x, 0, b.y);
+        uvs.push(len, 0);
+        positions.push(b.x, elevation, b.y);
+        uvs.push(len, elevation);
+        positions.push(a.x, elevation, a.y);
+        uvs.push(0, elevation);
+        // Standard winding on a CCW polygon gives inward-facing normals (see pool
+        // path), so the unflipped quad faces outward; flipped is its back face.
+        if (!flipped) {
+            indices.push(base, base + 2, base + 1, base, base + 3, base + 2);
+        }
+        else {
+            indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+        }
+    };
+    for (const region of buildSlabRegions(polygon, holePolygons)) {
+        const contour2d = ensureCounterClockwisePolygon(region.contour).map(([x, z]) => new THREE.Vector2(x, z));
+        const holes2d = region.holes
+            .filter((h) => h.length >= 3)
+            .map((h) => h.map(([x, z]) => new THREE.Vector2(x, z)));
+        // --- Top & bottom caps ---
+        // capPoints order (contour then holes) matches triangulateShape's index space.
+        // UVs reproduce ExtrudeGeometry's WorldUVGenerator mapping (shape-space x,-z)
+        // so textured slabs keep the same floor projection.
+        const capPoints = [...contour2d, ...holes2d.flat()];
+        const topBase = positions.length / 3;
+        for (const p of capPoints) {
+            positions.push(p.x, elevation, p.y);
+            uvs.push(p.x, -p.y);
+        }
+        const bottomBase = positions.length / 3;
+        for (const p of capPoints) {
+            positions.push(p.x, 0, p.y);
+            uvs.push(p.x, -p.y);
+        }
+        const capTris = THREE.ShapeUtils.triangulateShape(contour2d, holes2d);
+        for (const tri of capTris) {
+            const [a, b, c] = [tri[0], tri[1], tri[2]];
+            // Reversed winding → +Y normal on top; standard winding → -Y on bottom.
+            indices.push(topBase + a, topBase + c, topBase + b);
+            indices.push(bottomBase + a, bottomBase + b, bottomBase + c);
+        }
+        for (let i = 0; i < contour2d.length; i++) {
+            addWall(contour2d[i], contour2d[(i + 1) % contour2d.length], false);
+        }
+        for (const hole of holes2d) {
+            for (let i = 0; i < hole.length; i++) {
+                const a = hole[i];
+                const b = hole[(i + 1) % hole.length];
+                addWall(a, b, false);
+                addWall(a, b, true);
+            }
+        }
     }
-    const geometry = new THREE.ExtrudeGeometry(shape, { depth: elevation, bevelEnabled: false });
-    geometry.rotateX(-Math.PI / 2);
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    geometry.setIndex(indices);
     geometry.computeVertexNormals();
     return geometry;
 }
@@ -89,62 +230,57 @@ function generatePositiveSlabGeometry(slabNode) {
  *   - floor in XZ plane at Y=0, normals pointing +Y (visible when looking down into pool)
  *   - walls from Y=0 to Y=depth, inward-facing normals (visible from inside pool)
  */
-function generatePoolGeometry(slabNode) {
-    const polygon = getRenderableSlabPolygon(slabNode);
+function generatePoolGeometry(slabNode, context) {
+    const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode, context));
     const depth = Math.abs(slabNode.elevation ?? 0.05);
+    const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? []);
     if (polygon.length < 3)
         return new THREE.BufferGeometry();
     const positions = [];
     const uvs = [];
     const indices = [];
-    const n = polygon.length;
-    const bounds = new THREE.Box2();
-    for (const [x, z] of polygon) {
-        bounds.expandByPoint(new THREE.Vector2(x, z));
-    }
-    for (const hole of slabNode.holes ?? []) {
-        for (const [x, z] of hole) {
-            bounds.expandByPoint(new THREE.Vector2(x, z));
-        }
-    }
-    const floorWidth = Math.max(bounds.max.x - bounds.min.x, 0.001);
-    const floorHeight = Math.max(bounds.max.y - bounds.min.y, 0.001);
     const pushFloorVertex = (x, y, z) => {
         positions.push(x, y, z);
-        uvs.push((x - bounds.min.x) / floorWidth, (z - bounds.min.y) / floorHeight);
+        // Floor UVs in metres (shape-space x, -z), matching generatePositiveSlabGeometry's
+        // cap mapping so a finish tiles at the same world scale on every surface.
+        uvs.push(x, -z);
     };
     const pushWallVertex = (x, y, z, u, v) => {
         positions.push(x, y, z);
         uvs.push(u, v);
     };
-    // --- Floor at Y=0 ---
-    for (const [x, z] of polygon)
-        pushFloorVertex(x, 0, z);
-    const pts2d = polygon.map(([x, z]) => new THREE.Vector2(x, z));
-    const holesPts2d = (slabNode.holes ?? []).map((h) => h.map(([x, z]) => new THREE.Vector2(x, z)));
-    for (const hole of slabNode.holes ?? []) {
-        for (const [x, z] of hole)
+    for (const region of buildSlabRegions(polygon, holePolygons)) {
+        const contour = ensureCounterClockwisePolygon(region.contour);
+        const floorBase = positions.length / 3;
+        // --- Floor at Y=0 ---
+        for (const [x, z] of contour)
             pushFloorVertex(x, 0, z);
-    }
-    const floorTris = THREE.ShapeUtils.triangulateShape(pts2d, holesPts2d);
-    for (const tri of floorTris) {
-        // Reversed winding → normals point +Y (upward) in XZ plane
-        indices.push(tri[0], tri[2], tri[1]);
-    }
-    // --- Inner walls (no top cap at Y=depth) ---
-    // Standard winding on a CCW polygon in XZ gives inward-facing normals.
-    for (let i = 0; i < n; i++) {
-        const j = (i + 1) % n;
-        const [x0, z0] = polygon[i];
-        const [x1, z1] = polygon[j];
-        const vBase = positions.length / 3;
-        const segmentLength = Math.max(Math.hypot(x1 - x0, z1 - z0), 0.001);
-        pushWallVertex(x0, 0, z0, 0, 0); // v0 — floor level
-        pushWallVertex(x1, 0, z1, segmentLength, 0); // v1 — floor level
-        pushWallVertex(x1, depth, z1, segmentLength, depth); // v2 — ground level
-        pushWallVertex(x0, depth, z0, 0, depth); // v3 — ground level
-        indices.push(vBase, vBase + 1, vBase + 2);
-        indices.push(vBase, vBase + 2, vBase + 3);
+        const pts2d = contour.map(([x, z]) => new THREE.Vector2(x, z));
+        const holesPts2d = region.holes.map((h) => h.map(([x, z]) => new THREE.Vector2(x, z)));
+        for (const hole of region.holes) {
+            for (const [x, z] of hole)
+                pushFloorVertex(x, 0, z);
+        }
+        const floorTris = THREE.ShapeUtils.triangulateShape(pts2d, holesPts2d);
+        for (const tri of floorTris) {
+            // Reversed winding → normals point +Y (upward) in XZ plane
+            indices.push(floorBase + tri[0], floorBase + tri[2], floorBase + tri[1]);
+        }
+        // --- Inner walls (no top cap at Y=depth) ---
+        // Standard winding on a CCW polygon in XZ gives inward-facing normals.
+        for (let i = 0; i < contour.length; i++) {
+            const j = (i + 1) % contour.length;
+            const [x0, z0] = contour[i];
+            const [x1, z1] = contour[j];
+            const vBase = positions.length / 3;
+            const segmentLength = Math.max(Math.hypot(x1 - x0, z1 - z0), 0.001);
+            pushWallVertex(x0, 0, z0, 0, 0); // v0 — floor level
+            pushWallVertex(x1, 0, z1, segmentLength, 0); // v1 — floor level
+            pushWallVertex(x1, depth, z1, segmentLength, depth); // v2 — ground level
+            pushWallVertex(x0, depth, z0, 0, depth); // v3 — ground level
+            indices.push(vBase, vBase + 1, vBase + 2);
+            indices.push(vBase, vBase + 2, vBase + 3);
+        }
     }
     const geo = new THREE.BufferGeometry();
     geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));

package/dist/systems/slab/slab-system.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=slab-system.test.d.ts.map

package/dist/systems/slab/slab-system.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slab-system.test.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.test.ts"],"names":[],"mappings":""}

package/dist/systems/slab/slab-system.test.js

@@ -0,0 +1,63 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { SlabNode } from '@pascal-app/core';
+import { generateSlabGeometry } from './slab-system';
+const EMPTY_CONTEXT = { walls: [], siblingSlabs: [] };
+function hasVertexAt(geometry, x, z) {
+    const positions = geometry.getAttribute('position');
+    for (let index = 0; index < positions.count; index += 1) {
+        if (Math.abs(positions.getX(index) - x) < 1e-6 && Math.abs(positions.getZ(index) - z) < 1e-6) {
+            return true;
+        }
+    }
+    return false;
+}
+describe('generateSlabGeometry', () => {
+    test('renders a boundary-overlapping hole as an open indentation', () => {
+        const slab = SlabNode.parse({
+            elevation: 0.05,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [
+                [
+                    [1, -0.5],
+                    [3, -0.5],
+                    [3, 1],
+                    [1, 1],
+                ],
+            ],
+        });
+        const geometry = generateSlabGeometry(slab, EMPTY_CONTEXT);
+        expect((geometry.index?.count ?? 0) / 3).toBeGreaterThan(0);
+        expect(hasVertexAt(geometry, 1, 1)).toBe(true);
+        expect(hasVertexAt(geometry, 3, 1)).toBe(true);
+    });
+    test('renders a boundary-overlapping hole as an open indentation on recessed slabs', () => {
+        const slab = SlabNode.parse({
+            elevation: -0.2,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [
+                [
+                    [1, -0.5],
+                    [3, -0.5],
+                    [3, 1],
+                    [1, 1],
+                ],
+            ],
+        });
+        const geometry = generateSlabGeometry(slab, EMPTY_CONTEXT);
+        expect((geometry.index?.count ?? 0) / 3).toBeGreaterThan(0);
+        expect(hasVertexAt(geometry, 1, 1)).toBe(true);
+        expect(hasVertexAt(geometry, 3, 1)).toBe(true);
+    });
+});

package/dist/systems/stair/stair-materials.d.ts

@@ -1,7 +1,8 @@
 import { type StairNode, type StairSegmentNode } from '@pascal-app/core';
 import type * as THREE from 'three';
+import { type ColorPreset, type RenderShading } from '../../lib/materials';
 export type StairBodyMaterials = [THREE.Material, THREE.Material];
-export declare function getStairBodyMaterials(stair: StairNode): StairBodyMaterials;
-export declare function getStairRailingMaterial(stair: StairNode): THREE.Material;
-export declare function getStraightStairSegmentBodyMaterials(segment: StairSegmentNode, parentNode?: StairNode): StairBodyMaterials;
+export declare function getStairBodyMaterials(stair: StairNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset): StairBodyMaterials;
+export declare function getStairRailingMaterial(stair: StairNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset): THREE.Material;
+export declare function getStraightStairSegmentBodyMaterials(segment: StairSegmentNode, parentNode?: StairNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset): StairBodyMaterials;
 //# sourceMappingURL=stair-materials.d.ts.map

package/dist/systems/stair/stair-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAOnC,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AA6BjE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,kBAAkB,CAkB1E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,GAAG,KAAK,CAAC,QAAQ,CASxE;AAED,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,gBAAgB,EACzB,UAAU,CAAC,EAAE,SAAS,GACrB,kBAAkB,CAWpB"}
+{"version":3,"file":"stair-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AACnC,OAAO,EACL,KAAK,WAAW,EAKhB,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAA;AAE5B,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AAoCjE,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,GAChC,kBAAkB,CAqBpB;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,GAChC,KAAK,CAAC,QAAQ,CAoBhB;AAED,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,gBAAgB,EACzB,UAAU,CAAC,EAAE,SAAS,EACtB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,GAChC,kBAAkB,CAsBpB"}

package/dist/systems/stair/stair-materials.js

@@ -1,5 +1,5 @@
 import { getEffectiveStairSurfaceMaterial, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, DEFAULT_STAIR_MATERIAL, } from '../../lib/materials';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, DEFAULT_STAIR_MATERIAL, } from '../../lib/materials';
 const stairBodyMaterialCache = new Map();
 const stairRailingMaterialCache = new Map();
 function getSurfaceMaterialSignature(spec) {
@@ -8,19 +8,25 @@ function getSurfaceMaterialSignature(spec) {
         materialPreset: spec.materialPreset ?? null,
     });
 }
-function createResolvedMaterial(material, materialPreset) {
+function createResolvedMaterial(material, materialPreset, shading, textures, colorPreset) {
+    if (!textures) {
+        return createSurfaceRoleMaterial('joinery', colorPreset);
+    }
     if (materialPreset) {
-        return createMaterialFromPresetRef(materialPreset) ?? DEFAULT_STAIR_MATERIAL;
+        return createMaterialFromPresetRef(materialPreset, shading) ?? DEFAULT_STAIR_MATERIAL(shading);
     }
     if (material) {
-        return createMaterial(material);
+        return createMaterial(material, shading);
     }
-    return DEFAULT_STAIR_MATERIAL;
+    return DEFAULT_STAIR_MATERIAL(shading);
 }
-export function getStairBodyMaterials(stair) {
+export function getStairBodyMaterials(stair, shading = 'rendered', textures = true, colorPreset = 'clay') {
     const tread = getEffectiveStairSurfaceMaterial(stair, 'tread');
     const side = getEffectiveStairSurfaceMaterial(stair, 'side');
     const cacheKey = JSON.stringify({
+        shading,
+        textures,
+        colorPreset,
         tread: getSurfaceMaterialSignature(tread),
         side: getSurfaceMaterialSignature(side),
     });
@@ -28,29 +34,38 @@ export function getStairBodyMaterials(stair) {
     if (cached)
         return cached;
     const materials = [
-        createResolvedMaterial(tread.material, tread.materialPreset),
-        createResolvedMaterial(side.material, side.materialPreset),
+        createResolvedMaterial(tread.material, tread.materialPreset, shading, textures, colorPreset),
+        createResolvedMaterial(side.material, side.materialPreset, shading, textures, colorPreset),
     ];
     stairBodyMaterialCache.set(cacheKey, materials);
     return materials;
 }
-export function getStairRailingMaterial(stair) {
+export function getStairRailingMaterial(stair, shading = 'rendered', textures = true, colorPreset = 'clay') {
     const railing = getEffectiveStairSurfaceMaterial(stair, 'railing');
-    const cacheKey = getSurfaceMaterialSignature(railing);
+    const cacheKey = JSON.stringify({
+        shading,
+        textures,
+        colorPreset,
+        railing: getSurfaceMaterialSignature(railing),
+    });
     const cached = stairRailingMaterialCache.get(cacheKey);
     if (cached)
         return cached;
-    const material = createResolvedMaterial(railing.material, railing.materialPreset);
+    const material = createResolvedMaterial(railing.material, railing.materialPreset, shading, textures, colorPreset);
     stairRailingMaterialCache.set(cacheKey, material);
     return material;
 }
-export function getStraightStairSegmentBodyMaterials(segment, parentNode) {
+export function getStraightStairSegmentBodyMaterials(segment, parentNode, shading = 'rendered', textures = true, colorPreset = 'clay') {
     if (segment.material !== undefined || typeof segment.materialPreset === 'string') {
-        const override = createResolvedMaterial(segment.material, segment.materialPreset);
+        const override = createResolvedMaterial(segment.material, segment.materialPreset, shading, textures, colorPreset);
         return [override, override];
     }
     if (parentNode) {
-        return getStairBodyMaterials(parentNode);
+        return getStairBodyMaterials(parentNode, shading, textures, colorPreset);
+    }
+    if (!textures) {
+        const material = createSurfaceRoleMaterial('joinery', colorPreset);
+        return [material, material];
     }
-    return [DEFAULT_STAIR_MATERIAL, DEFAULT_STAIR_MATERIAL];
+    return [DEFAULT_STAIR_MATERIAL(shading), DEFAULT_STAIR_MATERIAL(shading)];
 }

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

@@ -1 +1 @@
-{"version":3,"file":"stair-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-system.tsx"],"names":[],"mappings":"AA4BA,eAAO,MAAM,WAAW,YAgHvB,CAAA"}
+{"version":3,"file":"stair-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-system.tsx"],"names":[],"mappings":"AA0BA,eAAO,MAAM,WAAW,YAuGvB,CAAA"}