@pascal-app/core 0.7.0 → 0.8.0

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

@@ -1,8 +0,0 @@
-import * as THREE from 'three';
-import type { SlabNode } from '../../schema';
-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

@@ -1 +0,0 @@
-{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAcvD,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAmFD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAG7E"}

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

@@ -1,214 +0,0 @@
-import { useFrame } from '@react-three/fiber';
-import * as THREE from 'three';
-import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
-import { insetPolygonFromCentroid, simplifyClosedPolygon } from '../../lib/polygon-geometry';
-import useScene from '../../store/use-scene';
-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;
-}
-/** Half of default wall thickness — used to extend slab geometry under walls */
-const SLAB_OUTSET = 0.05;
-const AUTO_SLAB_INSET = 0.02;
-const AUTO_SLAB_SIMPLIFY_TOLERANCE = 0.08;
-function getRenderableSlabPolygon(slabNode) {
-    return slabNode.autoFromWalls
-        ? simplifyClosedPolygon(insetPolygonFromCentroid(slabNode.polygon, AUTO_SLAB_INSET), AUTO_SLAB_SIMPLIFY_TOLERANCE)
-        : outsetPolygon(slabNode.polygon, SLAB_OUTSET);
-}
-/**
- * Expand a polygon outward by a uniform distance.
- * Offsets each edge outward then intersects consecutive offset edges.
- */
-function outsetPolygon(polygon, amount) {
-    const n = polygon.length;
-    if (n < 3)
-        return polygon;
-    // Determine winding via signed area
-    let area2 = 0;
-    for (let i = 0; i < n; i++) {
-        const j = (i + 1) % n;
-        area2 += polygon[i][0] * polygon[j][1] - polygon[j][0] * polygon[i][1];
-    }
-    const s = area2 >= 0 ? 1 : -1;
-    // Offset each edge outward by amount
-    const offEdges = [];
-    for (let i = 0; i < n; i++) {
-        const j = (i + 1) % n;
-        const dx = polygon[j][0] - polygon[i][0];
-        const dz = polygon[j][1] - polygon[i][1];
-        const len = Math.sqrt(dx * dx + dz * dz);
-        if (len < 1e-9) {
-            offEdges.push([polygon[i][0], polygon[i][1], dx, dz]);
-            continue;
-        }
-        const nx = ((s * dz) / len) * amount;
-        const nz = ((s * -dx) / len) * amount;
-        offEdges.push([polygon[i][0] + nx, polygon[i][1] + nz, dx, dz]);
-    }
-    // Intersect consecutive offset edges to get new vertices
-    const result = [];
-    for (let i = 0; i < n; i++) {
-        const j = (i + 1) % n;
-        const [ax, az, adx, adz] = offEdges[i];
-        const [bx, bz, bdx, bdz] = offEdges[j];
-        const denom = adx * bdz - adz * bdx;
-        if (Math.abs(denom) < 1e-9) {
-            // Parallel edges — use offset endpoint
-            result.push([ax + adx, az + adz]);
-        }
-        else {
-            const t = ((bx - ax) * bdz - (bz - az) * bdx) / denom;
-            result.push([ax + t * adx, az + t * adz]);
-        }
-    }
-    return result;
-}
-/**
- * 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-system.d.ts

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

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

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