@pascal-app/viewer 1.0.6 → 1.1.0

package/dist/systems/item-light/pooled-lights.js

@@ -0,0 +1,449 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { float, instancedDynamicBufferAttribute, mrt, output, smoothstep, uv, vec4, } from 'three/tsl';
+import { AdditiveBlending, Color, DynamicDrawUsage, Frustum, InstancedBufferAttribute, MathUtils, Matrix4, Sphere, Sprite, SpriteNodeMaterial, Vector3, } from 'three/webgpu';
+import { useSceneAtmosphere } from '../../components/viewer/scene-atmosphere';
+import { isDaylightAtmosphere } from '../../lib/daylight/look';
+import { lampFeeds } from '../../lib/daylight/room-scene';
+import useViewer from '../../store/use-viewer';
+/**
+ * Unshadowed pool lights only lengthen the shaders' light loop (no pass, and no recompile while
+ * the count holds); a shadow slot adds a depth render each frame, so those stay few. Touch
+ * devices get smaller pools.
+ */
+function poolSizes() {
+    const touch = typeof window !== 'undefined' &&
+        typeof window.matchMedia === 'function' &&
+        window.matchMedia('(pointer: coarse)').matches;
+    return touch ? { point: 6, spot: 6, shadow: 2 } : { point: 16, spot: 16, shadow: 2 };
+}
+// A point light's shadow is six renders and a spot's one, so spots win the shadow slots.
+const POINT_SHADOW_FACTOR = 0.25;
+const GLOW_CAPACITY = 256;
+// How bright a glow stays in full daylight, against 1 at night.
+const DAYLIGHT_GLOW = 0.08;
+// Strength 1 is a lamp's plain halo at night, read against tone-mapped light colours.
+const GLOW_GAIN = 3;
+// Where a light with no distance of its own stops counting: intensity / d² under this.
+const REACH_CUTOFF = 0.01;
+// Nearer than this (metres squared) a light counts as this near, so one at the eye cannot win alone.
+const MIN_DISTANCE_SQ = 0.25;
+// How often (in seconds) to re-evaluate which lights hold slots (fallback timer)
+const REASSIGN_INTERVAL = 0.2;
+// A held slot keeps its key unless a newcomer adds this much more (no flicker at the boundary).
+const HYSTERESIS = 0.15;
+// Camera movement that triggers an early re-evaluation
+const CAM_MOVE_DIST = 0.5;
+const CAM_ROT_DOT = 0.995;
+const slotsOf = (size) => Array.from({ length: size }, () => ({ key: null, pendingKey: null, isFadingOut: false }));
+const _sphere = new Sphere();
+const _frustum = new Frustum();
+const _viewProjection = new Matrix4();
+/** The frustum `camera` sees, for a capture camera that never rendered as well as the live one. */
+function frustumOf(camera) {
+    camera.updateMatrixWorld();
+    _viewProjection.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+    return _frustum.setFromProjectionMatrix(_viewProjection, camera.coordinateSystem, camera.reversedDepth);
+}
+/**
+ * Roughly what a light adds to a view: its intensity over its squared distance from the eye, or 0
+ * when its reach (its distance, else where it falls under REACH_CUTOFF) misses the view.
+ */
+export function lightContribution(position, intensity, distance, eye, frustum) {
+    if (intensity <= 0)
+        return 0;
+    const reach = distance > 0 ? distance : Math.sqrt(intensity / REACH_CUTOFF);
+    if (!frustum.intersectsSphere(_sphere.set(position, reach)))
+        return 0;
+    return intensity / Math.max(position.distanceToSquared(eye), MIN_DISTANCE_SQ);
+}
+/**
+ * Gives the wanted keys (most first) the pool's slots: a key that holds a slot keeps it, and a
+ * newcomer evicts a key no longer wanted only on a clear win. A slot changing hands fades out
+ * first; an idle slot takes its key at once.
+ */
+export function assignSlots(slots, wanted, priorityByKey) {
+    const desired = wanted.map((candidate) => candidate.key);
+    const held = new Map();
+    slots.forEach((slot, i) => {
+        const key = slot.key ?? slot.pendingKey;
+        if (key)
+            held.set(key, i);
+    });
+    const used = new Set();
+    const assigned = new Set();
+    for (const key of desired) {
+        const index = held.get(key);
+        if (index !== undefined && !used.has(index)) {
+            used.add(index);
+            assigned.add(key);
+        }
+    }
+    let free = 0;
+    for (const key of desired) {
+        if (assigned.has(key))
+            continue;
+        while (free < slots.length && used.has(free))
+            free++;
+        if (free >= slots.length)
+            break;
+        const slot = slots[free];
+        const current = slot.key ?? slot.pendingKey;
+        if (current && !desired.includes(current)) {
+            const currentPriority = priorityByKey.get(current) ?? 0;
+            if ((priorityByKey.get(key) ?? 0) < currentPriority * (1 + HYSTERESIS)) {
+                free++;
+                continue;
+            }
+        }
+        used.add(free);
+        assigned.add(key);
+        if (slot.key !== key) {
+            slot.pendingKey = key;
+            slot.isFadingOut = slot.key !== null;
+            if (!slot.isFadingOut) {
+                slot.key = key;
+                slot.pendingKey = null;
+            }
+        }
+        free++;
+    }
+    slots.forEach((slot, i) => {
+        if (!used.has(i) && slot.key && !desired.includes(slot.key)) {
+            slot.pendingKey = null;
+            slot.isFadingOut = true;
+        }
+    });
+}
+/** A pool handed over at once, for a picture: no fades, each slot on the key it is going to. */
+function settle(slots) {
+    for (const slot of slots) {
+        if (slot.isFadingOut)
+            slot.key = slot.pendingKey;
+        slot.pendingKey = null;
+        slot.isFadingOut = false;
+    }
+}
+/** How much a glow shows: 1 at night, nearly nothing in daylight. */
+export function glowDarkness(sunDirection, appearance) {
+    if (!sunDirection)
+        return appearance === 'dark' ? 1 : DAYLIGHT_GLOW;
+    const elevation = sunDirection.y / (sunDirection.length() || 1);
+    return MathUtils.lerp(1, DAYLIGHT_GLOW, MathUtils.smoothstep(elevation, -0.05, 0.3));
+}
+const _pos = new Vector3();
+const _dir = new Vector3();
+const _camPos = new Vector3();
+const _camFwd = new Vector3();
+const _color = new Color();
+function place(light, source) {
+    light.color.set(source.color);
+    light.distance = source.distance;
+    if (source.getWorldPosition(_pos))
+        light.position.copy(_pos);
+    const spot = light;
+    if (!spot.isSpotLight)
+        return;
+    spot.angle = Math.min(Math.PI / 2, MathUtils.degToRad((source.spot?.angle ?? 60) / 2));
+    spot.penumbra = source.spot?.softness ?? 0;
+    if (source.getWorldDirection)
+        source.getWorldDirection(_dir);
+    else
+        _dir.set(0, -1, 0);
+    spot.target.position.copy(spot.position).add(_dir);
+    spot.target.updateMatrixWorld();
+}
+const fade = (light, to, dt) => {
+    light.intensity = MathUtils.lerp(light.intensity, to, Math.min(1, dt * 12));
+    if (to <= 0 && light.intensity < 0.01)
+        light.intensity = 0;
+};
+/**
+ * Drives a pool's slots for a frame. A slot's lights are its point light and, in the shadow
+ * pool, a spot beside it: the one matching its source shines, the other rests dark with its
+ * shadow map frozen.
+ */
+function drivePool(slots, lights, byKey, intensity, dt) {
+    // dt Infinity: every light straight to its target, for a picture.
+    slots.forEach((slot, i) => {
+        const pair = lights[i];
+        if (!pair?.every(Boolean))
+            return;
+        const members = pair;
+        if (slot.isFadingOut) {
+            for (const light of members)
+                fade(light, 0, dt);
+            if (members.every((light) => light.intensity === 0)) {
+                slot.isFadingOut = false;
+                slot.key = slot.pendingKey;
+                slot.pendingKey = null;
+            }
+            return;
+        }
+        const source = slot.key ? byKey.get(slot.key) : undefined;
+        if (!source)
+            slot.key = null;
+        const active = source
+            ? (members.find((light) => Boolean(light.isSpotLight) === !!source.spot) ??
+                members[0])
+            : null;
+        for (const light of members) {
+            if (light !== active || !source) {
+                fade(light, 0, dt);
+                if (light.castShadow)
+                    light.shadow.autoUpdate = light.intensity > 0;
+                continue;
+            }
+            place(light, source);
+            fade(light, intensity(source), dt);
+            if (light.castShadow)
+                light.shadow.autoUpdate = true;
+        }
+    });
+}
+function createGlows() {
+    const positions = new InstancedBufferAttribute(new Float32Array(GLOW_CAPACITY * 3), 3);
+    const colors = new InstancedBufferAttribute(new Float32Array(GLOW_CAPACITY * 3), 3);
+    const sizes = new InstancedBufferAttribute(new Float32Array(GLOW_CAPACITY), 1);
+    for (const attribute of [positions, colors, sizes])
+        attribute.setUsage(DynamicDrawUsage);
+    const material = new SpriteNodeMaterial({
+        transparent: true,
+        depthWrite: false,
+        blending: AdditiveBlending,
+    });
+    material.positionNode = instancedDynamicBufferAttribute(positions);
+    material.scaleNode = instancedDynamicBufferAttribute(sizes);
+    material.colorNode = instancedDynamicBufferAttribute(colors, 'vec3');
+    // A soft disc: full at the centre, smoothly nothing at the rim.
+    const falloff = smoothstep(float(1), float(0), uv().sub(0.5).length().mul(2));
+    material.opacityNode = falloff.mul(falloff);
+    // Nothing into the scene pass's normals and diffuse colour (alpha 0 under material blending): the
+    // ink reads the normals, and the whole quad, not just its disc, was an edge there. As the dust.
+    material.mrtNode = mrt({ output, diffuseColor: vec4(0), normal: vec4(0) });
+    material.fog = false;
+    const sprite = new Sprite(material);
+    sprite.count = 0;
+    sprite.frustumCulled = false;
+    sprite.raycast = () => { };
+    sprite.name = 'light-glows';
+    return { sprite, positions, colors, sizes };
+}
+const captureHooks = new WeakMap();
+/**
+ * Sets the item lights of `scene` for a picture taken through `camera`: the pools re-ranked for
+ * what that camera sees and every light straight at its strength, no fade. A capture camera is not
+ * the live view's, and a theme switched for the picture leaves no time for lamps to fade in.
+ * Returns what puts the live view's lights back.
+ */
+export function itemLightsForCapture(scene, camera) {
+    const restores = [...(captureHooks.get(scene) ?? [])].map((hook) => hook(camera));
+    return () => {
+        for (const restore of restores)
+            restore();
+    };
+}
+/**
+ * The lights items hold, through fixed pools of point lights, spots and two shadow-casting slots,
+ * handed to the lights that add most to the view (intensity over squared distance, among those
+ * whose reach meets the view frustum), with hysteresis, and faded across reassignment. Every pool
+ * light stays mounted and visible and only its intensity moves: changing the light count
+ * recompiles every material. The spot and shadow pools mount the first time a light needs them,
+ * and stay. Glows are one instanced sprite for every glowing lamp, pooled or not.
+ */
+export function PooledLights(props) {
+    // The daylight look lights rooms analytically (room lamps, window spill, exterior lamps): the
+    // pool hands its lamps over instead of mounting point lights and glows.
+    const daylight = isDaylightAtmosphere(useSceneAtmosphere());
+    return daylight ? _jsx(DaylightLampFeed, { ...props }) : _jsx(PooledLightPool, { ...props });
+}
+function DaylightLampFeed(props) {
+    const propsRef = useRef(props);
+    propsRef.current = props;
+    useLayoutEffect(() => {
+        const feed = {
+            lights: () => propsRef.current.getLights(),
+            // The feed hands back the pool's own lights.
+            intensity: (light) => propsRef.current.intensity(light),
+        };
+        lampFeeds.add(feed);
+        return () => {
+            lampFeeds.delete(feed);
+        };
+    }, []);
+    return null;
+}
+function PooledLightPool(props) {
+    const propsRef = useRef(props);
+    propsRef.current = props;
+    const scene = useThree((state) => state.scene);
+    const atmosphere = useSceneAtmosphere();
+    const atmosphereRef = useRef(atmosphere);
+    atmosphereRef.current = atmosphere;
+    const [sizes] = useState(poolSizes);
+    const [needs, setNeeds] = useState({ spots: false, shadows: false, glows: false });
+    const needsRef = useRef(needs);
+    needsRef.current = needs;
+    const pools = useRef({
+        point: slotsOf(sizes.point),
+        spot: slotsOf(sizes.spot),
+        shadow: slotsOf(sizes.shadow),
+    });
+    const pointRefs = useRef(Array.from({ length: sizes.point }, () => [null]));
+    const spotRefs = useRef(Array.from({ length: sizes.spot }, () => [null]));
+    const shadowRefs = useRef(Array.from({ length: sizes.shadow }, () => [null, null]));
+    const glows = useMemo(createGlows, []);
+    const reassignTimer = useRef(0);
+    const prevCamPos = useRef(new Vector3());
+    const prevCamFwd = useRef(new Vector3(0, 0, -1));
+    const collect = () => {
+        const byKey = new Map();
+        for (const light of propsRef.current.getLights())
+            byKey.set(light.key, light);
+        return byKey;
+    };
+    /** Hands the pools to the lights that add most to what `camera` sees. */
+    const rank = (camera, byKey) => {
+        const { weight, intensity } = propsRef.current;
+        const frustum = frustumOf(camera);
+        camera.getWorldPosition(_camPos);
+        const mounted = needsRef.current;
+        const wants = { ...mounted };
+        const ranked = [];
+        for (const light of byKey.values()) {
+            wants.spots ||= Boolean(light.spot);
+            wants.shadows ||= Boolean(light.shadows);
+            wants.glows ||= Boolean(light.glow);
+            const factor = weight(light);
+            if (factor <= 0 || !light.getWorldPosition(_pos))
+                continue;
+            const priority = factor * lightContribution(_pos, intensity(light), light.distance, _camPos, frustum);
+            if (priority > 0)
+                ranked.push({ key: light.key, priority, light });
+        }
+        if (wants.spots !== mounted.spots ||
+            wants.shadows !== mounted.shadows ||
+            wants.glows !== mounted.glows)
+            setNeeds(wants);
+        ranked.sort((a, b) => b.priority - a.priority);
+        const priorityByKey = new Map(ranked.map((candidate) => [candidate.key, candidate.priority]));
+        const shadowed = mounted.shadows
+            ? ranked
+                .filter((candidate) => candidate.light.shadows)
+                .map((candidate) => ({
+                key: candidate.key,
+                priority: candidate.priority * (candidate.light.spot ? 1 : POINT_SHADOW_FACTOR),
+            }))
+                .sort((a, b) => b.priority - a.priority)
+                .slice(0, sizes.shadow)
+            : [];
+        const inShadowPool = new Set(shadowed.map((candidate) => candidate.key));
+        const rest = ranked.filter((candidate) => !inShadowPool.has(candidate.key));
+        assignSlots(pools.current.shadow, shadowed, priorityByKey);
+        assignSlots(pools.current.spot, mounted.spots ? rest.filter((candidate) => candidate.light.spot).slice(0, sizes.spot) : [], priorityByKey);
+        // Until the spot pool mounts, a spot shines as a point light.
+        assignSlots(pools.current.point, rest.filter((candidate) => !(mounted.spots && candidate.light.spot)).slice(0, sizes.point), priorityByKey);
+    };
+    const drive = (byKey, dt) => {
+        const { intensity } = propsRef.current;
+        drivePool(pools.current.point, pointRefs.current, byKey, intensity, dt);
+        drivePool(pools.current.spot, spotRefs.current, byKey, intensity, dt);
+        drivePool(pools.current.shadow, shadowRefs.current, byKey, intensity, dt);
+    };
+    /**
+     * The glows, each at its bulb and depth-tested: the fixture's opaque housing hides what lies
+     * behind it and its glass shows it. Drawn nearer the eye, a glow covered the fixture's own body.
+     */
+    const placeGlows = (byKey) => {
+        if (!needsRef.current.glows)
+            return;
+        const { intensity } = propsRef.current;
+        const darkness = glowDarkness(atmosphereRef.current?.sunDirection ?? null, useViewer.getState().sceneAppearance.appearance);
+        let count = 0;
+        for (const light of byKey.values()) {
+            if (!light.glow || count >= GLOW_CAPACITY)
+                continue;
+            const now = intensity(light);
+            if (now <= 0 || !light.getWorldPosition(_pos))
+                continue;
+            const level = light.peak ? Math.min(1, now / light.peak) : 1;
+            _color
+                .set(light.color)
+                .multiplyScalar(GLOW_GAIN * (light.glow.strength ?? 1) * level * darkness);
+            glows.positions.setXYZ(count, _pos.x, _pos.y, _pos.z);
+            glows.colors.setXYZ(count, _color.r, _color.g, _color.b);
+            glows.sizes.setX(count, light.glow.size);
+            count++;
+        }
+        glows.sprite.count = count;
+        glows.sprite.visible = count > 0;
+        glows.positions.needsUpdate = true;
+        glows.colors.needsUpdate = true;
+        glows.sizes.needsUpdate = true;
+    };
+    useEffect(() => {
+        const hook = (camera) => {
+            const slots = Object.values(pools.current).map((pool) => pool.map((slot) => ({ ...slot })));
+            const lights = [...pointRefs.current, ...spotRefs.current, ...shadowRefs.current]
+                .flat()
+                .filter((light) => Boolean(light));
+            const intensities = lights.map((light) => light.intensity);
+            const byKey = collect();
+            rank(camera, byKey);
+            for (const pool of Object.values(pools.current))
+                settle(pool);
+            drive(byKey, Number.POSITIVE_INFINITY);
+            placeGlows(byKey);
+            return () => {
+                Object.values(pools.current).forEach((pool, i) => {
+                    pool.forEach((slot, j) => {
+                        Object.assign(slot, slots[i][j]);
+                    });
+                });
+                lights.forEach((light, i) => {
+                    light.intensity = intensities[i];
+                });
+                reassignTimer.current = 0;
+            };
+        };
+        let hooks = captureHooks.get(scene);
+        if (!hooks) {
+            hooks = new Set();
+            captureHooks.set(scene, hooks);
+        }
+        hooks.add(hook);
+        return () => {
+            hooks.delete(hook);
+        };
+        // biome-ignore lint/correctness/useExhaustiveDependencies: the hook reads the latest props and pools through refs
+    }, [scene]);
+    useFrame(({ camera }, delta) => {
+        const byKey = collect();
+        camera.getWorldPosition(_camPos);
+        camera.getWorldDirection(_camFwd);
+        const camMoved = _camPos.distanceTo(prevCamPos.current) > CAM_MOVE_DIST ||
+            _camFwd.dot(prevCamFwd.current) < CAM_ROT_DOT;
+        reassignTimer.current -= delta;
+        if (reassignTimer.current <= 0 || camMoved) {
+            reassignTimer.current = REASSIGN_INTERVAL;
+            prevCamPos.current.copy(_camPos);
+            prevCamFwd.current.copy(_camFwd);
+            rank(camera, byKey);
+        }
+        drive(byKey, Math.min(delta, 0.1));
+        placeGlows(byKey);
+    }, 6);
+    return (_jsxs(_Fragment, { children: [pointRefs.current.map((_, i) => (_jsx("pointLight", { castShadow: false, intensity: 0, ref: (el) => {
+                    pointRefs.current[i][0] = el;
+                } }, i))), needs.spots &&
+                spotRefs.current.map((_, i) => (_jsx("spotLight", { castShadow: false, intensity: 0, ref: (el) => {
+                        spotRefs.current[i][0] = el;
+                    } }, i))), needs.shadows &&
+                shadowRefs.current.map((_, i) => (_jsxs("group", { children: [_jsx("pointLight", { castShadow: true, intensity: 0, ref: (el) => {
+                                shadowRefs.current[i][0] = el;
+                            }, "shadow-bias": -0.0005, "shadow-camera-far": 20, "shadow-camera-near": 0.05, "shadow-mapSize": [512, 512], "shadow-normalBias": 0.02 }), _jsx("spotLight", { castShadow: true, intensity: 0, ref: (el) => {
+                                shadowRefs.current[i][1] = el;
+                            }, "shadow-bias": -0.0005, "shadow-camera-far": 20, "shadow-camera-near": 0.05, "shadow-mapSize": [1024, 1024], "shadow-normalBias": 0.02 })] }, i))), needs.glows && _jsx("primitive", { object: glows.sprite })] }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"level-system.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-system.tsx"],"names":[],"mappings":"AAWA,eAAO,MAAM,WAAW,YAyEvB,CAAA"}
+{"version":3,"file":"level-system.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-system.tsx"],"names":[],"mappings":"AAqBA,eAAO,MAAM,WAAW,YAiFvB,CAAA"}

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

@@ -1,12 +1,21 @@
 import { getLevelElevations, sceneRegistry, useScene } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { lerp } from 'three/src/math/MathUtils.js';
+import { getLayoutRevision, isLayoutObserved } from '../../lib/layer-pass';
 import { applyShadowOnly, clearShadowOnly } from '../../lib/shadow-only';
 import useViewer from '../../store/use-viewer';
 import { heldLevelY } from './level-hold';
 import { EXPLODED_GAP, resolveLevelVisibility } from './level-utils';
 import { shadowOnlyLevels } from './shadow-only-levels';
 const placed = new WeakSet();
+/** Layout revision right after a level was last made shadow-only (see layer-pass.ts). */
+const shadowOnlyAt = new WeakMap();
+function sceneRoot(object) {
+    let root = object;
+    while (root.parent)
+        root = root.parent;
+    return root;
+}
 export const LevelSystem = () => {
     useFrame((_, delta) => {
         const nodes = useScene.getState().nodes;
@@ -64,12 +73,21 @@ export const LevelSystem = () => {
                 revealing: levelsRevealing.includes(levelId),
             });
             if (shadowOnly) {
-                applyShadowOnly(obj);
+                // Re-applied so meshes rebuilt while hidden are hidden too — a rebuild inserts children
+                // or writes masks, which moves the observed layout revision; without either the level
+                // is as it was left.
+                const observed = isLayoutObserved(sceneRoot(obj));
+                if (!observed || shadowOnlyAt.get(obj) !== getLayoutRevision()) {
+                    applyShadowOnly(obj);
+                    if (observed)
+                        shadowOnlyAt.set(obj, getLayoutRevision());
+                }
                 shadowOnlyLevels.add(obj);
             }
             else if (shadowOnlyLevels.has(obj)) {
                 clearShadowOnly(obj);
                 shadowOnlyLevels.delete(obj);
+                shadowOnlyAt.delete(obj);
             }
             obj.visible = visible;
         }

package/dist/systems/roof/roof-material-slots.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A roof mesh's material slots. Slots 0–3 come out of the CSG (0 wall / trim,
+ * 1 deck, 2 interior and fascia, 3 shingle top); the wall bands are split off
+ * slot 0 after it (`splitRoofWallBandFaces`): the heel band (the wall between
+ * the top plate and the eaves) and each gable end, so each paints apart from
+ * the edge role. The merged shell splits only the heel band; a segment's own
+ * mesh splits its gables too.
+ */
+export declare const ROOF_HEEL_MATERIAL_INDEX = 4;
+export declare const ROOF_GABLE_LEFT_MATERIAL_INDEX = 5;
+export declare const ROOF_GABLE_RIGHT_MATERIAL_INDEX = 6;
+/** Every slot a roof mesh can carry: the four CSG slots plus the wall bands. */
+export declare const ROOF_RENDER_MATERIAL_COUNT = 7;
+//# sourceMappingURL=roof-material-slots.d.ts.map

package/dist/systems/roof/roof-material-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-material-slots.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-material-slots.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAA;AACzC,eAAO,MAAM,8BAA8B,IAAI,CAAA;AAC/C,eAAO,MAAM,+BAA+B,IAAI,CAAA;AAChD,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,IAAI,CAAA"}

package/dist/systems/roof/roof-material-slots.js

@@ -0,0 +1,13 @@
+/**
+ * A roof mesh's material slots. Slots 0–3 come out of the CSG (0 wall / trim,
+ * 1 deck, 2 interior and fascia, 3 shingle top); the wall bands are split off
+ * slot 0 after it (`splitRoofWallBandFaces`): the heel band (the wall between
+ * the top plate and the eaves) and each gable end, so each paints apart from
+ * the edge role. The merged shell splits only the heel band; a segment's own
+ * mesh splits its gables too.
+ */
+export const ROOF_HEEL_MATERIAL_INDEX = 4;
+export const ROOF_GABLE_LEFT_MATERIAL_INDEX = 5;
+export const ROOF_GABLE_RIGHT_MATERIAL_INDEX = 6;
+/** Every slot a roof mesh can carry: the four CSG slots plus the wall bands. */
+export const ROOF_RENDER_MATERIAL_COUNT = 7;

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

@@ -2,7 +2,20 @@ import { type AnyNode, type RoofNode, type SceneMaterial, type SceneMaterialId }
 import type * as THREE from 'three';
 import { type ColorPreset, type RenderShading } from '../../lib/materials';
 type SceneMaterials = Record<SceneMaterialId, SceneMaterial> | undefined;
-export type RoofMaterialArray = [THREE.Material, THREE.Material, THREE.Material, THREE.Material];
+/**
+ * One material per roof mesh slot (`roof-material-slots.ts`): 0 wall / trim
+ * (the edge role), 1 deck, 2 interior, 3 shingle top, 4 the heel band, 5 and
+ * 6 the gable ends — the merged shell's gables are the edge role's.
+ */
+export type RoofMaterialArray = [
+    THREE.Material,
+    THREE.Material,
+    THREE.Material,
+    THREE.Material,
+    THREE.Material,
+    THREE.Material,
+    THREE.Material
+];
 /**
  * The cladding the walls under a roof declare through their ASSEMBLIES
  * (`wall.assembly.exterior.finish` → catalog ref), so the roof's gable band —
@@ -13,8 +26,18 @@ export type RoofMaterialArray = [THREE.Material, THREE.Material, THREE.Material,
  * null when none declares one.
  */
 export declare function levelWallCladdingRef(nodes: Readonly<Record<string, AnyNode | undefined>>, roof: Pick<RoofNode, 'parentId'>): string | null;
+/**
+ * What the walls under a roof show outside, for the heel band — the strip of
+ * wall between their top plate and the eaves, which is wall, not trim: their
+ * exterior face's paint, else the cladding their assembly declares
+ * (`levelWallCladdingRef`'s walls). The most common wins; null when none has
+ * either.
+ */
+export declare function levelWallFaceRef(nodes: Readonly<Record<string, AnyNode | undefined>>, roof: Pick<RoofNode, 'parentId'>): string | null;
 export declare function getRoofMaterialArray(node: RoofNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string, 
 /** Catalog ref for the gable/trim band when unpainted — see `levelWallCladdingRef`. */
-wallCladdingRef?: string | null, sceneMaterials?: SceneMaterials): RoofMaterialArray | null;
+wallCladdingRef?: string | null, sceneMaterials?: SceneMaterials, 
+/** Catalog ref for the heel band when unpainted — see `levelWallFaceRef`. */
+wallFaceRef?: string | null): RoofMaterialArray | null;
 export {};
 //# sourceMappingURL=roof-materials.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAMZ,KAAK,QAAQ,EAEb,KAAK,aAAa,EAClB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AACnC,OAAO,EACL,KAAK,WAAW,EAGhB,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAA;AAE5B,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;AAaxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AAqChG;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,EACpD,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,GAC/B,MAAM,GAAG,IAAI,CAyBf;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM;AACnB,uFAAuF;AACvF,eAAe,GAAE,MAAM,GAAG,IAAW,EACrC,cAAc,CAAC,EAAE,cAAc,GAC9B,iBAAiB,GAAG,IAAI,CA4D1B"}
+{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAOZ,KAAK,QAAQ,EAEb,KAAK,aAAa,EAClB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AACnC,OAAO,EACL,KAAK,WAAW,EAGhB,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAA;AAE5B,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;AAaxE;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,CAAC,QAAQ;IACd,KAAK,CAAC,QAAQ;IACd,KAAK,CAAC,QAAQ;IACd,KAAK,CAAC,QAAQ;IACd,KAAK,CAAC,QAAQ;IACd,KAAK,CAAC,QAAQ;IACd,KAAK,CAAC,QAAQ;CACf,CAAA;AA4FD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,EACpD,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,GAC/B,MAAM,GAAG,IAAI,CAEf;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,EACpD,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,GAC/B,MAAM,GAAG,IAAI,CAEf;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM;AACnB,uFAAuF;AACvF,eAAe,GAAE,MAAM,GAAG,IAAW,EACrC,cAAc,CAAC,EAAE,cAAc;AAC/B,6EAA6E;AAC7E,WAAW,GAAE,MAAM,GAAG,IAAW,GAChC,iBAAiB,GAAG,IAAI,CAqF1B"}