@pascal-app/viewer 0.5.1 → 0.7.0

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

@@ -0,0 +1,8 @@
+import { type SlabNode } from '@pascal-app/core';
+import * as THREE from 'three';
+export declare const SlabSystem: () => null;
+/**
+ * Generates extruded slab geometry from polygon
+ */
+export declare function generateSlabGeometry(slabNode: SlabNode): THREE.BufferGeometry;
+//# sourceMappingURL=slab-system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,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"}

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

@@ -0,0 +1,155 @@
+import { useFrame } from '@react-three/fiber';
+import { getRenderableSlabPolygon, sceneRegistry, useScene, } from '@pascal-app/core';
+import * as THREE from 'three';
+function ensureUv2Attribute(geometry) {
+    const uv = geometry.getAttribute('uv');
+    if (!uv)
+        return;
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
+}
+// ============================================================================
+// SLAB SYSTEM
+// ============================================================================
+export const SlabSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        // Process dirty slabs
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'slab')
+                return;
+            const mesh = sceneRegistry.nodes.get(id);
+            if (mesh) {
+                updateSlabGeometry(node, mesh);
+                clearDirty(id);
+            }
+            // If mesh not found, keep it dirty for next frame
+        });
+    }, 1);
+    return null;
+};
+/**
+ * Updates the geometry for a single slab
+ */
+function updateSlabGeometry(node, mesh) {
+    const newGeo = generateSlabGeometry(node);
+    ensureUv2Attribute(newGeo);
+    mesh.geometry.dispose();
+    mesh.geometry = newGeo;
+    // For negative elevation, shift the mesh down so the top face sits at Y=elevation
+    // rather than at Y=0. Positive elevation stays at Y=0 (slab sits at floor level).
+    const elevation = node.elevation ?? 0.05;
+    mesh.position.y = elevation < 0 ? elevation : 0;
+}
+/**
+ * Generates extruded slab geometry from polygon
+ */
+export function generateSlabGeometry(slabNode) {
+    const elevation = slabNode.elevation ?? 0.05;
+    return elevation < 0 ? generatePoolGeometry(slabNode) : generatePositiveSlabGeometry(slabNode);
+}
+/**
+ * Standard slab: flat extrusion upward from Y=0 by elevation thickness.
+ */
+function generatePositiveSlabGeometry(slabNode) {
+    const polygon = getRenderableSlabPolygon(slabNode);
+    const elevation = slabNode.elevation ?? 0.05;
+    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 geometry = new THREE.ExtrudeGeometry(shape, { depth: elevation, bevelEnabled: false });
+    geometry.rotateX(-Math.PI / 2);
+    geometry.computeVertexNormals();
+    return geometry;
+}
+/**
+ * Pool / recessed slab: floor cap at Y=0 (local) + inner walls up to Y=|elevation|.
+ * No top cap — the opening at ground level is handled by the ground occluder hole.
+ * mesh.position.y must be set to elevation so the floor sits at the correct world Y.
+ *
+ * Geometry is built directly in 3D (Y-up) to avoid rotation confusion:
+ *   - 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);
+    const depth = Math.abs(slabNode.elevation ?? 0.05);
+    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);
+    };
+    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)
+            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 geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    geo.setIndex(indices);
+    geo.computeVertexNormals();
+    return geo;
+}

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

@@ -0,0 +1,7 @@
+import { type StairNode, type StairSegmentNode } from '@pascal-app/core';
+import type * as THREE from 'three';
+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;
+//# sourceMappingURL=stair-materials.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,56 @@
+import { getEffectiveStairSurfaceMaterial, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, DEFAULT_STAIR_MATERIAL, } from '../../lib/materials';
+const stairBodyMaterialCache = new Map();
+const stairRailingMaterialCache = new Map();
+function getSurfaceMaterialSignature(spec) {
+    return JSON.stringify({
+        material: spec.material ?? null,
+        materialPreset: spec.materialPreset ?? null,
+    });
+}
+function createResolvedMaterial(material, materialPreset) {
+    if (materialPreset) {
+        return createMaterialFromPresetRef(materialPreset) ?? DEFAULT_STAIR_MATERIAL;
+    }
+    if (material) {
+        return createMaterial(material);
+    }
+    return DEFAULT_STAIR_MATERIAL;
+}
+export function getStairBodyMaterials(stair) {
+    const tread = getEffectiveStairSurfaceMaterial(stair, 'tread');
+    const side = getEffectiveStairSurfaceMaterial(stair, 'side');
+    const cacheKey = JSON.stringify({
+        tread: getSurfaceMaterialSignature(tread),
+        side: getSurfaceMaterialSignature(side),
+    });
+    const cached = stairBodyMaterialCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const materials = [
+        createResolvedMaterial(tread.material, tread.materialPreset),
+        createResolvedMaterial(side.material, side.materialPreset),
+    ];
+    stairBodyMaterialCache.set(cacheKey, materials);
+    return materials;
+}
+export function getStairRailingMaterial(stair) {
+    const railing = getEffectiveStairSurfaceMaterial(stair, 'railing');
+    const cacheKey = getSurfaceMaterialSignature(railing);
+    const cached = stairRailingMaterialCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const material = createResolvedMaterial(railing.material, railing.materialPreset);
+    stairRailingMaterialCache.set(cacheKey, material);
+    return material;
+}
+export function getStraightStairSegmentBodyMaterials(segment, parentNode) {
+    if (segment.material !== undefined || typeof segment.materialPreset === 'string') {
+        const override = createResolvedMaterial(segment.material, segment.materialPreset);
+        return [override, override];
+    }
+    if (parentNode) {
+        return getStairBodyMaterials(parentNode);
+    }
+    return [DEFAULT_STAIR_MATERIAL, DEFAULT_STAIR_MATERIAL];
+}

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

@@ -0,0 +1,2 @@
+export declare const StairSystem: () => null;
+//# sourceMappingURL=stair-system.d.ts.map

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

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