@chocozhang/three-model-render 1.0.1

package/dist/effect/index.js

@@ -0,0 +1,749 @@
+'use strict';
+
+var THREE = require('three');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function easeInOutQuad(t) {
+    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+class GroupExploder {
+    constructor(scene, camera, controls) {
+        // sets and snapshots
+        this.currentSet = null;
+        this.stateMap = new Map();
+        // prevSet preserved to allow async restore
+        this.prevSet = null;
+        this.prevStateMap = new Map();
+        // material context map: material -> Set<contextId>, and snapshot store material->snap
+        this.materialContexts = new Map();
+        this.materialSnaps = new Map();
+        this.contextMaterials = new Map();
+        this.animId = null;
+        this.cameraAnimId = null;
+        this.isExploded = false;
+        this.isInitialized = false;
+        this.scene = scene;
+        this.camera = camera;
+        this.controls = controls;
+    }
+    log(msg) {
+        console.log('[GroupExploderDebug]', msg);
+        if (this.onLog)
+            this.onLog(msg);
+    }
+    init() {
+        if (this.isInitialized)
+            return;
+        this.isInitialized = true;
+        this.log('init() called');
+    }
+    /**
+     * setMeshes(newSet):
+     * - Detects content-level changes even if same Set reference is used.
+     * - Preserves prevSet/stateMap to allow async restore when needed.
+     * - Ensures stateMap contains snapshots for *all meshes in the new set*.
+     */
+    setMeshes(newSet, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const autoRestorePrev = (_a = options === null || options === void 0 ? void 0 : options.autoRestorePrev) !== null && _a !== void 0 ? _a : true;
+            const restoreDuration = (_b = options === null || options === void 0 ? void 0 : options.restoreDuration) !== null && _b !== void 0 ? _b : 300;
+            this.log(`setMeshes called. newSetSize=${newSet ? newSet.size : 0}, autoRestorePrev=${autoRestorePrev}`);
+            // If the newSet is null and currentSet is null -> nothing
+            if (!newSet && !this.currentSet) {
+                this.log('setMeshes: both newSet and currentSet are null, nothing to do');
+                return;
+            }
+            // If both exist and are the same reference, we still must detect content changes.
+            const sameReference = this.currentSet === newSet;
+            // Prepare prevSet snapshot (we copy current to prev)
+            if (this.currentSet) {
+                this.prevSet = this.currentSet;
+                this.prevStateMap = new Map(this.stateMap);
+                this.log(`setMeshes: backed up current->prev prevSetSize=${this.prevSet.size}`);
+            }
+            else {
+                this.prevSet = null;
+                this.prevStateMap = new Map();
+            }
+            // If we used to be exploded and need to restore prevSet, do that first (await)
+            if (this.prevSet && autoRestorePrev && this.isExploded) {
+                this.log('setMeshes: need to restore prevSet before applying newSet');
+                yield this.restoreSet(this.prevSet, this.prevStateMap, restoreDuration, { debug: true });
+                this.log('setMeshes: prevSet restore done');
+                this.prevStateMap.clear();
+                this.prevSet = null;
+            }
+            // Now register newSet: we clear and rebuild stateMap carefully.
+            // But we must handle the case where caller reuses same Set object and just mutated elements.
+            // We will compute additions and removals.
+            const oldSet = this.currentSet;
+            this.currentSet = newSet;
+            // If newSet is null -> simply clear stateMap
+            if (!this.currentSet) {
+                this.stateMap.clear();
+                this.log('setMeshes: newSet is null -> cleared stateMap');
+                this.isExploded = false;
+                return;
+            }
+            // If we have oldSet (could be same reference) then compute diffs
+            if (oldSet) {
+                // If same reference but size or content differs -> handle diffs
+                const wasSameRef = sameReference;
+                let added = [];
+                let removed = [];
+                // Build maps of membership
+                const oldMembers = new Set(Array.from(oldSet));
+                const newMembers = new Set(Array.from(this.currentSet));
+                // find removals
+                oldMembers.forEach((m) => {
+                    if (!newMembers.has(m))
+                        removed.push(m);
+                });
+                // find additions
+                newMembers.forEach((m) => {
+                    if (!oldMembers.has(m))
+                        added.push(m);
+                });
+                if (wasSameRef && added.length === 0 && removed.length === 0) {
+                    // truly identical (no content changes)
+                    this.log('setMeshes: same reference and identical contents -> nothing to update');
+                    return;
+                }
+                this.log(`setMeshes: diff detected -> added=${added.length}, removed=${removed.length}`);
+                // Remove snapshots for removed meshes
+                removed.forEach((m) => {
+                    if (this.stateMap.has(m)) {
+                        this.stateMap.delete(m);
+                    }
+                });
+                // Ensure snapshots exist for current set members (create for newly added meshes)
+                yield this.ensureSnapshotsForSet(this.currentSet);
+                this.log(`setMeshes: after diff handling, stateMap size=${this.stateMap.size}`);
+                this.isExploded = false;
+                return;
+            }
+            else {
+                // no oldSet -> brand new registration
+                this.stateMap.clear();
+                yield this.ensureSnapshotsForSet(this.currentSet);
+                this.log(`setMeshes: recorded stateMap entries for newSet size=${this.stateMap.size}`);
+                this.isExploded = false;
+                return;
+            }
+        });
+    }
+    /**
+     * ensureSnapshotsForSet: for each mesh in set, ensure stateMap has an entry.
+     * If missing, record current matrixWorld as originalMatrixWorld (best-effort).
+     */
+    ensureSnapshotsForSet(set) {
+        return __awaiter(this, void 0, void 0, function* () {
+            set.forEach((m) => {
+                try {
+                    m.updateMatrixWorld(true);
+                }
+                catch (_a) { }
+                if (!this.stateMap.has(m)) {
+                    try {
+                        this.stateMap.set(m, {
+                            originalParent: m.parent || null,
+                            originalMatrixWorld: (m.matrixWorld && m.matrixWorld.clone()) || new THREE__namespace.Matrix4().copy(m.matrix),
+                        });
+                        // Also store in userData for extra resilience
+                        m.userData.__originalMatrixWorld = this.stateMap.get(m).originalMatrixWorld.clone();
+                    }
+                    catch (e) {
+                        this.log(`ensureSnapshotsForSet: failed to snapshot mesh ${m.name || m.id}: ${e.message}`);
+                    }
+                }
+            });
+        });
+    }
+    /**
+     * explode: compute targets first, compute targetBound using targets + mesh radii,
+     * animate camera to that targetBound, then animate meshes to targets.
+     */
+    explode(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.currentSet || this.currentSet.size === 0) {
+                this.log('explode: empty currentSet, nothing to do');
+                return;
+            }
+            const { spacing = 2, duration = 1000, lift = 0.5, cameraPadding = 1.5, mode = 'spiral', dimOthers = { enabled: true, opacity: 0.25 }, debug = false, } = opts || {};
+            this.log(`explode called. setSize=${this.currentSet.size}, mode=${mode}, spacing=${spacing}, duration=${duration}, lift=${lift}, dim=${dimOthers.enabled}`);
+            this.cancelAnimations();
+            const meshes = Array.from(this.currentSet);
+            // ensure snapshots exist for any meshes that may have been added after initial registration
+            yield this.ensureSnapshotsForSet(this.currentSet);
+            // compute center/radius from current meshes (fallback)
+            const initial = this.computeBoundingSphereForMeshes(meshes);
+            const center = initial.center;
+            const baseRadius = Math.max(1, initial.radius);
+            this.log(`explode: initial center=${center.toArray().map((n) => n.toFixed(3))}, baseRadius=${baseRadius.toFixed(3)}`);
+            // compute targets (pure calculation)
+            const targets = this.computeTargetsByMode(meshes, center, baseRadius + spacing, { lift, mode });
+            this.log(`explode: computed ${targets.length} target positions`);
+            // compute target-based bounding sphere (targets + per-mesh radius)
+            const targetBound = this.computeBoundingSphereForPositionsAndMeshes(targets, meshes);
+            this.log(`explode: targetBound center=${targetBound.center.toArray().map((n) => n.toFixed(3))}, radius=${targetBound.radius.toFixed(3)}`);
+            yield this.animateCameraToFit(targetBound.center, targetBound.radius, { duration: Math.min(600, duration), padding: cameraPadding });
+            this.log('explode: camera animation to target bound completed');
+            // apply dim if needed with context id
+            const contextId = (dimOthers === null || dimOthers === void 0 ? void 0 : dimOthers.enabled) ? this.applyDimToOthers(meshes, (_a = dimOthers.opacity) !== null && _a !== void 0 ? _a : 0.25, { debug }) : null;
+            if (contextId)
+                this.log(`explode: applied dim for context ${contextId}`);
+            // capture starts after camera move
+            const starts = meshes.map((m) => {
+                const v = new THREE__namespace.Vector3();
+                try {
+                    m.getWorldPosition(v);
+                }
+                catch (_a) {
+                    // fallback to originalMatrixWorld if available
+                    const st = this.stateMap.get(m);
+                    if (st)
+                        v.setFromMatrixPosition(st.originalMatrixWorld);
+                }
+                return v;
+            });
+            const startTime = performance.now();
+            const total = Math.max(1, duration);
+            const tick = (now) => {
+                const t = Math.min(1, (now - startTime) / total);
+                const eased = easeInOutQuad(t);
+                for (let i = 0; i < meshes.length; i++) {
+                    const m = meshes[i];
+                    const s = starts[i];
+                    const tar = targets[i];
+                    const cur = s.clone().lerp(tar, eased);
+                    if (m.parent) {
+                        const local = cur.clone();
+                        m.parent.worldToLocal(local);
+                        m.position.copy(local);
+                    }
+                    else {
+                        m.position.copy(cur);
+                    }
+                    m.updateMatrix();
+                }
+                if (this.controls && typeof this.controls.update === 'function')
+                    this.controls.update();
+                if (t < 1) {
+                    this.animId = requestAnimationFrame(tick);
+                }
+                else {
+                    this.animId = null;
+                    this.isExploded = true;
+                    this.log(`explode: completed. contextId=${contextId !== null && contextId !== void 0 ? contextId : 'none'}`);
+                }
+            };
+            this.animId = requestAnimationFrame(tick);
+            return;
+        });
+    }
+    restore(duration = 400) {
+        if (!this.currentSet || this.currentSet.size === 0) {
+            this.log('restore: no currentSet to restore');
+            return Promise.resolve();
+        }
+        this.log(`restore called for currentSet size=${this.currentSet.size}`);
+        return this.restoreSet(this.currentSet, this.stateMap, duration, { debug: true });
+    }
+    /**
+     * restoreSet: reparent and restore transforms using provided stateMap.
+     * If missing stateMap entry for a mesh, use fallbacks:
+     *  1) mesh.userData.__originalMatrixWorld (if present)
+     *  2) mesh.matrixWorld (current) -> smooth lerp to itself (no-op visually)
+     */
+    restoreSet(set, stateMap, duration = 400, opts) {
+        if (!set || set.size === 0) {
+            if (opts === null || opts === void 0 ? void 0 : opts.debug)
+                this.log('restoreSet: empty set, nothing to restore');
+            return Promise.resolve();
+        }
+        this.cancelAnimations();
+        const meshes = Array.from(set);
+        this.log(`restoreSet: starting restore for ${meshes.length} meshes (duration=${duration})`);
+        const starts = [];
+        const targets = [];
+        for (const m of meshes) {
+            try {
+                m.updateMatrixWorld(true);
+            }
+            catch (_a) { }
+            const s = new THREE__namespace.Vector3();
+            try {
+                m.getWorldPosition(s);
+            }
+            catch (_b) {
+                s.set(0, 0, 0);
+            }
+            starts.push(s);
+            const st = stateMap.get(m);
+            if (st) {
+                const tar = new THREE__namespace.Vector3();
+                tar.setFromMatrixPosition(st.originalMatrixWorld);
+                targets.push(tar);
+            }
+            else {
+                // fallback attempts
+                const ud = m.userData.__originalMatrixWorld;
+                if (ud instanceof THREE__namespace.Matrix4) {
+                    const tar = new THREE__namespace.Vector3();
+                    tar.setFromMatrixPosition(ud);
+                    targets.push(tar);
+                    this.log(`restoreSet: used userData.__originalMatrixWorld for mesh ${m.name || m.id}`);
+                }
+                else {
+                    // fallback to current position to avoid NaN; will be effectively a no-op but avoids error
+                    const tar = s.clone();
+                    targets.push(tar);
+                    this.log(`restoreSet: missing stateMap entry for mesh ${m.name || m.id} -> fallback to current pos`);
+                }
+            }
+        }
+        const startTime = performance.now();
+        const total = Math.max(1, duration);
+        return new Promise((resolve) => {
+            const tick = (now) => {
+                const t = Math.min(1, (now - startTime) / total);
+                const eased = easeInOutQuad(t);
+                for (let i = 0; i < meshes.length; i++) {
+                    const m = meshes[i];
+                    const s = starts[i];
+                    const tar = targets[i];
+                    const cur = s.clone().lerp(tar, eased);
+                    // final step: ensure reparent to original parent if possible
+                    const st = stateMap.get(m);
+                    if (st && t >= 0.999) {
+                        try {
+                            const origParent = st.originalParent || this.scene;
+                            origParent.updateMatrixWorld(true);
+                            const parentInv = new THREE__namespace.Matrix4().copy(origParent.matrixWorld).invert();
+                            const localMat = new THREE__namespace.Matrix4().multiplyMatrices(parentInv, st.originalMatrixWorld);
+                            // reparent (if needed)
+                            if (m.parent !== origParent) {
+                                origParent.add(m);
+                            }
+                            m.matrix.copy(localMat);
+                            m.matrix.decompose(m.position, m.quaternion, m.scale);
+                            m.updateMatrixWorld(true);
+                        }
+                        catch (e) {
+                            // fallback: set world position
+                            if (m.parent) {
+                                const local = tar.clone();
+                                m.parent.worldToLocal(local);
+                                m.position.copy(local);
+                            }
+                            else {
+                                m.position.copy(tar);
+                            }
+                            m.updateMatrixWorld(true);
+                            this.log(`restoreSet: error finalizing reparent for ${m.name || m.id}: ${e.message}`);
+                        }
+                    }
+                    else {
+                        // intermediate frames: lerp world -> convert to local relative to current parent
+                        if (m.parent) {
+                            const local = cur.clone();
+                            m.parent.worldToLocal(local);
+                            m.position.copy(local);
+                        }
+                        else {
+                            m.position.copy(cur);
+                        }
+                        m.updateMatrix();
+                    }
+                }
+                if (this.controls && typeof this.controls.update === 'function')
+                    this.controls.update();
+                if (t < 1) {
+                    this.animId = requestAnimationFrame(tick);
+                }
+                else {
+                    this.animId = null;
+                    this.cleanContextsForMeshes(meshes);
+                    this.isExploded = false;
+                    this.log('restoreSet: completed and cleaned contexts for restored meshes');
+                    resolve();
+                }
+            };
+            this.animId = requestAnimationFrame(tick);
+        });
+    }
+    // material dim with context id
+    applyDimToOthers(explodingMeshes, opacity = 0.25, opts) {
+        const contextId = `ctx_${Date.now()}_${Math.floor(Math.random() * 10000)}`;
+        const explodingSet = new Set(explodingMeshes);
+        const touched = new Set();
+        this.scene.traverse((obj) => {
+            if (!obj.isMesh)
+                return;
+            const mesh = obj;
+            if (explodingSet.has(mesh))
+                return;
+            const applyMat = (mat) => {
+                var _a;
+                if (!this.materialSnaps.has(mat)) {
+                    this.materialSnaps.set(mat, {
+                        transparent: !!mat.transparent,
+                        opacity: (_a = mat.opacity) !== null && _a !== void 0 ? _a : 1,
+                        depthWrite: mat.depthWrite,
+                    });
+                }
+                let s = this.materialContexts.get(mat);
+                if (!s) {
+                    s = new Set();
+                    this.materialContexts.set(mat, s);
+                }
+                s.add(contextId);
+                touched.add(mat);
+                mat.transparent = true;
+                mat.opacity = opacity;
+                mat.needsUpdate = true;
+            };
+            if (Array.isArray(mesh.material)) {
+                mesh.material.forEach((m) => applyMat(m));
+            }
+            else if (mesh.material) {
+                applyMat(mesh.material);
+            }
+        });
+        this.contextMaterials.set(contextId, touched);
+        this.log(`applyDimToOthers: context=${contextId}, touchedMaterials=${touched.size}`);
+        return contextId;
+    }
+    // clean contexts for meshes (restore materials whose contexts are removed)
+    cleanContextsForMeshes(meshes) {
+        // conservative strategy: for each context we created, delete it and restore materials accordingly
+        for (const [contextId, mats] of Array.from(this.contextMaterials.entries())) {
+            mats.forEach((mat) => {
+                const ctxSet = this.materialContexts.get(mat);
+                if (ctxSet) {
+                    ctxSet.delete(contextId);
+                    if (ctxSet.size === 0) {
+                        const snap = this.materialSnaps.get(mat);
+                        if (snap) {
+                            mat.transparent = snap.transparent;
+                            mat.opacity = snap.opacity;
+                            if (typeof snap.depthWrite !== 'undefined')
+                                mat.depthWrite = snap.depthWrite;
+                        }
+                        mat.needsUpdate = true;
+                        this.materialContexts.delete(mat);
+                        this.materialSnaps.delete(mat);
+                    }
+                    else {
+                        this.materialContexts.set(mat, ctxSet);
+                    }
+                }
+            });
+            this.contextMaterials.delete(contextId);
+            this.log(`cleanContextsForMeshes: removed context ${contextId}`);
+        }
+    }
+    // robust bounding sphere computation; if mesh world pos invalid, try stateMap's originalMatrixWorld as backoff
+    computeBoundingSphereForMeshes(meshes) {
+        const box = new THREE__namespace.Box3();
+        meshes.forEach((m) => {
+            try {
+                m.updateMatrixWorld(true);
+                const pos = new THREE__namespace.Vector3();
+                m.getWorldPosition(pos);
+                if (!isFinite(pos.x) || !isFinite(pos.y) || !isFinite(pos.z)) {
+                    // fallback to stateMap's originalMatrixWorld if available
+                    const st = this.stateMap.get(m);
+                    if (st) {
+                        const fallback = new THREE__namespace.Vector3();
+                        fallback.setFromMatrixPosition(st.originalMatrixWorld);
+                        if (isFinite(fallback.x) && isFinite(fallback.y) && isFinite(fallback.z)) {
+                            this.log(`computeBoundingSphereForMeshes: using stateMap originalMatrixWorld for mesh ${m.name || m.id}`);
+                            pos.copy(fallback);
+                        }
+                        else {
+                            this.log(`computeBoundingSphereForMeshes: skipping mesh ${m.name || m.id} due to invalid positions`);
+                            return;
+                        }
+                    }
+                    else {
+                        this.log(`computeBoundingSphereForMeshes: skipping mesh ${m.name || m.id} due to invalid world pos and no snapshot`);
+                        return;
+                    }
+                }
+                let radius = 0;
+                const geom = m.geometry || null;
+                if (geom) {
+                    if (!geom.boundingSphere)
+                        geom.computeBoundingSphere();
+                    if (geom.boundingSphere) {
+                        radius = geom.boundingSphere.radius;
+                        const ws = new THREE__namespace.Vector3();
+                        m.getWorldScale(ws);
+                        radius = radius * Math.max(ws.x, ws.y, ws.z, 1e-6);
+                    }
+                }
+                if (!isFinite(radius) || radius < 0 || radius > 1e8)
+                    radius = 0;
+                const min = pos.clone().addScalar(-radius);
+                const max = pos.clone().addScalar(radius);
+                box.expandByPoint(min);
+                box.expandByPoint(max);
+            }
+            catch (e) {
+                this.log(`computeBoundingSphereForMeshes: error for mesh ${m.name || m.id}: ${e.message}`);
+            }
+        });
+        const center = new THREE__namespace.Vector3();
+        if (box.isEmpty()) {
+            center.set(0, 0, 0);
+            box.expandByPoint(center);
+        }
+        box.getCenter(center);
+        const sphere = new THREE__namespace.Sphere();
+        box.getBoundingSphere(sphere);
+        const radius = sphere.radius || Math.max(box.getSize(new THREE__namespace.Vector3()).length() * 0.5, 1.0);
+        return { center, radius };
+    }
+    // compute bounding sphere for positions + mesh radii
+    computeBoundingSphereForPositionsAndMeshes(positions, meshes) {
+        const box = new THREE__namespace.Box3();
+        for (let i = 0; i < positions.length; i++) {
+            const p = positions[i];
+            if (!isFinite(p.x) || !isFinite(p.y) || !isFinite(p.z)) {
+                this.log(`computeBoundingSphereForPositionsAndMeshes: skipping invalid target pos idx=${i}`);
+                continue;
+            }
+            let radius = 0;
+            const m = meshes[i];
+            try {
+                const geom = m.geometry || null;
+                if (geom) {
+                    if (!geom.boundingSphere)
+                        geom.computeBoundingSphere();
+                    if (geom.boundingSphere) {
+                        radius = geom.boundingSphere.radius;
+                        const ws = new THREE__namespace.Vector3();
+                        m.getWorldScale(ws);
+                        radius = radius * Math.max(ws.x, ws.y, ws.z, 1e-6);
+                    }
+                }
+            }
+            catch (_a) {
+                radius = 0;
+            }
+            if (!isFinite(radius) || radius < 0 || radius > 1e8)
+                radius = 0;
+            const min = p.clone().addScalar(-radius);
+            const max = p.clone().addScalar(radius);
+            box.expandByPoint(min);
+            box.expandByPoint(max);
+        }
+        const center = new THREE__namespace.Vector3();
+        if (box.isEmpty()) {
+            center.set(0, 0, 0);
+            box.expandByPoint(center);
+        }
+        box.getCenter(center);
+        const tmp = new THREE__namespace.Sphere();
+        box.getBoundingSphere(tmp);
+        const radius = tmp.radius || Math.max(box.getSize(new THREE__namespace.Vector3()).length() * 0.5, 1.0);
+        return { center, radius };
+    }
+    // computeTargetsByMode (unchanged logic but pure function)
+    computeTargetsByMode(meshes, center, baseRadius, opts) {
+        var _a, _b;
+        const n = meshes.length;
+        const lift = (_a = opts.lift) !== null && _a !== void 0 ? _a : 0.5;
+        const mode = (_b = opts.mode) !== null && _b !== void 0 ? _b : 'ring';
+        const targets = [];
+        if (mode === 'ring') {
+            for (let i = 0; i < n; i++) {
+                const angle = (i / n) * Math.PI * 2;
+                targets.push(new THREE__namespace.Vector3(center.x + Math.cos(angle) * baseRadius, center.y + lift, center.z + Math.sin(angle) * baseRadius));
+            }
+            return targets;
+        }
+        if (mode === 'spiral') {
+            const turns = Math.max(1, Math.ceil(n / 6));
+            for (let i = 0; i < n; i++) {
+                const t = i / (n - 1 || 1);
+                const angle = t * Math.PI * 2 * turns;
+                const radius = baseRadius * (0.3 + 0.7 * t);
+                targets.push(new THREE__namespace.Vector3(center.x + Math.cos(angle) * radius, center.y + lift + t * 0.5, center.z + Math.sin(angle) * radius));
+            }
+            return targets;
+        }
+        if (mode === 'grid') {
+            const cols = Math.ceil(Math.sqrt(n));
+            const rows = Math.ceil(n / cols);
+            const spacing = Math.max(0.5, baseRadius / Math.max(cols, rows));
+            const startX = center.x - ((cols - 1) * spacing) / 2;
+            const startZ = center.z - ((rows - 1) * spacing) / 2;
+            for (let i = 0; i < n; i++) {
+                const r = Math.floor(i / cols);
+                const c = i % cols;
+                targets.push(new THREE__namespace.Vector3(startX + c * spacing, center.y + lift, startZ + r * spacing));
+            }
+            return targets;
+        }
+        // radial
+        for (let i = 0; i < n; i++) {
+            const t = i / n;
+            const angle = t * Math.PI * 2;
+            const r = baseRadius * (1 + (i % 3) * 0.4 + Math.floor(i / 3) * 0.6);
+            targets.push(new THREE__namespace.Vector3(center.x + Math.cos(angle) * r, center.y + lift + Math.floor(i / 3) * 0.2, center.z + Math.sin(angle) * r));
+        }
+        return targets;
+    }
+    animateCameraToFit(targetCenter, targetRadius, opts) {
+        var _a, _b, _c;
+        const duration = (_a = opts === null || opts === void 0 ? void 0 : opts.duration) !== null && _a !== void 0 ? _a : 600;
+        const padding = (_b = opts === null || opts === void 0 ? void 0 : opts.padding) !== null && _b !== void 0 ? _b : 1.5;
+        if (!(this.camera instanceof THREE__namespace.PerspectiveCamera)) {
+            if (this.controls && this.controls.target) {
+                this.controls.target.copy(targetCenter);
+                if (typeof this.controls.update === 'function')
+                    this.controls.update();
+            }
+            return Promise.resolve();
+        }
+        const cam = this.camera;
+        const fov = (cam.fov * Math.PI) / 180;
+        const safeRadius = isFinite(targetRadius) && targetRadius > 0 ? targetRadius : 1;
+        const desiredDistance = Math.min(1e6, (safeRadius * ((_c = opts === null || opts === void 0 ? void 0 : opts.padding) !== null && _c !== void 0 ? _c : padding)) / Math.sin(fov / 2));
+        const camPos = cam.position.clone();
+        const dir = camPos.clone().sub(targetCenter);
+        if (dir.length() === 0)
+            dir.set(0, 0, 1);
+        else
+            dir.normalize();
+        const newCamPos = targetCenter.clone().add(dir.multiplyScalar(desiredDistance));
+        const startPos = cam.position.clone();
+        const startTarget = (this.controls && this.controls.target) ? (this.controls.target.clone()) : this.getCameraLookAtPoint();
+        const endTarget = targetCenter.clone();
+        const startTime = performance.now();
+        return new Promise((resolve) => {
+            const tick = (now) => {
+                const t = Math.min(1, (now - startTime) / Math.max(1, duration));
+                const eased = easeInOutQuad(t);
+                cam.position.lerpVectors(startPos, newCamPos, eased);
+                if (this.controls && this.controls.target)
+                    this.controls.target.lerpVectors(startTarget, endTarget, eased);
+                cam.updateProjectionMatrix();
+                if (this.controls && typeof this.controls.update === 'function')
+                    this.controls.update();
+                if (t < 1)
+                    this.cameraAnimId = requestAnimationFrame(tick);
+                else {
+                    this.cameraAnimId = null;
+                    this.log(`animateCameraToFit: done. center=${targetCenter.toArray().map((n) => n.toFixed(2))}, radius=${targetRadius.toFixed(2)}`);
+                    resolve();
+                }
+            };
+            this.cameraAnimId = requestAnimationFrame(tick);
+        });
+    }
+    getCameraLookAtPoint() {
+        const dir = new THREE__namespace.Vector3();
+        this.camera.getWorldDirection(dir);
+        return this.camera.position.clone().add(dir.multiplyScalar(10));
+    }
+    cancelAnimations() {
+        if (this.animId) {
+            cancelAnimationFrame(this.animId);
+            this.animId = null;
+        }
+        if (this.cameraAnimId) {
+            cancelAnimationFrame(this.cameraAnimId);
+            this.cameraAnimId = null;
+        }
+    }
+    dispose() {
+        return __awaiter(this, arguments, void 0, function* (restoreBefore = true) {
+            this.cancelAnimations();
+            if (restoreBefore && this.isExploded) {
+                try {
+                    yield this.restore(200);
+                }
+                catch (_a) { }
+            }
+            // force restore of materials
+            for (const [mat, ctxs] of Array.from(this.materialContexts.entries())) {
+                const snap = this.materialSnaps.get(mat);
+                if (snap) {
+                    mat.transparent = snap.transparent;
+                    mat.opacity = snap.opacity;
+                    if (typeof snap.depthWrite !== 'undefined')
+                        mat.depthWrite = snap.depthWrite;
+                    mat.needsUpdate = true;
+                }
+                this.materialContexts.delete(mat);
+                this.materialSnaps.delete(mat);
+            }
+            this.contextMaterials.clear();
+            this.stateMap.clear();
+            this.prevStateMap.clear();
+            this.currentSet = null;
+            this.prevSet = null;
+            this.isInitialized = false;
+            this.isExploded = false;
+            this.log('dispose: cleaned up');
+        });
+    }
+}
+
+exports.GroupExploder = GroupExploder;
+//# sourceMappingURL=index.js.map