@pascal-app/viewer 0.3.3 → 0.4.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAChF,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,cAAc,EACd,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,GAChB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AAC5E,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAA;AAC9E,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAChF,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,cAAc,EACd,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,GAChB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AACzD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AAC5E,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA"}

package/dist/index.js

@@ -1,8 +1,9 @@
 export { default as Viewer } from './components/viewer';
+export { WalkthroughControls } from './components/viewer/walkthrough-controls';
 export { ASSETS_CDN_URL, resolveAssetUrl, resolveCdnUrl } from './lib/asset-url';
 export { SCENE_LAYER, ZONE_LAYER } from './lib/layers';
 export { clearMaterialCache, createDefaultMaterial, createMaterial, DEFAULT_CEILING_MATERIAL, DEFAULT_DOOR_MATERIAL, DEFAULT_ROOF_MATERIAL, DEFAULT_SLAB_MATERIAL, DEFAULT_WALL_MATERIAL, DEFAULT_WINDOW_MATERIAL, disposeMaterial, } from './lib/materials';
+export { mergedOutline } from './lib/merged-outline-node';
 export { default as useViewer } from './store/use-viewer';
-export { ExportSystem } from './systems/export/export-system';
 export { InteractiveSystem } from './systems/interactive/interactive-system';
 export { snapLevelsToTruePositions } from './systems/level/level-utils';

package/dist/lib/materials.d.ts

@@ -8,6 +8,7 @@ export declare const DEFAULT_DOOR_MATERIAL: THREE.MeshStandardMaterial;
 export declare const DEFAULT_WINDOW_MATERIAL: THREE.MeshStandardMaterial;
 export declare const DEFAULT_CEILING_MATERIAL: THREE.MeshStandardMaterial;
 export declare const DEFAULT_ROOF_MATERIAL: THREE.MeshStandardMaterial;
+export declare const DEFAULT_STAIR_MATERIAL: THREE.MeshStandardMaterial;
 export declare function disposeMaterial(material: THREE.Material): void;
 export declare function clearMaterialCache(): void;
 //# sourceMappingURL=materials.d.ts.map

package/dist/lib/materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/lib/materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,cAAc,EAAmB,MAAM,kBAAkB,CAAA;AAChG,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAc9B,wBAAgB,cAAc,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,KAAK,CAAC,oBAAoB,CAmBpF;AAED,wBAAgB,qBAAqB,CACnC,KAAK,GAAE,MAAkB,EACzB,SAAS,GAAE,MAAY,GACtB,KAAK,CAAC,oBAAoB,CAO5B;AAED,eAAO,MAAM,qBAAqB,4BAAwC,CAAA;AAC1E,eAAO,MAAM,qBAAqB,4BAAwC,CAAA;AAC1E,eAAO,MAAM,qBAAqB,4BAAwC,CAAA;AAC1E,eAAO,MAAM,uBAAuB,4BAOlC,CAAA;AACF,eAAO,MAAM,wBAAwB,4BAAyC,CAAA;AAC9E,eAAO,MAAM,qBAAqB,4BAAyC,CAAA;AAE3E,wBAAgB,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE9D;AAED,wBAAgB,kBAAkB,IAAI,IAAI,CAKzC"}
+{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/lib/materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,cAAc,EAAmB,MAAM,kBAAkB,CAAA;AAChG,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAc9B,wBAAgB,cAAc,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,KAAK,CAAC,oBAAoB,CAmBpF;AAED,wBAAgB,qBAAqB,CACnC,KAAK,SAAY,EACjB,SAAS,SAAM,GACd,KAAK,CAAC,oBAAoB,CAO5B;AAED,eAAO,MAAM,qBAAqB,4BAAwC,CAAA;AAC1E,eAAO,MAAM,qBAAqB,4BAAwC,CAAA;AAC1E,eAAO,MAAM,qBAAqB,4BAAwC,CAAA;AAC1E,eAAO,MAAM,uBAAuB,4BAOlC,CAAA;AACF,eAAO,MAAM,wBAAwB,4BAAyC,CAAA;AAC9E,eAAO,MAAM,qBAAqB,4BAAyC,CAAA;AAC3E,eAAO,MAAM,sBAAsB,4BAAwC,CAAA;AAE3E,wBAAgB,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE9D;AAED,wBAAgB,kBAAkB,IAAI,IAAI,CAKzC"}

package/dist/lib/materials.js

@@ -47,6 +47,7 @@ export const DEFAULT_WINDOW_MATERIAL = new THREE.MeshStandardMaterial({
 });
 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);
 export function disposeMaterial(material) {
     material.dispose();
 }

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

@@ -0,0 +1,88 @@
+/**
+ * MergedOutlineNode — a fork of Three.js OutlineNode that processes two object
+ * groups (primary = selected, secondary = hovered) in a single pass, sharing the
+ * expensive non-selected depth pre-render between both groups.
+ *
+ * Cost comparison vs two separate OutlineNode instances:
+ *   Before: depth_A + mask_A + edge_A×6 + depth_B + mask_B + edge_B×6 = 2 depth passes
+ *   After:  depth_AB (shared) + mask_A + edge_A×6 + mask_B + edge_B×6 = 1 depth pass
+ *
+ * Additional early-outs:
+ *   - Both empty       → skip everything (0 passes)
+ *   - Only primary     → skip secondary mask/edge/blur
+ *   - Only secondary   → skip primary mask/edge/blur
+ */
+import { type Object3D } from 'three';
+import { TempNode } from 'three/webgpu';
+export declare class MergedOutlineNode extends TempNode {
+    static get type(): string;
+    scene: any;
+    camera: any;
+    primaryObjects: Object3D[];
+    secondaryObjects: Object3D[];
+    primaryEdgeThicknessNode: any;
+    secondaryEdgeThicknessNode: any;
+    primaryEdgeGlowNode: any;
+    secondaryEdgeGlowNode: any;
+    downSampleRatio: number;
+    updateBeforeType: string;
+    private readonly _depthRT;
+    private readonly _depthTexUniform;
+    private readonly _groupA;
+    private readonly _groupB;
+    private readonly _maskTexA;
+    private readonly _maskDownTexA;
+    private readonly _edge1TexA;
+    private readonly _edge2TexA;
+    private readonly _blurColorTexA;
+    private readonly _maskTexB;
+    private readonly _maskDownTexB;
+    private readonly _edge1TexB;
+    private readonly _edge2TexB;
+    private readonly _blurColorTexB;
+    private readonly _blurDirectionA;
+    private readonly _blurDirectionB;
+    private readonly _cameraNear;
+    private readonly _cameraFar;
+    private readonly _depthMaterial;
+    private readonly _depthSpriteMaterial;
+    private readonly _prepareMaskMatA;
+    private readonly _prepareMaskSpriteMatA;
+    private readonly _copyMatA;
+    private readonly _edgeDetectMatA;
+    private readonly _blurMat1A;
+    private readonly _blurMat2A;
+    private readonly _compositeMatA;
+    private readonly _prepareMaskMatB;
+    private readonly _prepareMaskSpriteMatB;
+    private readonly _copyMatB;
+    private readonly _edgeDetectMatB;
+    private readonly _blurMat1B;
+    private readonly _blurMat2B;
+    private readonly _compositeMatB;
+    private readonly _cacheA;
+    private readonly _cacheB;
+    private readonly _textureNodeA;
+    private readonly _textureNodeB;
+    constructor(scene: any, camera: any, params?: {
+        primaryObjects?: Object3D[];
+        secondaryObjects?: Object3D[];
+        primaryEdgeThickness?: any;
+        secondaryEdgeThickness?: any;
+        primaryEdgeGlow?: any;
+        secondaryEdgeGlow?: any;
+        downSampleRatio?: number;
+    });
+    get primaryVisibleEdge(): any;
+    get primaryHiddenEdge(): any;
+    get secondaryVisibleEdge(): any;
+    get secondaryHiddenEdge(): any;
+    setSize(width: number, height: number): void;
+    updateBefore(frame: any): void;
+    private _runEdgePipeline;
+    setup(_builder: any): any;
+    dispose(): void;
+    private _buildCache;
+}
+export declare const mergedOutline: (scene: any, camera: any, params?: ConstructorParameters<typeof MergedOutlineNode>[2]) => MergedOutlineNode;
+//# sourceMappingURL=merged-outline-node.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,450 @@
+// @ts-nocheck — Three.js TSL/WebGPU internal APIs have incomplete type definitions;
+// this file is a fork of OutlineNode and is intentionally exempt from strict TS checking.
+/**
+ * MergedOutlineNode — a fork of Three.js OutlineNode that processes two object
+ * groups (primary = selected, secondary = hovered) in a single pass, sharing the
+ * expensive non-selected depth pre-render between both groups.
+ *
+ * Cost comparison vs two separate OutlineNode instances:
+ *   Before: depth_A + mask_A + edge_A×6 + depth_B + mask_B + edge_B×6 = 2 depth passes
+ *   After:  depth_AB (shared) + mask_A + edge_A×6 + mask_B + edge_B×6 = 1 depth pass
+ *
+ * Additional early-outs:
+ *   - Both empty       → skip everything (0 passes)
+ *   - Only primary     → skip secondary mask/edge/blur
+ *   - Only secondary   → skip primary mask/edge/blur
+ */
+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';
+const _quadMesh = new QuadMesh();
+const _size = new Vector2();
+const _BLUR_X = new Vector2(1.0, 0.0);
+const _BLUR_Y = new Vector2(0.0, 1.0);
+let _rendererState; // eslint-disable-line @typescript-eslint/no-explicit-any
+// ---------------------------------------------------------------------------
+// Helper: render targets for one outline group
+// ---------------------------------------------------------------------------
+function makeGroupTargets(downSampleRatio) {
+    const maskBuffer = new RenderTarget();
+    const maskDownSample = new RenderTarget(1, 1, { depthBuffer: false });
+    const edgeBuffer1 = new RenderTarget(1, 1, { depthBuffer: false });
+    const edgeBuffer2 = new RenderTarget(1, 1, { depthBuffer: false });
+    const blurBuffer1 = new RenderTarget(1, 1, { depthBuffer: false });
+    const blurBuffer2 = new RenderTarget(1, 1, { depthBuffer: false });
+    const composite = new RenderTarget(1, 1, { depthBuffer: false });
+    function setSize(w, h) {
+        maskBuffer.setSize(w, h);
+        composite.setSize(w, h);
+        let rx = Math.round(w / downSampleRatio);
+        let ry = Math.round(h / downSampleRatio);
+        maskDownSample.setSize(rx, ry);
+        edgeBuffer1.setSize(rx, ry);
+        blurBuffer1.setSize(rx, ry);
+        rx = Math.round(rx / 2);
+        ry = Math.round(ry / 2);
+        edgeBuffer2.setSize(rx, ry);
+        blurBuffer2.setSize(rx, ry);
+    }
+    function dispose() {
+        maskBuffer.dispose();
+        maskDownSample.dispose();
+        edgeBuffer1.dispose();
+        edgeBuffer2.dispose();
+        blurBuffer1.dispose();
+        blurBuffer2.dispose();
+        composite.dispose();
+    }
+    return {
+        maskBuffer,
+        maskDownSample,
+        edgeBuffer1,
+        edgeBuffer2,
+        blurBuffer1,
+        blurBuffer2,
+        composite,
+        setSize,
+        dispose,
+    };
+}
+// ---------------------------------------------------------------------------
+// MergedOutlineNode
+// ---------------------------------------------------------------------------
+export class MergedOutlineNode extends TempNode {
+    static get type() {
+        return 'MergedOutlineNode';
+    }
+    scene;
+    camera;
+    primaryObjects;
+    secondaryObjects;
+    primaryEdgeThicknessNode;
+    secondaryEdgeThicknessNode;
+    primaryEdgeGlowNode;
+    secondaryEdgeGlowNode;
+    downSampleRatio;
+    updateBeforeType;
+    _depthRT;
+    _depthTexUniform;
+    _groupA;
+    _groupB;
+    _maskTexA;
+    _maskDownTexA;
+    _edge1TexA;
+    _edge2TexA;
+    _blurColorTexA;
+    _maskTexB;
+    _maskDownTexB;
+    _edge1TexB;
+    _edge2TexB;
+    _blurColorTexB;
+    _blurDirectionA;
+    _blurDirectionB;
+    _cameraNear;
+    _cameraFar;
+    _depthMaterial;
+    _depthSpriteMaterial;
+    _prepareMaskMatA;
+    _prepareMaskSpriteMatA;
+    _copyMatA;
+    _edgeDetectMatA;
+    _blurMat1A;
+    _blurMat2A;
+    _compositeMatA;
+    _prepareMaskMatB;
+    _prepareMaskSpriteMatB;
+    _copyMatB;
+    _edgeDetectMatB;
+    _blurMat1B;
+    _blurMat2B;
+    _compositeMatB;
+    _cacheA = new Set();
+    _cacheB = new Set();
+    _textureNodeA;
+    _textureNodeB;
+    constructor(scene, camera, params = {}) {
+        super('vec4');
+        const { primaryObjects = [], secondaryObjects = [], primaryEdgeThickness = float(1), secondaryEdgeThickness = float(1), primaryEdgeGlow = float(0), secondaryEdgeGlow = float(0), downSampleRatio = 2, } = params;
+        this.scene = scene;
+        this.camera = camera;
+        this.primaryObjects = primaryObjects;
+        this.secondaryObjects = secondaryObjects;
+        this.primaryEdgeThicknessNode = nodeObject(primaryEdgeThickness);
+        this.secondaryEdgeThicknessNode = nodeObject(secondaryEdgeThickness);
+        this.primaryEdgeGlowNode = nodeObject(primaryEdgeGlow);
+        this.secondaryEdgeGlowNode = nodeObject(secondaryEdgeGlow);
+        this.downSampleRatio = downSampleRatio;
+        this.updateBeforeType = NodeUpdateType.FRAME;
+        this._depthRT = new RenderTarget();
+        this._depthRT.depthTexture = new DepthTexture();
+        this._depthRT.depthTexture.type = FloatType;
+        this._groupA = makeGroupTargets(downSampleRatio);
+        this._groupB = makeGroupTargets(downSampleRatio);
+        this._cameraNear = reference('near', 'float', camera);
+        this._cameraFar = reference('far', 'float', camera);
+        this._blurDirectionA = uniform(new Vector2());
+        this._blurDirectionB = uniform(new Vector2());
+        this._depthTexUniform = texture(this._depthRT.depthTexture);
+        this._maskTexA = texture(this._groupA.maskBuffer.texture);
+        this._maskDownTexA = texture(this._groupA.maskDownSample.texture);
+        this._edge1TexA = texture(this._groupA.edgeBuffer1.texture);
+        this._edge2TexA = texture(this._groupA.edgeBuffer2.texture);
+        this._blurColorTexA = texture(this._groupA.edgeBuffer1.texture);
+        this._maskTexB = texture(this._groupB.maskBuffer.texture);
+        this._maskDownTexB = texture(this._groupB.maskDownSample.texture);
+        this._edge1TexB = texture(this._groupB.edgeBuffer1.texture);
+        this._edge2TexB = texture(this._groupB.edgeBuffer2.texture);
+        this._blurColorTexB = texture(this._groupB.edgeBuffer1.texture);
+        this._depthMaterial = new NodeMaterial();
+        this._depthMaterial.colorNode = color(0, 0, 0);
+        this._depthMaterial.name = 'MergedOutline.depth';
+        this._depthSpriteMaterial = new SpriteNodeMaterial();
+        this._depthSpriteMaterial.colorNode = color(0, 0, 0);
+        this._depthSpriteMaterial.name = 'MergedOutline.depthSprite';
+        this._prepareMaskMatA = new NodeMaterial();
+        this._prepareMaskMatA.name = 'MergedOutline.maskA';
+        this._prepareMaskSpriteMatA = new SpriteNodeMaterial();
+        this._prepareMaskSpriteMatA.name = 'MergedOutline.maskSpriteA';
+        this._copyMatA = new NodeMaterial();
+        this._copyMatA.name = 'MergedOutline.copyA';
+        this._edgeDetectMatA = new NodeMaterial();
+        this._edgeDetectMatA.name = 'MergedOutline.edgeA';
+        this._blurMat1A = new NodeMaterial();
+        this._blurMat1A.name = 'MergedOutline.blur1A';
+        this._blurMat2A = new NodeMaterial();
+        this._blurMat2A.name = 'MergedOutline.blur2A';
+        this._compositeMatA = new NodeMaterial();
+        this._compositeMatA.name = 'MergedOutline.compositeA';
+        this._prepareMaskMatB = new NodeMaterial();
+        this._prepareMaskMatB.name = 'MergedOutline.maskB';
+        this._prepareMaskSpriteMatB = new SpriteNodeMaterial();
+        this._prepareMaskSpriteMatB.name = 'MergedOutline.maskSpriteB';
+        this._copyMatB = new NodeMaterial();
+        this._copyMatB.name = 'MergedOutline.copyB';
+        this._edgeDetectMatB = new NodeMaterial();
+        this._edgeDetectMatB.name = 'MergedOutline.edgeB';
+        this._blurMat1B = new NodeMaterial();
+        this._blurMat1B.name = 'MergedOutline.blur1B';
+        this._blurMat2B = new NodeMaterial();
+        this._blurMat2B.name = 'MergedOutline.blur2B';
+        this._compositeMatB = new NodeMaterial();
+        this._compositeMatB.name = 'MergedOutline.compositeB';
+        // Output: R = visibleEdge, G = hiddenEdge
+        this._textureNodeA = passTexture(this, this._groupA.composite.texture);
+        this._textureNodeB = passTexture(this, this._groupB.composite.texture);
+    }
+    get primaryVisibleEdge() {
+        return this._textureNodeA.r;
+    }
+    get primaryHiddenEdge() {
+        return this._textureNodeA.g;
+    }
+    get secondaryVisibleEdge() {
+        return this._textureNodeB.r;
+    }
+    get secondaryHiddenEdge() {
+        return this._textureNodeB.g;
+    }
+    setSize(width, height) {
+        this._depthRT.setSize(width, height);
+        this._groupA.setSize(width, height);
+        this._groupB.setSize(width, height);
+    }
+    updateBefore(frame) {
+        const hasPrimary = this.primaryObjects.length > 0;
+        const hasSecondary = this.secondaryObjects.length > 0;
+        const { renderer } = frame;
+        const { camera, scene } = this;
+        _rendererState = RendererUtils.resetRendererAndSceneState(renderer, scene, _rendererState);
+        const size = renderer.getDrawingBufferSize(_size);
+        this.setSize(size.width, size.height);
+        // Clear composites for inactive groups so stale outlines don't persist on GPU.
+        // Must happen inside resetRendererAndSceneState to avoid MSAA state corruption.
+        if (!hasPrimary) {
+            renderer.setRenderTarget(this._groupA.composite);
+            renderer.clearColor();
+        }
+        if (!hasSecondary) {
+            renderer.setRenderTarget(this._groupB.composite);
+            renderer.clearColor();
+        }
+        const hasAny = hasPrimary || hasSecondary;
+        if (!hasAny) {
+            RendererUtils.restoreRendererAndSceneState(renderer, scene, _rendererState);
+            return;
+        }
+        renderer.setClearColor(0xff_ff_ff, 1);
+        if (hasPrimary)
+            this._buildCache(this.primaryObjects, this._cacheA);
+        if (hasSecondary)
+            this._buildCache(this.secondaryObjects, this._cacheB);
+        const savedName = scene.name;
+        // ── 1. Shared depth pass: all objects NOT in either group ─────────────────
+        renderer.setRenderTarget(this._depthRT);
+        renderer.setRenderObjectFunction((obj, sc, cam, geo, _mat, grp, lights, clip) => {
+            const inCache = this._cacheA.has(obj) || this._cacheB.has(obj);
+            if (!inCache) {
+                const m = obj.isSprite ? this._depthSpriteMaterial : this._depthMaterial;
+                renderer.renderObject(obj, sc, cam, geo, m, grp, lights, clip);
+            }
+        });
+        scene.name = 'MergedOutline [ Depth ]';
+        renderer.render(scene, camera);
+        // ── 2a. Primary mask pass ─────────────────────────────────────────────────
+        if (hasPrimary) {
+            renderer.setRenderTarget(this._groupA.maskBuffer);
+            renderer.setRenderObjectFunction((obj, sc, cam, geo, _mat, grp, lights, clip) => {
+                if (this._cacheA.has(obj)) {
+                    const m = obj.isSprite ? this._prepareMaskSpriteMatA : this._prepareMaskMatA;
+                    renderer.renderObject(obj, sc, cam, geo, m, grp, lights, clip);
+                }
+            });
+            scene.name = 'MergedOutline [ Mask A ]';
+            renderer.render(scene, camera);
+        }
+        // ── 2b. Secondary mask pass ───────────────────────────────────────────────
+        if (hasSecondary) {
+            renderer.setRenderTarget(this._groupB.maskBuffer);
+            renderer.setRenderObjectFunction((obj, sc, cam, geo, _mat, grp, lights, clip) => {
+                if (this._cacheB.has(obj)) {
+                    const m = obj.isSprite ? this._prepareMaskSpriteMatB : this._prepareMaskMatB;
+                    renderer.renderObject(obj, sc, cam, geo, m, grp, lights, clip);
+                }
+            });
+            scene.name = 'MergedOutline [ Mask B ]';
+            renderer.render(scene, camera);
+        }
+        renderer.setRenderObjectFunction(_rendererState.renderObjectFunction);
+        this._cacheA.clear();
+        this._cacheB.clear();
+        scene.name = savedName;
+        // ── 3–7. Edge detect + blur + composite per active group ──────────────────
+        if (hasPrimary)
+            this._runEdgePipeline(renderer, 'A');
+        if (hasSecondary)
+            this._runEdgePipeline(renderer, 'B');
+        RendererUtils.restoreRendererAndSceneState(renderer, scene, _rendererState);
+    }
+    _runEdgePipeline(renderer, group) {
+        const isA = group === 'A';
+        const g = isA ? this._groupA : this._groupB;
+        const copyMat = isA ? this._copyMatA : this._copyMatB;
+        const edgeMat = isA ? this._edgeDetectMatA : this._edgeDetectMatB;
+        const blur1 = isA ? this._blurMat1A : this._blurMat1B;
+        const blur2 = isA ? this._blurMat2A : this._blurMat2B;
+        const blurDir = isA ? this._blurDirectionA : this._blurDirectionB;
+        const blurColorTex = isA ? this._blurColorTexA : this._blurColorTexB;
+        const compositeMat = isA ? this._compositeMatA : this._compositeMatB;
+        _quadMesh.material = copyMat;
+        renderer.setRenderTarget(g.maskDownSample);
+        _quadMesh.render(renderer);
+        _quadMesh.material = edgeMat;
+        renderer.setRenderTarget(g.edgeBuffer1);
+        _quadMesh.render(renderer);
+        blurColorTex.value = g.edgeBuffer1.texture;
+        blurDir.value.copy(_BLUR_X);
+        _quadMesh.material = blur1;
+        renderer.setRenderTarget(g.blurBuffer1);
+        _quadMesh.render(renderer);
+        blurColorTex.value = g.blurBuffer1.texture;
+        blurDir.value.copy(_BLUR_Y);
+        renderer.setRenderTarget(g.edgeBuffer1);
+        _quadMesh.render(renderer);
+        blurColorTex.value = g.edgeBuffer1.texture;
+        blurDir.value.copy(_BLUR_X);
+        _quadMesh.material = blur2;
+        renderer.setRenderTarget(g.blurBuffer2);
+        _quadMesh.render(renderer);
+        blurColorTex.value = g.blurBuffer2.texture;
+        blurDir.value.copy(_BLUR_Y);
+        renderer.setRenderTarget(g.edgeBuffer2);
+        _quadMesh.render(renderer);
+        _quadMesh.material = compositeMat;
+        renderer.setRenderTarget(g.composite);
+        _quadMesh.render(renderer);
+    }
+    setup(_builder) {
+        // ── prepareMask ───────────────────────────────────────────────────────────
+        const buildPrepareMask = () => {
+            const depth = this._depthTexUniform.sample(screenUV);
+            const viewZ = this.camera.isPerspectiveCamera
+                ? perspectiveDepthToViewZ(depth, this._cameraNear, this._cameraFar)
+                : orthographicDepthToViewZ(depth, this._cameraNear, this._cameraFar);
+            const depthTest = positionView.z.lessThanEqual(viewZ).select(1, 0);
+            return vec3(0.0, depthTest, 1.0);
+        };
+        const maskColorA = buildPrepareMask();
+        this._prepareMaskMatA.colorNode = maskColorA;
+        this._prepareMaskMatA.needsUpdate = true;
+        this._prepareMaskSpriteMatA.colorNode = maskColorA;
+        this._prepareMaskSpriteMatA.needsUpdate = true;
+        const maskColorB = buildPrepareMask();
+        this._prepareMaskMatB.colorNode = maskColorB;
+        this._prepareMaskMatB.needsUpdate = true;
+        this._prepareMaskSpriteMatB.colorNode = maskColorB;
+        this._prepareMaskSpriteMatB.needsUpdate = true;
+        // ── Copy ──────────────────────────────────────────────────────────────────
+        this._copyMatA.fragmentNode = this._maskTexA;
+        this._copyMatA.needsUpdate = true;
+        this._copyMatB.fragmentNode = this._maskTexB;
+        this._copyMatB.needsUpdate = true;
+        // ── Edge detection ────────────────────────────────────────────────────────
+        const buildEdgeDetect = (maskDownTex) => Fn(() => {
+            const resolution = textureSize(maskDownTex);
+            const invSize = vec2(1).div(resolution).toVar();
+            const uvOffset = vec4(1.0, 0.0, 0.0, 1.0).mul(vec4(invSize, invSize));
+            const uvNode = uv();
+            const c1 = maskDownTex.sample(uvNode.add(uvOffset.xy)).toVar();
+            const c2 = maskDownTex.sample(uvNode.sub(uvOffset.xy)).toVar();
+            const c3 = maskDownTex.sample(uvNode.add(uvOffset.yw)).toVar();
+            const c4 = maskDownTex.sample(uvNode.sub(uvOffset.yw)).toVar();
+            const diff1 = mul(c1.r.sub(c2.r), 0.5);
+            const diff2 = mul(c3.r.sub(c4.r), 0.5);
+            const d = vec2(diff1, diff2).length();
+            const a1 = min(c1.g, c2.g);
+            const a2 = min(c3.g, c4.g);
+            const visibilityFactor = min(a1, a2);
+            // R = visible edge, G = hidden edge (matches OutlineNode convention)
+            const edgeColor = visibilityFactor
+                .oneMinus()
+                .greaterThan(0.001)
+                .select(vec3(1, 0, 0), vec3(0, 1, 0));
+            return vec4(edgeColor, 1).mul(d);
+        })();
+        this._edgeDetectMatA.fragmentNode = buildEdgeDetect(this._maskDownTexA);
+        this._edgeDetectMatA.needsUpdate = true;
+        this._edgeDetectMatB.fragmentNode = buildEdgeDetect(this._maskDownTexB);
+        this._edgeDetectMatB.needsUpdate = true;
+        // ── Separable blur ────────────────────────────────────────────────────────
+        const MAX_RADIUS = 4;
+        const gaussianPdf = Fn(([x, sigma]) => float(0.398_94).mul(exp(float(-0.5).mul(x).mul(x).div(sigma.mul(sigma))).div(sigma)));
+        const buildBlur = (maskDownTex, blurColorTex, blurDir, kernelRadius) => Fn(() => {
+            const resolution = textureSize(maskDownTex);
+            const invSize = vec2(1).div(resolution).toVar();
+            const uvNode = uv();
+            const sigma = kernelRadius.div(2).toVar();
+            const weightSum = gaussianPdf(0, sigma).toVar();
+            const diffuseSum = blurColorTex.sample(uvNode).mul(weightSum).toVar();
+            const delta = blurDir.mul(invSize).mul(kernelRadius).div(MAX_RADIUS).toVar();
+            const uvOffset = delta.toVar();
+            Loop({ start: int(1), end: int(MAX_RADIUS), type: 'int', condition: '<=' }, ({ i }) => {
+                const x = kernelRadius.mul(float(i)).div(MAX_RADIUS);
+                const w = gaussianPdf(x, sigma);
+                diffuseSum.addAssign(blurColorTex
+                    .sample(uvNode.add(uvOffset))
+                    .add(blurColorTex.sample(uvNode.sub(uvOffset)))
+                    .mul(w));
+                weightSum.addAssign(w.mul(2));
+                uvOffset.addAssign(delta);
+            });
+            return diffuseSum.div(weightSum);
+        })();
+        this._blurMat1A.fragmentNode = buildBlur(this._maskDownTexA, this._blurColorTexA, this._blurDirectionA, this.primaryEdgeThicknessNode);
+        this._blurMat1A.needsUpdate = true;
+        this._blurMat2A.fragmentNode = buildBlur(this._maskDownTexA, this._blurColorTexA, this._blurDirectionA, float(MAX_RADIUS));
+        this._blurMat2A.needsUpdate = true;
+        this._blurMat1B.fragmentNode = buildBlur(this._maskDownTexB, this._blurColorTexB, this._blurDirectionB, this.secondaryEdgeThicknessNode);
+        this._blurMat1B.needsUpdate = true;
+        this._blurMat2B.fragmentNode = buildBlur(this._maskDownTexB, this._blurColorTexB, this._blurDirectionB, float(MAX_RADIUS));
+        this._blurMat2B.needsUpdate = true;
+        // ── Composite ─────────────────────────────────────────────────────────────
+        const buildComposite = (maskTex, edge1Tex, edge2Tex, edgeGlowNode) => Fn(() => maskTex.r.mul(edge1Tex.add(edge2Tex.mul(edgeGlowNode))))();
+        this._compositeMatA.fragmentNode = buildComposite(this._maskTexA, this._edge1TexA, this._edge2TexA, this.primaryEdgeGlowNode);
+        this._compositeMatA.needsUpdate = true;
+        this._compositeMatB.fragmentNode = buildComposite(this._maskTexB, this._edge1TexB, this._edge2TexB, this.secondaryEdgeGlowNode);
+        this._compositeMatB.needsUpdate = true;
+        return this._textureNodeA;
+    }
+    dispose() {
+        this.primaryObjects.length = 0;
+        this.secondaryObjects.length = 0;
+        this._depthRT.dispose();
+        this._groupA.dispose();
+        this._groupB.dispose();
+        this._depthMaterial.dispose();
+        this._depthSpriteMaterial.dispose();
+        this._prepareMaskMatA.dispose();
+        this._prepareMaskSpriteMatA.dispose();
+        this._copyMatA.dispose();
+        this._edgeDetectMatA.dispose();
+        this._blurMat1A.dispose();
+        this._blurMat2A.dispose();
+        this._compositeMatA.dispose();
+        this._prepareMaskMatB.dispose();
+        this._prepareMaskSpriteMatB.dispose();
+        this._copyMatB.dispose();
+        this._edgeDetectMatB.dispose();
+        this._blurMat1B.dispose();
+        this._blurMat2B.dispose();
+        this._compositeMatB.dispose();
+    }
+    _buildCache(objects, cache) {
+        for (const obj of objects) {
+            obj.traverse((child) => {
+                if (child.isMesh || child.isSprite)
+                    cache.add(child);
+            });
+        }
+    }
+}
+export const mergedOutline = (scene, camera, params) => new MergedOutlineNode(scene, camera, params);

package/dist/lib/suppress-three-clock-warning.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Suppresses the `THREE.Clock: This module has been deprecated` warning
+ * emitted by three.js r183+ on every `new THREE.Clock()` call.
+ *
+ * We don't instantiate `Clock` ourselves — `@react-three/fiber` 9.x
+ * (current stable) creates one internally per `<Canvas>` mount. The
+ * migration to `THREE.Timer` lands in R3F 10.x (still alpha).
+ *
+ * Uses three's `setConsoleFunction` hook so we don't touch `console.warn`
+ * globally. Only the exact Clock deprecation message is suppressed; all
+ * other three.js logs (including TSL stack-trace warnings) pass through
+ * untouched.
+ *
+ * Runs in production as well as dev — the suppressed message is a pure
+ * deprecation notice with no user-actionable content.
+ *
+ * REMOVAL: safe to delete once `@react-three/fiber` no longer constructs
+ * `new THREE.Clock()`. To verify after an R3F upgrade:
+ *   grep -n "new THREE.Clock" node_modules/@react-three/fiber/dist/*.js
+ * No hits → delete this file and its import in components/viewer/index.tsx.
+ *
+ * @see https://github.com/pascalorg/editor/issues/213
+ */
+export {};
+//# sourceMappingURL=suppress-three-clock-warning.d.ts.map

package/dist/lib/suppress-three-clock-warning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suppress-three-clock-warning.d.ts","sourceRoot":"","sources":["../../src/lib/suppress-three-clock-warning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

package/dist/lib/suppress-three-clock-warning.js

@@ -0,0 +1,51 @@
+/**
+ * Suppresses the `THREE.Clock: This module has been deprecated` warning
+ * emitted by three.js r183+ on every `new THREE.Clock()` call.
+ *
+ * We don't instantiate `Clock` ourselves — `@react-three/fiber` 9.x
+ * (current stable) creates one internally per `<Canvas>` mount. The
+ * migration to `THREE.Timer` lands in R3F 10.x (still alpha).
+ *
+ * Uses three's `setConsoleFunction` hook so we don't touch `console.warn`
+ * globally. Only the exact Clock deprecation message is suppressed; all
+ * other three.js logs (including TSL stack-trace warnings) pass through
+ * untouched.
+ *
+ * Runs in production as well as dev — the suppressed message is a pure
+ * deprecation notice with no user-actionable content.
+ *
+ * REMOVAL: safe to delete once `@react-three/fiber` no longer constructs
+ * `new THREE.Clock()`. To verify after an R3F upgrade:
+ *   grep -n "new THREE.Clock" node_modules/@react-three/fiber/dist/*.js
+ * No hits → delete this file and its import in components/viewer/index.tsx.
+ *
+ * @see https://github.com/pascalorg/editor/issues/213
+ */
+import { setConsoleFunction } from 'three';
+// three's warn() prepends 'THREE.' to its first argument, and the Clock
+// constructor passes 'THREE.Clock: ...', producing a double-prefixed
+// string. Exact equality keeps the suppression surgical — if three ever
+// rewords this, the filter stops matching and the message resurfaces.
+const CLOCK_DEPRECATION_MESSAGE = 'THREE.THREE.Clock: This module has been deprecated. Please use THREE.Timer instead.';
+// HMR-idempotent install guard. setConsoleFunction is a single-slot global
+// in three, so re-evaluating this module on HMR would reinstall the hook.
+const INSTALLED = Symbol.for('@pascal-app/viewer/suppress-three-clock-warning');
+if (!globalThis[INSTALLED]) {
+    ;
+    globalThis[INSTALLED] = true;
+    setConsoleFunction((method, message, ...params) => {
+        if (method === 'warn' && message === CLOCK_DEPRECATION_MESSAGE) {
+            return;
+        }
+        // Mirror three's default stack-trace handling so TSL warnings/errors
+        // keep their clickable stack frames.
+        if (method !== 'log') {
+            const first = params[0];
+            if (first?.isStackTrace && typeof first.getError === 'function') {
+                console[method](first.getError(message));
+                return;
+            }
+        }
+        console[method](message, ...params);
+    });
+}