@pascal-app/core 1.0.3 → 1.0.5

package/dist/lib/building-footprint.js

@@ -0,0 +1,89 @@
+import { getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
+import { calculateLevelMiters } from '../systems/wall/wall-mitering.js';
+import { unionPolygons } from './polygon-union.js';
+/** A three.js Y rotation of a plan point: local (x, z) turned by `yaw`. */
+export function turnPlanPoint(x, z, yaw) {
+    const c = Math.cos(yaw);
+    const s = Math.sin(yaw);
+    return [c * x + s * z, -s * x + c * z];
+}
+export function yawOf(rotation) {
+    if (typeof rotation === 'number')
+        return rotation;
+    if (Array.isArray(rotation))
+        return Number(rotation[1] ?? 0) || 0;
+    return 0;
+}
+/**
+ * Level-local plan (x, z) → site metres, through the building's placement: three.js Y rotation,
+ * the convention BuildingRenderer applies, `site = position + (c·x + s·z, −s·x + c·z)`.
+ */
+export function siteFrame(building) {
+    const yaw = building?.rotation?.[1] ?? 0;
+    const ox = building?.position?.[0] ?? 0;
+    const oz = building?.position?.[2] ?? 0;
+    return (x, z) => {
+        const [tx, tz] = turnPlanPoint(x, z, yaw);
+        return [ox + tx, oz + tz];
+    };
+}
+/** Site metres → the building's level-local plan (x, z): `siteFrame` inverted. */
+export function levelFrame(building) {
+    const yaw = building?.rotation?.[1] ?? 0;
+    const ox = building?.position?.[0] ?? 0;
+    const oz = building?.position?.[2] ?? 0;
+    return (x, z) => turnPlanPoint(x - ox, z - oz, -yaw);
+}
+/**
+ * Per-wall plan footprints for a level, mitred, then transformed by the building's site
+ * placement (`siteFrame`); with no building, in the level's own coordinates. `only` keeps the
+ * named walls, still mitred against every wall on the level.
+ */
+export function levelFootprintLoops(nodes, level, building, only) {
+    if (!level)
+        return [];
+    const walls = [];
+    for (const childId of level.children ?? []) {
+        const child = nodes[childId];
+        if (child?.type === 'wall')
+            walls.push(child);
+    }
+    if (walls.length === 0)
+        return [];
+    const miters = calculateLevelMiters(walls);
+    const toSite = siteFrame(building);
+    const loops = [];
+    for (const wall of walls) {
+        if (only && !only.has(wall.id))
+            continue;
+        const poly = getWallPlanFootprint(wall, miters);
+        if (poly.length < 3)
+            continue;
+        loops.push(poly.map((p) => toSite(p.x, p.y)));
+    }
+    return loops;
+}
+/**
+ * The outer ring(s) of a set of wall bands: their union, minus any ring that
+ * lies inside another (a room enclosed by partitions is a hole in the union,
+ * not a second building). Falls back to the bands themselves when the union
+ * yields nothing.
+ */
+export function footprintOutline(loops) {
+    const rings = unionPolygons(loops.map((loop) => loop.map((p) => [p[0], p[1]])));
+    if (rings.length === 0)
+        return loops.map((loop) => [...loop]);
+    const inside = (p, ring) => {
+        let hit = false;
+        for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+            const a = ring[i];
+            const b = ring[j];
+            if (a[1] > p[1] !== b[1] > p[1] &&
+                p[0] < ((b[0] - a[0]) * (p[1] - a[1])) / (b[1] - a[1]) + a[0]) {
+                hit = !hit;
+            }
+        }
+        return hit;
+    };
+    return rings.filter((ring, i) => !rings.some((other, j) => j !== i && ring[0] !== undefined && inside(ring[0], other)));
+}

package/dist/lib/canonical-opening-ring.d.ts

@@ -0,0 +1,3 @@
+import type { Ring } from './polygon-boolean.js';
+export declare function canonicalOpeningRing(polygon: Ring): Ring;
+//# sourceMappingURL=canonical-opening-ring.d.ts.map

package/dist/lib/canonical-opening-ring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-opening-ring.d.ts","sourceRoot":"","sources":["../../src/lib/canonical-opening-ring.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAE7C,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAkBxD"}

package/dist/lib/canonical-opening-ring.js

@@ -0,0 +1,14 @@
+export function canonicalOpeningRing(polygon) {
+    const ring = polygon.map(([x, z]) => [
+        Math.round(x * 10_000) / 10_000,
+        Math.round(z * 10_000) / 10_000,
+    ]);
+    if (ring.length > 1 &&
+        ring[0][0] === ring[ring.length - 1][0] &&
+        ring[0][1] === ring[ring.length - 1][1])
+        ring.pop();
+    if (ring.length < 3)
+        return ring;
+    const rotations = [ring, [...ring].reverse()].flatMap((points) => points.map((_, index) => [...points.slice(index), ...points.slice(0, index)]));
+    return rotations.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))[0];
+}

package/dist/lib/ceiling-children.d.ts

@@ -0,0 +1,8 @@
+import type { AnyNodeId, CeilingNode as CeilingNodeType } from '../schema/index.js';
+import { type Ring } from './polygon-boolean.js';
+import { type Point2D } from './room-graph.js';
+export declare function partitionCeilingChildren(ceiling: CeilingNodeType, roomIndices: number[], detected: Array<{
+    poly: Point2D[];
+    holes: Ring[];
+}>, fallbackRoomIndex: number | undefined, childPosition: (childId: AnyNodeId) => [number, number] | undefined): Map<number, (`item_${string}` | `procedural-item_${string}`)[]>;
+//# sourceMappingURL=ceiling-children.d.ts.map

package/dist/lib/ceiling-children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceiling-children.d.ts","sourceRoot":"","sources":["../../src/lib/ceiling-children.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,WAAW,CAAA;AAC1E,OAAO,EAAqC,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAChF,OAAO,EAAE,KAAK,OAAO,EAAgC,MAAM,cAAc,CAAA;AAEzE,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,MAAM,EAAE,EACrB,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAAC,EACnD,iBAAiB,EAAE,MAAM,GAAG,SAAS,EACrC,aAAa,EAAE,CAAC,OAAO,EAAE,SAAS,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,mEA0CpE"}

package/dist/lib/ceiling-children.js

@@ -0,0 +1,36 @@
+import { containsPoint, distanceToBoundary } from './polygon-boolean.js';
+import { pointFromTuple, pointToTuple } from './room-graph.js';
+export function partitionCeilingChildren(ceiling, roomIndices, detected, fallbackRoomIndex, childPosition) {
+    const assignments = new Map();
+    for (const roomIndex of roomIndices)
+        assignments.set(roomIndex, []);
+    for (const childId of ceiling.children) {
+        const tuple = childPosition?.(childId);
+        const point = tuple ? pointFromTuple(tuple) : undefined;
+        const boundaryRoomIndices = point
+            ? roomIndices.filter((roomIndex) => {
+                const room = detected[roomIndex];
+                return room
+                    ? distanceToBoundary([{ outer: room.poly.map(pointToTuple), holes: room.holes }], pointToTuple(point)) <= 1e-7
+                    : false;
+            })
+            : [];
+        const interiorRoomIndex = point && boundaryRoomIndices.length === 0
+            ? roomIndices.find((roomIndex) => {
+                const room = detected[roomIndex];
+                return room
+                    ? containsPoint([{ outer: room.poly.map(pointToTuple), holes: room.holes }], pointToTuple(point))
+                    : false;
+            })
+            : undefined;
+        const roomIndex = interiorRoomIndex ??
+            (fallbackRoomIndex !== undefined && boundaryRoomIndices.includes(fallbackRoomIndex)
+                ? fallbackRoomIndex
+                : boundaryRoomIndices[0]) ??
+            fallbackRoomIndex ??
+            roomIndices[0];
+        if (roomIndex !== undefined)
+            assignments.get(roomIndex)?.push(childId);
+    }
+    return assignments;
+}

package/dist/lib/ceiling-surface.d.ts

@@ -0,0 +1,40 @@
+import type { AnyNode, CeilingNode } from '../schema/index.js';
+import type { SurfacePaintRegion } from '../schema/nodes/surface-paint-region.js';
+import { type MultiPolygon } from './polygon-boolean.js';
+/**
+ * Who paints which part of a ceiling's underside. A ceiling draws its own
+ * finish (`slots.surface`) except where a paint region covers it; regions later
+ * in the list win. An automatic ceiling is rebuilt from its room, so the room
+ * holds its regions (`zone.ceiling.regions`); a manual ceiling holds its own
+ * (`ceiling.regions`). Pure 2D in level XZ — the renderer triangulates the
+ * cells, the paint path reads the roles.
+ */
+export declare const CEILING_SURFACE_ROLE = "surface";
+export declare function ceilingRegionRole(regionId: string): string;
+export declare function parseCeilingRegionRole(role: string): string | null;
+/** Whether a ceiling's regions live on its room (an automatic ceiling) rather than on itself. */
+export declare function ceilingRegionsOwner(ceiling: Pick<CeilingNode, 'id' | 'boundary' | 'zoneId'>): {
+    kind: 'zone';
+    id: string;
+} | {
+    kind: 'ceiling';
+    id: string;
+};
+/** The paint regions a ceiling draws: its room's for an automatic ceiling, its own otherwise. */
+export declare function ceilingPaintRegions(ceiling: Pick<CeilingNode, 'id' | 'boundary' | 'zoneId' | 'regions'>, nodes: Readonly<Record<string, AnyNode | undefined>>): readonly SurfacePaintRegion[];
+export type CeilingSurfaceCell = {
+    /** `surface` (the ceiling's own finish) or `region:<id>`. */
+    role: string;
+    /** The region's finish; absent for the ceiling's own `surface`. */
+    finish?: SurfacePaintRegion['finish'];
+    polygons: MultiPolygon;
+};
+/**
+ * Disjoint cells covering the ceiling (outline minus `holes`): each region
+ * takes what the later ones left, and `surface` is the rest. Regions that miss
+ * the ceiling produce no cell.
+ */
+export declare function computeCeilingSurfaceCells(outline: readonly [number, number][], holes: readonly (readonly [number, number][])[], regions: readonly SurfacePaintRegion[]): CeilingSurfaceCell[];
+/** What the partition of one ceiling depends on — its outline, holes and regions. */
+export declare function ceilingSurfaceSignature(ceiling: Pick<CeilingNode, 'polygon' | 'holes'>, regions: readonly SurfacePaintRegion[]): string;
+//# sourceMappingURL=ceiling-surface.d.ts.map

package/dist/lib/ceiling-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceiling-surface.d.ts","sourceRoot":"","sources":["../../src/lib/ceiling-surface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAA;AAC9E,OAAO,EAIL,KAAK,YAAY,EAGlB,MAAM,mBAAmB,CAAA;AAE1B;;;;;;;GAOG;AAEH,eAAO,MAAM,oBAAoB,YAAY,CAAA;AAG7C,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIlE;AAED,iGAAiG;AACjG,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,UAAU,GAAG,QAAQ,CAAC,GACvD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAIhE;AAED,iGAAiG;AACjG,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC,EACpE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,GACnD,SAAS,kBAAkB,EAAE,CAK/B;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAA;IACrC,QAAQ,EAAE,YAAY,CAAA;CACvB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EACpC,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,EAC/C,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,kBAAkB,EAAE,CAoBtB;AAED,qFAAqF;AACrF,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,GAAG,OAAO,CAAC,EAC/C,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,MAAM,CAER"}

package/dist/lib/ceiling-surface.js

@@ -0,0 +1,65 @@
+import { area, difference, intersection, union, } from './polygon-boolean.js';
+/**
+ * Who paints which part of a ceiling's underside. A ceiling draws its own
+ * finish (`slots.surface`) except where a paint region covers it; regions later
+ * in the list win. An automatic ceiling is rebuilt from its room, so the room
+ * holds its regions (`zone.ceiling.regions`); a manual ceiling holds its own
+ * (`ceiling.regions`). Pure 2D in level XZ — the renderer triangulates the
+ * cells, the paint path reads the roles.
+ */
+export const CEILING_SURFACE_ROLE = 'surface';
+const MIN_CELL_AREA = 1e-6;
+export function ceilingRegionRole(regionId) {
+    return `region:${regionId}`;
+}
+export function parseCeilingRegionRole(role) {
+    return role.startsWith('region:') && role.length > 'region:'.length
+        ? role.slice('region:'.length)
+        : null;
+}
+/** Whether a ceiling's regions live on its room (an automatic ceiling) rather than on itself. */
+export function ceilingRegionsOwner(ceiling) {
+    return ceiling.boundary === 'auto' && ceiling.zoneId
+        ? { kind: 'zone', id: ceiling.zoneId }
+        : { kind: 'ceiling', id: ceiling.id };
+}
+/** The paint regions a ceiling draws: its room's for an automatic ceiling, its own otherwise. */
+export function ceilingPaintRegions(ceiling, nodes) {
+    const owner = ceilingRegionsOwner(ceiling);
+    if (owner.kind === 'ceiling')
+        return ceiling.regions ?? [];
+    const zone = nodes[owner.id];
+    return zone?.type === 'zone' ? (zone.ceiling?.regions ?? []) : [];
+}
+/**
+ * Disjoint cells covering the ceiling (outline minus `holes`): each region
+ * takes what the later ones left, and `surface` is the rest. Regions that miss
+ * the ceiling produce no cell.
+ */
+export function computeCeilingSurfaceCells(outline, holes, regions) {
+    const surface = [
+        {
+            outer: outline.map(([x, z]) => [x, z]),
+            holes: holes.map((hole) => [...hole]),
+        },
+    ];
+    let remaining = holes.length ? union([surface]) : surface;
+    const cells = [];
+    for (let index = regions.length - 1; index >= 0; index -= 1) {
+        const region = regions[index];
+        if (region.polygon.length < 3 || !remaining.length)
+            continue;
+        const part = intersection(union([region.polygon]), remaining);
+        if (area(part) < MIN_CELL_AREA)
+            continue;
+        cells.push({ role: ceilingRegionRole(region.id), finish: region.finish, polygons: part });
+        remaining = difference(remaining, part);
+    }
+    if (area(remaining) >= MIN_CELL_AREA)
+        cells.push({ role: CEILING_SURFACE_ROLE, polygons: remaining });
+    return cells.reverse();
+}
+/** What the partition of one ceiling depends on — its outline, holes and regions. */
+export function ceilingSurfaceSignature(ceiling, regions) {
+    return JSON.stringify([ceiling.polygon, ceiling.holes ?? [], regions]);
+}