@pascal-app/viewer 0.7.0 → 0.9.1

package/dist/lib/materials.js

@@ -1,18 +1,66 @@
 import { getMaterialPresetByRef, 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 { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+import { resolveCdnUrl } from './asset-url';
+import { getSceneTheme } from './scene-themes';
+export const CLAY_PALETTE = {
+    wall: '#dcd6c7',
+    floor: '#cfc8b6',
+    ceiling: '#e4ded0',
+    roof: '#b8ad96',
+    joinery: '#c4bba6',
+    glazing: '#c8d4dc',
+    furnishing: '#d2ccbe',
+};
+export const WHITE_PALETTE = {
+    wall: '#f4f3ef',
+    floor: '#ece9e2',
+    ceiling: '#fbfaf6',
+    roof: '#dedbd2',
+    joinery: '#e8e5dc',
+    glazing: '#dbe8ee',
+    furnishing: '#efede7',
+};
+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][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,
 });
 const sideMap = {
     front: THREE.FrontSide,
@@ -20,6 +68,8 @@ const sideMap = {
     double: THREE.DoubleSide,
 };
 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();
@@ -29,8 +79,26 @@ const wrapMap = {
     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;
@@ -54,13 +122,18 @@ function getTexture(material) {
     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);
+        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];
@@ -68,27 +141,54 @@ 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 = textureLoader.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;
@@ -96,15 +196,16 @@ async function loadPresetTexture(path, props, slot) {
     if (existingPromise)
         return existingPromise;
     const promise = textureLoader
-        .loadAsync(path)
+        .loadAsync(resolvedPath)
         .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;
     });
@@ -112,34 +213,48 @@ 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;
-    void loadPresetTexture(path, props, slot).then((texture) => {
+    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 =
@@ -148,12 +263,16 @@ function applyMaterialMapProperties(material, mapProperties) {
             : mapProperties.side === 1
                 ? THREE.BackSide
                 : THREE.DoubleSide;
-    material.normalScale.set(mapProperties.normalScaleX, mapProperties.normalScaleY);
+    applyTexturePropertiesToMaterial(material, mapProperties);
     material.needsUpdate = true;
 }
 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);
@@ -168,7 +287,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) {
@@ -176,63 +295,150 @@ 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);
     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,
+        });
     materialCache.set(cacheKey, threeMaterial);
     return threeMaterial;
 }
-export function createDefaultMaterial(color = '#ffffff', roughness = 0.9) {
-    return new THREE.MeshStandardMaterial({
+export function createDefaultMaterial(color = '#ffffff', roughness = 0.9, shading = 'rendered', side = THREE.FrontSide) {
+    if (shading === 'solid') {
+        return new MeshLambertNodeMaterial({
+            color,
+            side,
+        });
+    }
+    return new MeshStandardNodeMaterial({
         color,
         roughness,
         metalness: 0,
-        side: THREE.FrontSide,
+        side,
     });
 }
-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);
+    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 : side;
+    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', '#f2f0ed', 0.5, shading);
+}
+export function DEFAULT_WALL_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('wall', '#ffffff', 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,
+        });
+    defaultMaterialCache.set(cacheKey, material);
+    return material;
+}
+export function DEFAULT_CEILING_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('ceiling', '#f5f5dc', 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', '#ffffff', 0.9, shading);
+}
+export function DEFAULT_STAIR_MATERIAL(shading = 'rendered') {
+    return cachedDefaultMaterial('stair', '#ffffff', 0.9, shading);
+}
 export function disposeMaterial(material) {
     material.dispose();
 }
@@ -241,6 +447,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);
@@ -460,17 +467,10 @@ export class MergedOutlineNode extends TempNode {
     }
     _buildCache(objects, cache) {
         for (const obj of objects) {
-            if (!obj || !obj.traverse)
-                continue;
-            try {
-                obj.traverse((child) => {
-                    if (child.isMesh || child.isSprite)
-                        cache.add(child);
-                });
-            }
-            catch {
-                // Skip objects that were disposed or removed from the scene graph
-            }
+            obj.traverse((child) => {
+                if (child.isMesh || child.isSprite)
+                    cache.add(child);
+            });
         }
     }
 }

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"}