@pascal-app/viewer 0.8.0 → 0.9.2

package/dist/lib/materials.js

@@ -1,36 +1,119 @@
-import { getMaterialPresetByRef, resolveMaterial, } from '@pascal-app/core';
+import { getMaterialPresetByRef, parseMaterialRef, resolveMaterial, } from '@pascal-app/core';
 import * as THREE from 'three';
-import { MeshStandardNodeMaterial } from 'three/webgpu';
-export const baseMaterial = new MeshStandardNodeMaterial({
-    color: '#f2f0ed',
-    roughness: 0.5,
-    metalness: 0.0,
-});
-export const glassMaterial = new MeshStandardNodeMaterial({
+import { float, mix, positionViewDirection, transformedNormalView } from 'three/tsl';
+import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+import { resolveCdnUrl } from './asset-url';
+import { isKtx2Url, ktx2Loader, whenKtx2Ready } from './ktx2-loader';
+import { getSceneTheme } from './scene-themes';
+export const CLAY_PALETTE = {
+    wall: '#dcd6c7',
+    floor: '#cfc8b6',
+    ceiling: '#e4ded0',
+    roof: '#b8ad96',
+    joinery: '#c4bba6',
+    glazing: '#c8d4dc',
+    furnishing: '#d2ccbe',
+};
+// Albedos are clamped to ≈0.83 linear (max channel #eb): real white paint
+// reflects ~80%, and pure-white albedo kills GI/shadow contrast.
+export const WHITE_PALETTE = {
+    wall: '#ebeae6',
+    floor: '#e7e4dd',
+    ceiling: '#ebeae6',
+    roof: '#dedbd2',
+    joinery: '#e5e2d9',
+    glazing: '#dbe8ee',
+    furnishing: '#e9e7e1',
+};
+export const MONO_PALETTE = {
+    wall: '#c8c8c8',
+    floor: '#b8b8b8',
+    ceiling: '#d8d8d8',
+    roof: '#9a9a9a',
+    joinery: '#adadad',
+    glazing: '#c2cbd0',
+    furnishing: '#c0c0c0',
+};
+export const BLUEPRINT_PALETTE = {
+    wall: '#90a9c7',
+    floor: '#7f98ba',
+    ceiling: '#aec0d8',
+    roof: '#5f789b',
+    joinery: '#6f86a8',
+    glazing: '#b6d7ea',
+    furnishing: '#8ba2bf',
+};
+export const PRESET_PALETTES = {
+    clay: CLAY_PALETTE,
+    white: WHITE_PALETTE,
+    mono: MONO_PALETTE,
+    blueprint: BLUEPRINT_PALETTE,
+};
+export function resolveSurfaceColor(role, preset, sceneThemeId) {
+    // The active scene theme may tint individual roles (e.g. Mediterranean's blue
+    // roof); fall back to the chosen colour preset's palette when it doesn't.
+    const tints = sceneThemeId ? getSceneTheme(sceneThemeId).clayTints : undefined;
+    return tints?.[role] ?? (PRESET_PALETTES[preset] ?? CLAY_PALETTE)[role];
+}
+// DoubleSide on any NodeMaterial inside the MRT scenePass (SSGI's output /
+// diffuseColor / normal targets) causes WebGPU to create a render pipeline
+// whose back-face shader variant doesn't declare outputs for every MRT target
+// — the validator rejects it and poisons the entire render context. FrontSide
+// avoids that code path. Same pattern as MeshStandardMaterial in renderer.tsx.
+export const glassMaterial = new MeshLambertNodeMaterial({
     color: '#e0f2fe',
-    roughness: 0.05,
-    metalness: 0.0,
     transparent: true,
     opacity: 0.35,
-    side: THREE.DoubleSide,
+    side: THREE.FrontSide,
 });
+glassMaterial.userData.__pascalCachedMaterial = true;
+function resolveNodeMaterialSide(side) {
+    return side === THREE.DoubleSide ? THREE.FrontSide : side;
+}
 const sideMap = {
     front: THREE.FrontSide,
     back: THREE.BackSide,
-    double: THREE.DoubleSide,
+    double: THREE.FrontSide,
 };
 const materialCache = new Map();
+const defaultMaterialCache = new Map();
+const surfaceRoleMaterialCache = new Map();
 const textureCache = new Map();
 const textureLoadPromises = new Map();
 const textureLoader = new THREE.TextureLoader();
+// `.ktx2` finish maps transcode through the shared KTX2 loader (support is
+// detected once at viewer init); everything else loads as a normal image.
+function pickTextureLoader(url) {
+    // KTX2Loader's load/loadAsync are call-compatible with TextureLoader (url →
+    // Texture / Promise<Texture>); cast for typing.
+    return isKtx2Url(url) ? ktx2Loader : textureLoader;
+}
 const wrapMap = {
     Repeat: THREE.RepeatWrapping,
     ClampToEdge: THREE.ClampToEdgeWrapping,
     MirroredRepeat: THREE.MirroredRepeatWrapping,
 };
 const SRGB_TEXTURE_SLOTS = ['map', 'emissiveMap'];
-function getCacheKey(props) {
-    return `${props.color}-${props.roughness}-${props.metalness}-${props.opacity}-${props.transparent}-${props.side}`;
+const TEXTURE_SLOTS = [
+    'map',
+    'normalMap',
+    'roughnessMap',
+    'metalnessMap',
+    'displacementMap',
+    'aoMap',
+    'bumpMap',
+    'alphaMap',
+    'lightMap',
+    'emissiveMap',
+];
+function getTextureChannel(slot) {
+    if (slot === 'aoMap' || slot === 'lightMap') {
+        return 2;
+    }
+    return 0;
+}
+function getCacheKey(props, shading) {
+    return `${shading}-${props.color}-${props.roughness}-${props.metalness}-${props.opacity}-${props.transparent}-${props.side}`;
 }
 function getTextureKey(material) {
     const texture = material?.texture;
@@ -48,18 +131,24 @@ function getTexture(material) {
     const cached = textureCache.get(cacheKey);
     if (cached)
         return cached;
-    const texture = textureLoader.load(textureConfig.url);
+    const texture = pickTextureLoader(textureConfig.url).load(textureConfig.url);
     texture.wrapS = THREE.RepeatWrapping;
     texture.wrapT = THREE.RepeatWrapping;
     const repeatX = textureConfig.repeat?.[0] ?? textureConfig.scale ?? 1;
     const repeatY = textureConfig.repeat?.[1] ?? textureConfig.scale ?? 1;
     texture.repeat.set(repeatX, repeatY);
+    texture.updateMatrix();
     texture.colorSpace = THREE.SRGBColorSpace;
     textureCache.set(cacheKey, texture);
     return texture;
 }
 function isStandardMaterial(material) {
-    return (material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshPhysicalMaterial);
+    return (material instanceof THREE.MeshStandardMaterial ||
+        material instanceof THREE.MeshPhysicalMaterial ||
+        material instanceof MeshStandardNodeMaterial);
+}
+function isCommonMaterial(material) {
+    return 'color' in material && material.color instanceof THREE.Color;
 }
 function applyTextureProperties(texture, props, slot) {
     texture.wrapS = wrapMap[props.wrapS];
@@ -67,43 +156,77 @@ function applyTextureProperties(texture, props, slot) {
     texture.repeat.set(props.repeatX, props.repeatY);
     texture.rotation = props.rotation;
     texture.flipY = props.flipY;
+    texture.updateMatrix();
+    texture.channel = getTextureChannel(slot);
     texture.colorSpace = SRGB_TEXTURE_SLOTS.includes(slot ?? 'map')
         ? THREE.SRGBColorSpace
         : THREE.NoColorSpace;
     texture.needsUpdate = true;
     return texture;
 }
+function setTextureCacheKey(texture, cacheKey) {
+    texture.userData.pascalTextureCacheKey = cacheKey;
+    return texture;
+}
 function getPresetTextureCacheKey(path, props, slot) {
     return `${path}-${props.repeatX}-${props.repeatY}-${props.rotation}-${props.wrapS}-${props.wrapT}-${props.flipY}-${slot ?? 'map'}`;
 }
 function getPresetTexture(path, props, slot) {
-    const cacheKey = getPresetTextureCacheKey(path, props, slot);
+    const resolvedPath = resolveCdnUrl(path) ?? path;
+    const cacheKey = getPresetTextureCacheKey(resolvedPath, props, slot);
     const cached = textureCache.get(cacheKey);
     if (cached)
         return cached;
-    const texture = textureLoader.load(path);
+    const texture = pickTextureLoader(resolvedPath).load(resolvedPath);
     applyTextureProperties(texture, props, slot);
+    setTextureCacheKey(texture, cacheKey);
     textureCache.set(cacheKey, texture);
     return texture;
 }
+function createAssignedTexture(source, props, slot) {
+    const texture = source.clone();
+    const cacheKey = source.userData.pascalTextureCacheKey;
+    if (typeof cacheKey === 'string') {
+        setTextureCacheKey(texture, cacheKey);
+    }
+    return applyTextureProperties(texture, props, slot);
+}
+function applyTexturePropertiesToMaterial(material, props) {
+    const slots = isStandardMaterial(material) ? TEXTURE_SLOTS : ['map'];
+    const textureMaterial = material;
+    for (const slot of slots) {
+        const texture = textureMaterial[slot];
+        if (!texture)
+            continue;
+        applyTextureProperties(texture, props, slot);
+    }
+}
 async function loadPresetTexture(path, props, slot) {
-    const cacheKey = getPresetTextureCacheKey(path, props, slot);
+    const resolvedPath = resolveCdnUrl(path) ?? path;
+    const cacheKey = getPresetTextureCacheKey(resolvedPath, props, slot);
     const cached = textureCache.get(cacheKey);
     if (cached)
         return cached;
     const existingPromise = textureLoadPromises.get(cacheKey);
     if (existingPromise)
         return existingPromise;
-    const promise = textureLoader
-        .loadAsync(path)
+    // `.ktx2` loads wait for `detectSupport` (KTX2Loader.load throws before it) —
+    // materials can be created while a capture canvas's renderer is still
+    // initializing, and failing here would cache the material permanently
+    // texture-less (white).
+    const load = isKtx2Url(resolvedPath)
+        ? whenKtx2Ready().then(() => ktx2Loader.loadAsync(resolvedPath))
+        : textureLoader.loadAsync(resolvedPath);
+    const promise = load
         .then((texture) => {
         applyTextureProperties(texture, props, slot);
+        setTextureCacheKey(texture, cacheKey);
         textureCache.set(cacheKey, texture);
         textureLoadPromises.delete(cacheKey);
         return texture;
     })
         .catch((error) => {
-        console.warn('[viewer] Failed to load material texture', path, error);
+        console.warn('[viewer] Failed to load material texture', resolvedPath, error);
         textureLoadPromises.delete(cacheKey);
         return null;
     });
@@ -111,48 +234,86 @@ async function loadPresetTexture(path, props, slot) {
     return promise;
 }
 function queueTextureAssignment(material, slot, path, props) {
+    const textureMaterial = material;
     if (!path) {
-        material[slot] = null;
+        textureMaterial[slot] = null;
+        return;
+    }
+    const resolvedPath = resolveCdnUrl(path) ?? path;
+    const cacheKey = getPresetTextureCacheKey(resolvedPath, props, slot);
+    if (textureMaterial[slot]?.userData.pascalTextureCacheKey === cacheKey) {
+        applyTextureProperties(textureMaterial[slot], props, slot);
         return;
     }
-    const cacheKey = getPresetTextureCacheKey(path, props, slot);
     const cached = textureCache.get(cacheKey);
     if (cached) {
-        material[slot] = cached;
+        textureMaterial[slot] = createAssignedTexture(cached, props, slot);
+        material.needsUpdate = true;
         return;
     }
-    material[slot] = null;
+    textureMaterial[slot] = null;
     loadPresetTexture(path, props, slot).then((texture) => {
         if (!texture)
             return;
-        material[slot] = texture;
+        textureMaterial[slot] = createAssignedTexture(texture, props, slot);
         material.needsUpdate = true;
     });
 }
 function applyMaterialMapProperties(material, mapProperties) {
     material.color.set(mapProperties.color);
-    material.roughness = mapProperties.roughness;
-    material.metalness = mapProperties.metalness;
-    material.emissiveIntensity = mapProperties.emissiveIntensity;
-    material.emissive.set(mapProperties.emissiveColor);
-    material.displacementScale = mapProperties.displacementScale;
-    material.bumpScale = mapProperties.bumpScale;
-    material.aoMapIntensity = mapProperties.aoMapIntensity;
-    material.lightMapIntensity = mapProperties.lightMapIntensity;
+    if (isStandardMaterial(material)) {
+        material.roughness = mapProperties.roughness;
+        material.metalness = mapProperties.metalness;
+        material.displacementScale = mapProperties.displacementScale;
+        material.bumpScale = mapProperties.bumpScale;
+        material.aoMapIntensity = mapProperties.aoMapIntensity;
+        material.lightMapIntensity = mapProperties.lightMapIntensity;
+        material.normalScale.set(mapProperties.normalScaleX, mapProperties.normalScaleY);
+    }
+    if (material.emissive) {
+        material.emissive.set(mapProperties.emissiveColor);
+    }
+    if ('emissiveIntensity' in material) {
+        material.emissiveIntensity = mapProperties.emissiveIntensity;
+    }
     material.transparent = mapProperties.transparent;
     material.opacity = mapProperties.opacity;
-    material.side =
-        mapProperties.side === 0
-            ? THREE.FrontSide
-            : mapProperties.side === 1
-                ? THREE.BackSide
-                : THREE.DoubleSide;
-    material.normalScale.set(mapProperties.normalScaleX, mapProperties.normalScaleY);
+    material.side = resolveNodeMaterialSide(mapProperties.side === 0
+        ? THREE.FrontSide
+        : mapProperties.side === 1
+            ? THREE.BackSide
+            : THREE.DoubleSide);
+    applyTexturePropertiesToMaterial(material, mapProperties);
     material.needsUpdate = true;
 }
+// Glass-like transparency threshold: any standard material authored as
+// `transparent` with opacity below this gets the fresnel treatment.
+const GLASS_OPACITY_THRESHOLD = 0.6;
+/**
+ * Fresnel-driven opacity for glass: nearly the authored opacity head-on,
+ * increasingly opaque (showing the environment reflection) at grazing angles.
+ * This is what makes glass read as a surface instead of a flat blue tint.
+ */
+function applyGlassFresnel(material) {
+    const facing = transformedNormalView.dot(positionViewDirection).clamp(0, 1);
+    const fresnel = facing.oneMinus().pow(3);
+    material.opacityNode = mix(float(material.opacity), float(0.92), fresnel);
+    material.envMapIntensity = 1.4;
+}
+function maybeApplyGlassFresnel(material) {
+    if (material instanceof MeshStandardNodeMaterial &&
+        material.transparent &&
+        material.opacity < GLASS_OPACITY_THRESHOLD) {
+        applyGlassFresnel(material);
+    }
+}
 function applyMaterialPresetTextures(material, preset) {
     const { maps, mapProperties } = preset;
     queueTextureAssignment(material, 'map', maps.albedoMap, mapProperties);
+    if (!isStandardMaterial(material)) {
+        material.needsUpdate = true;
+        return;
+    }
     queueTextureAssignment(material, 'normalMap', maps.normalMap, mapProperties);
     queueTextureAssignment(material, 'roughnessMap', maps.roughnessMap, mapProperties);
     queueTextureAssignment(material, 'metalnessMap', maps.metalnessMap, mapProperties);
@@ -167,7 +328,7 @@ function applyMaterialPresetTextures(material, preset) {
 export function applyMaterialPresetToMaterials(materialInput, preset) {
     if (!preset)
         return;
-    const materials = (Array.isArray(materialInput) ? materialInput : [materialInput]).filter(isStandardMaterial);
+    const materials = (Array.isArray(materialInput) ? materialInput : [materialInput]).filter(isCommonMaterial);
     if (materials.length === 0)
         return;
     for (const material of materials) {
@@ -175,63 +336,186 @@ export function applyMaterialPresetToMaterials(materialInput, preset) {
         applyMaterialPresetTextures(material, preset);
     }
 }
-export function createMaterialFromPreset(preset) {
-    const cacheKey = JSON.stringify(preset);
+export function createMaterialFromPreset(preset, shading = 'rendered') {
+    const cacheKey = `${shading}-${JSON.stringify(preset)}`;
     if (materialCache.has(cacheKey)) {
         return materialCache.get(cacheKey);
     }
-    const material = new THREE.MeshStandardMaterial();
+    const material = shading === 'solid' ? new MeshLambertNodeMaterial() : new MeshStandardNodeMaterial();
     applyMaterialPresetToMaterials(material, preset);
+    maybeApplyGlassFresnel(material);
+    material.userData.__pascalCachedMaterial = true;
     materialCache.set(cacheKey, material);
     return material;
 }
-export function createMaterialFromPresetRef(materialPreset) {
+export function createMaterialFromPresetRef(materialPreset, shading = 'rendered') {
     const preset = getMaterialPresetByRef(materialPreset);
     if (!preset)
         return null;
-    return createMaterialFromPreset(preset);
+    return createMaterialFromPreset(preset, shading);
 }
-export function createMaterial(material) {
+export function createMaterial(material, shading = 'rendered') {
     const props = resolveMaterial(material);
-    const cacheKey = `${getCacheKey(props)}-${getTextureKey(material)}`;
+    const cacheKey = `${getCacheKey(props, shading)}-${getTextureKey(material)}`;
     if (materialCache.has(cacheKey)) {
         return materialCache.get(cacheKey);
     }
     const map = getTexture(material);
-    const threeMaterial = new THREE.MeshStandardMaterial({
+    const materialParams = {
         color: props.color,
-        roughness: props.roughness,
-        metalness: props.metalness,
         opacity: props.opacity,
         transparent: props.transparent,
         side: sideMap[props.side],
-        map,
-    });
+    };
+    if (map)
+        materialParams.map = map;
+    const threeMaterial = shading === 'solid'
+        ? new MeshLambertNodeMaterial(materialParams)
+        : new MeshStandardNodeMaterial({
+            ...materialParams,
+            roughness: props.roughness,
+            metalness: props.metalness,
+        });
+    maybeApplyGlassFresnel(threeMaterial);
+    threeMaterial.userData.__pascalCachedMaterial = true;
     materialCache.set(cacheKey, threeMaterial);
     return threeMaterial;
 }
-export function createDefaultMaterial(color = '#ffffff', roughness = 0.9) {
-    return new THREE.MeshStandardMaterial({
+/**
+ * Resolve a MaterialRef ('library:<id>' | 'scene:<id>') to a three.js material.
+ * Returns null for an unknown / dangling ref so callers fall back to the
+ * slot's default (authored material, then themed default). Never throws.
+ */
+export function resolveMaterialRef(ref, sceneMaterials, shading = 'rendered') {
+    const parsed = parseMaterialRef(ref);
+    if (!parsed)
+        return null;
+    if (parsed.kind === 'library')
+        return createMaterialFromPresetRef(ref, shading);
+    const sceneMaterial = sceneMaterials?.[parsed.id];
+    if (!sceneMaterial)
+        return null;
+    return createMaterial(sceneMaterial.material, shading);
+}
+/**
+ * Resolve a node kind's declared slot default — either a catalog `library:<id>`
+ * finish or a flat `#rrggbb` colour — to a renderable material. Shared by the
+ * procedural kinds whose colored-mode unpainted appearance comes from a
+ * declarative default (slab, wall).
+ */
+export function resolveSlotDefaultMaterial(slotDefault, shading = 'rendered', roughness = 0.9) {
+    if (parseMaterialRef(slotDefault)?.kind === 'library') {
+        return (createMaterialFromPresetRef(slotDefault, shading) ??
+            createDefaultMaterial('#ffffff', roughness, shading));
+    }
+    return createDefaultMaterial(slotDefault, roughness, shading);
+}
+export function createDefaultMaterial(color = '#ffffff', roughness = 0.9, shading = 'rendered', side = THREE.FrontSide) {
+    const resolvedSide = resolveNodeMaterialSide(side);
+    if (shading === 'solid') {
+        return new MeshLambertNodeMaterial({
+            color,
+            side: resolvedSide,
+        });
+    }
+    return new MeshStandardNodeMaterial({
         color,
         roughness,
         metalness: 0,
-        side: THREE.FrontSide,
+        side: resolvedSide,
     });
 }
-export const DEFAULT_WALL_MATERIAL = createDefaultMaterial('#ffffff', 0.9);
-export const DEFAULT_SLAB_MATERIAL = createDefaultMaterial('#e5e5e5', 0.8);
-export const DEFAULT_DOOR_MATERIAL = createDefaultMaterial('#8b4513', 0.7);
-export const DEFAULT_WINDOW_MATERIAL = new THREE.MeshStandardMaterial({
-    color: '#87ceeb',
-    roughness: 0.1,
-    metalness: 0.1,
-    opacity: 0.3,
-    transparent: true,
-    side: THREE.DoubleSide,
-});
-export const DEFAULT_CEILING_MATERIAL = createDefaultMaterial('#f5f5dc', 0.95);
-export const DEFAULT_ROOF_MATERIAL = createDefaultMaterial('#808080', 0.85);
-export const DEFAULT_STAIR_MATERIAL = createDefaultMaterial('#ffffff', 0.9);
+function cachedDefaultMaterial(key, color, roughness, shading, side = THREE.FrontSide) {
+    const cacheKey = `${key}-${shading}`;
+    const cached = defaultMaterialCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const material = createDefaultMaterial(color, roughness, shading, side);
+    material.userData.__pascalCachedMaterial = true;
+    defaultMaterialCache.set(cacheKey, material);
+    return material;
+}
+export function createSurfaceRoleMaterial(role, preset, side = THREE.FrontSide, sceneThemeId) {
+    // DoubleSide on glazing trips the MRT back-face pipeline issue documented
+    // on `glassMaterial` above — the validator rejects the back-face variant
+    // for missing MRT outputs and poisons the render context (manifests as
+    // "Color target has no corresponding fragment stage output" on scene
+    // open, since the dormer's window-assembly mounts the glazing material
+    // on both gable faces on the first frame). Callers that need both sides
+    // visible (e.g. dormer back gable) must rotate the host mesh 180° so the
+    // FrontSide faces the viewer.
+    const resolvedSide = role === 'glazing' ? THREE.FrontSide : resolveNodeMaterialSide(side ?? THREE.FrontSide);
+    const cacheKey = `${role}-${preset}-${resolvedSide}-${sceneThemeId ?? 'base'}`;
+    const cached = surfaceRoleMaterialCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const material = role === 'glazing'
+        ? new MeshLambertNodeMaterial({
+            color: resolveSurfaceColor(role, preset, sceneThemeId),
+            depthWrite: false,
+            opacity: 0.25,
+            side: resolvedSide,
+            transparent: true,
+        })
+        : new MeshLambertNodeMaterial({
+            color: resolveSurfaceColor(role, preset, sceneThemeId),
+            side: resolvedSide,
+        });
+    material.userData.__pascalCachedMaterial = true;
+    surfaceRoleMaterialCache.set(cacheKey, material);
+    return material;
+}
+export function baseMaterial(shading = 'rendered') {
+    return cachedDefaultMaterial('base', '#e9e7e3', 0.5, shading);
+}
+export function DEFAULT_WALL_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('wall', '#e9e6e0', 0.9, shading);
+}
+export function DEFAULT_SLAB_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('slab', '#e5e5e5', 0.8, shading);
+}
+export function DEFAULT_DOOR_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('door', '#8b4513', 0.7, shading);
+}
+export function DEFAULT_WINDOW_MATERIAL(shading = 'rendered') {
+    const cacheKey = `window-${shading}`;
+    const cached = defaultMaterialCache.get(cacheKey);
+    if (cached)
+        return cached;
+    // DoubleSide on a NodeMaterial inside the MRT scene pass compiles a back-face
+    // pipeline variant whose fragment outputs don't cover every MRT target — the
+    // validator rejects it and poisons the render context (see the note above
+    // `glassMaterial`). FrontSide; flip the consumer's back-face group 180° if a
+    // back face is actually visible.
+    const params = {
+        color: '#87ceeb',
+        opacity: 0.3,
+        transparent: true,
+        side: THREE.FrontSide,
+    };
+    const material = shading === 'solid'
+        ? new MeshLambertNodeMaterial(params)
+        : new MeshStandardNodeMaterial({
+            ...params,
+            roughness: 0.1,
+            metalness: 0.1,
+        });
+    maybeApplyGlassFresnel(material);
+    defaultMaterialCache.set(cacheKey, material);
+    return material;
+}
+export function DEFAULT_CEILING_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('ceiling', '#ebebd3', 0.95, shading);
+}
+export function DEFAULT_ROOF_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('roof', '#808080', 0.85, shading);
+}
+export function DEFAULT_SHELF_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('shelf', '#e9e6e0', 0.9, shading);
+}
+export function DEFAULT_STAIR_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('stair', '#e9e6e0', 0.9, shading);
+}
 export function disposeMaterial(material) {
     material.dispose();
 }
@@ -240,6 +524,14 @@ export function clearMaterialCache() {
         material.dispose();
     }
     materialCache.clear();
+    for (const material of defaultMaterialCache.values()) {
+        material.dispose();
+    }
+    defaultMaterialCache.clear();
+    for (const material of surfaceRoleMaterialCache.values()) {
+        material.dispose();
+    }
+    surfaceRoleMaterialCache.clear();
     for (const texture of textureCache.values()) {
         texture.dispose();
     }

package/dist/lib/merged-outline-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merged-outline-node.d.ts","sourceRoot":"","sources":["../../src/lib/merged-outline-node.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"merged-outline-node.d.ts","sourceRoot":"","sources":["../../src/lib/merged-outline-node.ts"],"names":[],"mappings":"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"}

package/dist/lib/merged-outline-node.js

@@ -17,6 +17,7 @@
 import { DepthTexture, FloatType, RenderTarget, Vector2 } from 'three';
 import { color, exp, Fn, float, int, Loop, min, mul, nodeObject, orthographicDepthToViewZ, passTexture, perspectiveDepthToViewZ, positionView, reference, screenUV, texture, textureSize, uniform, uv, vec2, vec3, vec4, } from 'three/tsl';
 import { NodeMaterial, NodeUpdateType, QuadMesh, RendererUtils, SpriteNodeMaterial, TempNode, } from 'three/webgpu';
+import { hasDrawableGeometry } from './drawable-geometry';
 const _quadMesh = new QuadMesh();
 const _size = new Vector2();
 const _BLUR_X = new Vector2(1.0, 0.0);
@@ -262,6 +263,8 @@ export class MergedOutlineNode extends TempNode {
         // ── 1. Shared depth pass: all objects NOT in either group ─────────────────
         renderer.setRenderTarget(this._depthRT);
         renderer.setRenderObjectFunction((obj, sc, cam, geo, _mat, grp, lights, clip) => {
+            if (!hasDrawableGeometry(geo))
+                return;
             const inCache = this._cacheA.has(obj) || this._cacheB.has(obj);
             if (!inCache) {
                 const m = obj.isSprite ? this._depthSpriteMaterial : this._depthMaterial;
@@ -274,6 +277,8 @@ export class MergedOutlineNode extends TempNode {
         if (hasPrimary) {
             renderer.setRenderTarget(this._groupA.maskBuffer);
             renderer.setRenderObjectFunction((obj, sc, cam, geo, _mat, grp, lights, clip) => {
+                if (!hasDrawableGeometry(geo))
+                    return;
                 if (this._cacheA.has(obj)) {
                     const m = obj.isSprite ? this._prepareMaskSpriteMatA : this._prepareMaskMatA;
                     renderer.renderObject(obj, sc, cam, geo, m, grp, lights, clip);
@@ -286,6 +291,8 @@ export class MergedOutlineNode extends TempNode {
         if (hasSecondary) {
             renderer.setRenderTarget(this._groupB.maskBuffer);
             renderer.setRenderObjectFunction((obj, sc, cam, geo, _mat, grp, lights, clip) => {
+                if (!hasDrawableGeometry(geo))
+                    return;
                 if (this._cacheB.has(obj)) {
                     const m = obj.isSprite ? this._prepareMaskSpriteMatB : this._prepareMaskMatB;
                     renderer.renderObject(obj, sc, cam, geo, m, grp, lights, clip);

package/dist/lib/polygon-union.d.ts

@@ -0,0 +1,4 @@
+export type Point2D = [number, number];
+export declare function unionPolygons(polygons: Point2D[][]): Point2D[][];
+export declare function subtractPolygonsFromPolygon(subject: Point2D[], cutters: Point2D[][]): Point2D[][];
+//# sourceMappingURL=polygon-union.d.ts.map

package/dist/lib/polygon-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-union.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-union.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAwStC,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAShE;AA4CD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAkBjG"}