@chocozhang/three-model-render 1.0.4 → 1.0.5

package/dist/effect/index.mjs

@@ -1,37 +1,5 @@
 import * as THREE from '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;
-};
-
 /**
  * @file exploder.ts
  * @description
@@ -98,205 +66,197 @@ class GroupExploder {
      * @param newSet The new set of meshes
      * @param contextId Optional context ID to distinguish business scenarios
      */
-    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;
+    async setMeshes(newSet, options) {
+        const autoRestorePrev = options?.autoRestorePrev ?? true;
+        const restoreDuration = options?.restoreDuration ?? 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');
+            await 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;
             }
-            // 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);
                 }
-                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;
-            }
-        });
+            });
+            // Ensure snapshots exist for current set members (create for newly added meshes)
+            await 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();
+            await 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) => {
+    async ensureSnapshotsForSet(set) {
+        set.forEach((m) => {
+            try {
+                m.updateMatrixWorld(true);
+            }
+            catch { }
+            if (!this.stateMap.has(m)) {
                 try {
-                    m.updateMatrixWorld(true);
+                    this.stateMap.set(m, {
+                        originalParent: m.parent || null,
+                        originalMatrixWorld: (m.matrixWorld && m.matrixWorld.clone()) || new THREE.Matrix4().copy(m.matrix),
+                    });
+                    // Also store in userData for extra resilience
+                    m.userData.__originalMatrixWorld = this.stateMap.get(m).originalMatrixWorld.clone();
                 }
-                catch (_a) { }
-                if (!this.stateMap.has(m)) {
-                    try {
-                        this.stateMap.set(m, {
-                            originalParent: m.parent || null,
-                            originalMatrixWorld: (m.matrixWorld && m.matrixWorld.clone()) || new THREE.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}`);
-                    }
+                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;
+    async explode(opts) {
+        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
+        await 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)}`);
+        await 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?.enabled ? this.applyDimToOthers(meshes, dimOthers.opacity ?? 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.Vector3();
+            try {
+                m.getWorldPosition(v);
             }
-            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.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);
+            catch {
+                // 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 {
-                    this.animId = null;
-                    this.isExploded = true;
-                    this.log(`explode: completed. contextId=${contextId !== null && contextId !== void 0 ? contextId : 'none'}`);
+                    m.position.copy(cur);
                 }
-            };
-            this.animId = requestAnimationFrame(tick);
-            return;
-        });
+                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 ?? 'none'}`);
+            }
+        };
+        this.animId = requestAnimationFrame(tick);
+        return;
     }
     /**
      * Restore all exploded meshes to their original transform:
@@ -319,7 +279,7 @@ class GroupExploder {
      */
     restoreSet(set, stateMap, duration = 400, opts) {
         if (!set || set.size === 0) {
-            if (opts === null || opts === void 0 ? void 0 : opts.debug)
+            if (opts?.debug)
                 this.log('restoreSet: empty set, nothing to restore');
             return Promise.resolve();
         }
@@ -332,12 +292,12 @@ class GroupExploder {
             try {
                 m.updateMatrixWorld(true);
             }
-            catch (_a) { }
+            catch { }
             const s = new THREE.Vector3();
             try {
                 m.getWorldPosition(s);
             }
-            catch (_b) {
+            catch {
                 s.set(0, 0, 0);
             }
             starts.push(s);
@@ -435,7 +395,7 @@ class GroupExploder {
         });
     }
     // material dim with context id
-    applyDimToOthers(explodingMeshes, opacity = 0.25, opts) {
+    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();
@@ -446,11 +406,10 @@ class GroupExploder {
             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,
+                        opacity: mat.opacity ?? 1,
                         depthWrite: mat.depthWrite,
                     });
                 }
@@ -477,7 +436,7 @@ class GroupExploder {
         return contextId;
     }
     // clean contexts for meshes (restore materials whose contexts are removed)
-    cleanContextsForMeshes(meshes) {
+    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) => {
@@ -591,7 +550,7 @@ class GroupExploder {
                     }
                 }
             }
-            catch (_a) {
+            catch {
                 radius = 0;
             }
             if (!isFinite(radius) || radius < 0 || radius > 1e8)
@@ -614,10 +573,9 @@ class GroupExploder {
     }
     // 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 lift = opts.lift ?? 0.5;
+        const mode = opts.mode ?? 'ring';
         const targets = [];
         if (mode === 'ring') {
             for (let i = 0; i < n; i++) {
@@ -659,9 +617,8 @@ class GroupExploder {
         return targets;
     }
     animateCameraToFit(targetCenter, targetRadius, opts) {
-        var _a, _b, _c, _d;
-        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;
+        const duration = opts?.duration ?? 600;
+        const padding = opts?.padding ?? 1.5;
         if (!(this.camera instanceof THREE.PerspectiveCamera)) {
             if (this.controls && this.controls.target) {
                 // Fallback for non-PerspectiveCamera
@@ -673,14 +630,13 @@ class GroupExploder {
                 const endPos = endTarget.clone().add(dir.multiplyScalar(dist));
                 const startTime = performance.now();
                 const tick = (now) => {
-                    var _a;
                     const t = Math.min(1, (now - startTime) / duration);
                     const k = easeInOutQuad(t);
                     if (this.controls && this.controls.target) {
                         this.controls.target.lerpVectors(startTarget, endTarget, k);
                     }
                     this.camera.position.lerpVectors(startPos, endPos, k);
-                    if ((_a = this.controls) === null || _a === void 0 ? void 0 : _a.update)
+                    if (this.controls?.update)
                         this.controls.update();
                     if (t < 1) {
                         this.cameraAnimId = requestAnimationFrame(tick);
@@ -703,8 +659,8 @@ class GroupExploder {
         const distH = targetRadius / Math.sin(Math.min(fov, fov * aspect) / 2); // approximate
         const dist = Math.max(distV, distH) * padding;
         const startPos = this.camera.position.clone();
-        const startTarget = ((_c = this.controls) === null || _c === void 0 ? void 0 : _c.target) ? this.controls.target.clone() : new THREE.Vector3(); // assumption
-        if (!((_d = this.controls) === null || _d === void 0 ? void 0 : _d.target)) {
+        const startTarget = this.controls?.target ? this.controls.target.clone() : new THREE.Vector3(); // assumption
+        if (!this.controls?.target) {
             this.camera.getWorldDirection(startTarget);
             startTarget.add(startPos);
         }
@@ -717,13 +673,12 @@ class GroupExploder {
         return new Promise((resolve) => {
             const startTime = performance.now();
             const tick = (now) => {
-                var _a, _b;
                 const t = Math.min(1, (now - startTime) / duration);
                 const k = easeInOutQuad(t);
                 this.camera.position.lerpVectors(startPos, endPos, k);
                 if (this.controls && this.controls.target) {
                     this.controls.target.lerpVectors(startTarget, endTarget, k);
-                    (_b = (_a = this.controls).update) === null || _b === void 0 ? void 0 : _b.call(_a);
+                    this.controls.update?.();
                 }
                 else {
                     this.camera.lookAt(endTarget); // simple lookAt if no controls