@inweb/viewer-three 27.2.3 → 27.3.0

package/dist/viewer-three.module.js

@@ -3806,19 +3806,19 @@ class ModelImpl {
         return this;
     }
     explode(scale = 0, coeff = 4) {
-        const centers = new Map();
-        const getObjectCenter = (object, target) => {
+        const centersCache = new Map();
+        const calcObjectCenter = (object, target) => {
             const extents = new Box3().setFromObject(object);
             const handle = object.userData.handle;
             if (!handle)
                 return extents.getCenter(target);
-            const center = centers.get(handle);
+            const center = centersCache.get(handle);
             if (center)
                 return target.copy(center);
             const objects = this.getObjectsByHandles(handle);
             objects.forEach((x) => extents.expandByObject(x));
             extents.getCenter(target);
-            centers.set(handle, target.clone());
+            centersCache.set(handle, target.clone());
             return target;
         };
         function calcExplodeDepth(object, depth) {
@@ -3829,13 +3829,14 @@ class ModelImpl {
                     result = objectDepth;
             });
             object.userData.originalPosition = object.position.clone();
-            object.userData.originalCenter = getObjectCenter(object, new Vector3());
+            object.userData.originalCenter = calcObjectCenter(object, new Vector3());
             return result;
         }
         const explodeScale = scale / 100;
         const explodeRoot = this.scene;
-        if (!explodeRoot.userData.explodeDepth)
+        if (!explodeRoot.userData.explodeDepth) {
             explodeRoot.userData.explodeDepth = calcExplodeDepth(explodeRoot, 1);
+        }
         const maxDepth = explodeRoot.userData.explodeDepth;
         const scaledExplodeDepth = explodeScale * maxDepth + 1;
         const explodeDepth = 0 | scaledExplodeDepth;
@@ -3852,8 +3853,8 @@ class ModelImpl {
                     objectScale *= currentSegmentFraction;
                 const parentCenter = object.parent.userData.originalCenter;
                 const objectCenter = object.userData.originalCenter;
-                const objectOffset = objectCenter.clone().sub(parentCenter).multiplyScalar(objectScale);
-                object.position.add(objectOffset);
+                const localOffset = objectCenter.clone().sub(parentCenter).multiplyScalar(objectScale);
+                object.position.add(localOffset);
             }
             object.children.forEach((x) => explodeObject(x, depth + 1));
         }
@@ -3945,67 +3946,73 @@ class DynamicModelImpl extends ModelImpl {
         return this;
     }
     explode(scale = 0, coeff = 4) {
-        const centers = new Map();
+        const centersCache = new Map();
         const calcObjectCenter = (object, target) => {
             const extents = new Box3().setFromObject(object);
             const handle = object.userData.handle;
             if (!handle)
                 return extents.getCenter(target);
-            const center = centers.get(handle);
+            const center = centersCache.get(handle);
             if (center)
                 return target.copy(center);
             const objects = this.getObjectsByHandles(handle);
             objects.forEach((x) => extents.expandByObject(x));
             extents.getCenter(target);
-            centers.set(handle, target.clone());
+            centersCache.set(handle, target.clone());
             return target;
         };
-        function calcExplodeDepth(object, depth) {
-            let result = depth;
-            object.children
-                .filter((x) => !x.userData.isOptimized)
-                .forEach((x) => {
-                const objectDepth = calcExplodeDepth(x, depth + 1);
-                if (result < objectDepth)
-                    result = objectDepth;
-            });
+        const calcObjectDepth = (object) => {
+            if (object.userData.depth !== undefined)
+                return object.userData.depth;
+            const parent = object.parent;
+            const depth = parent && object !== explodeRoot ? calcObjectDepth(parent) + 1 : 0;
+            object.userData.depth = depth;
             object.userData.originalPosition = object.position.clone();
             object.userData.originalCenter = calcObjectCenter(object, new Vector3());
-            return result;
-        }
+            return depth;
+        };
         const explodeScale = scale / 100;
         const explodeRoot = this.scene.children[0];
-        if (!explodeRoot.userData.explodeDepth)
-            explodeRoot.userData.explodeDepth = calcExplodeDepth(explodeRoot, 1);
+        if (!explodeRoot.userData.explodeDepth) {
+            let maxDepth = 0;
+            this.gltfLoader.originalObjects.forEach((object) => {
+                const depth = calcObjectDepth(object);
+                if (depth > maxDepth)
+                    maxDepth = depth;
+            });
+            explodeRoot.userData.explodeDepth = maxDepth;
+        }
         const maxDepth = explodeRoot.userData.explodeDepth;
         const scaledExplodeDepth = explodeScale * maxDepth + 1;
         const explodeDepth = 0 | scaledExplodeDepth;
         const currentSegmentFraction = scaledExplodeDepth - explodeDepth;
-        const transformMap = new Map();
-        function explodeObject(object, depth) {
-            if (object.isCamera)
-                return;
-            if (object.userData.isHighlightWireframe)
-                return;
-            object.position.copy(object.userData.originalPosition);
-            if (depth > 0 && depth <= explodeDepth && !object.userData.isExplodeLocked) {
+        const offsetCache = new Map();
+        const calcObjectOffset = (object, target) => {
+            if (offsetCache.has(object))
+                return target.copy(offsetCache.get(object));
+            const parent = object.parent;
+            if (parent && object !== explodeRoot)
+                calcObjectOffset(parent, target);
+            const depth = object.userData.depth;
+            if (depth > 0 && depth <= explodeDepth) {
                 let objectScale = explodeScale * coeff;
                 if (depth === explodeDepth)
                     objectScale *= currentSegmentFraction;
-                const parentCenter = object.parent.userData.originalCenter;
+                const parentCenter = parent.userData.originalCenter;
                 const objectCenter = object.userData.originalCenter;
-                const objectOffset = objectCenter.clone().sub(parentCenter).multiplyScalar(objectScale);
-                object.position.add(objectOffset);
-                const matrix = new Matrix4().makeTranslation(objectOffset.x, objectOffset.y, objectOffset.z);
-                transformMap.set(object, matrix);
+                const localOffset = objectCenter.clone().sub(parentCenter).multiplyScalar(objectScale);
+                target.add(localOffset);
             }
-            object.children
-                .filter((x) => !x.userData.isOptimized)
-                .forEach((x) => explodeObject(x, depth + 1));
-        }
-        explodeObject(explodeRoot, 0);
-        this.scene.updateMatrixWorld();
+            offsetCache.set(object, target.clone());
+            return target;
+        };
+        const transformMap = new Map();
+        this.gltfLoader.originalObjects.forEach((object) => {
+            const globalOffset = calcObjectOffset(object, new Vector3());
+            transformMap.set(object, new Matrix4().makeTranslation(globalOffset));
+        });
         this.gltfLoader.applyObjectTransforms(transformMap);
+        this.scene.updateMatrixWorld();
         return this;
     }
 }
@@ -4582,6 +4589,8 @@ class DynamicGltfLoader {
     this.oldOptimizeObjects = new Set();
     this.objectTransforms = new Map();
     this.transformedGeometries = new Map();
+    this.syncTransformsToOriginalObjects = true;
+    this._originalObjectMatrices = new Map();
     this.activeChunkLoads = 0;
     this.chunkQueue = [];
     this.objectIdToIndex = new Map();
@@ -5736,6 +5745,7 @@ class DynamicGltfLoader {
     this.isolatedObjects = [];
     this.objectTransforms.clear();
     this.transformedGeometries.clear();
+    this._originalObjectMatrices.clear();
     this.totalLoadedObjects = 0;
     this.currentMemoryUsage = 0;
     this.pendingMemoryUsage = 0;
@@ -6581,6 +6591,47 @@ class DynamicGltfLoader {
         this.updateMaterialUniforms();
       }
     }
+    if (this.syncTransformsToOriginalObjects) {
+      this._syncOriginalObjectTransforms(objectTransformMap);
+    }
+  }
+  _syncOriginalObjectTransforms(objectTransformMap) {
+    for (const [obj, savedPos] of this._originalObjectMatrices) {
+      obj.position.copy(savedPos);
+      if (obj.userData.highlight) {
+        obj.userData.highlight.position.copy(savedPos);
+      }
+    }
+    this._originalObjectMatrices.clear();
+    const _offset = new Vector3();
+    const _parentInverse = new Matrix4();
+    if (objectTransformMap instanceof Map) {
+      for (const [object, matrix] of objectTransformMap.entries()) {
+        if (!object.userData?.handle) continue;
+        if (!this._originalObjectMatrices.has(object)) {
+          this._originalObjectMatrices.set(object, object.position.clone());
+        }
+        _offset.setFromMatrixPosition(matrix);
+        if (object.userData.structureId) {
+          const rootGroup = this.structureRoots.get(object.userData.structureId);
+          if (rootGroup && object.parent && object.parent !== rootGroup) {
+            const origin = new Vector3(0, 0, 0);
+            origin.applyMatrix4(rootGroup.matrixWorld);
+            _offset.applyMatrix4(rootGroup.matrixWorld);
+            _offset.sub(origin);
+            const parentOrigin = new Vector3(0, 0, 0);
+            _parentInverse.copy(object.parent.matrixWorld).invert();
+            parentOrigin.applyMatrix4(_parentInverse);
+            _offset.applyMatrix4(_parentInverse);
+            _offset.sub(parentOrigin);
+          }
+        }
+        object.position.add(_offset);
+        if (object.userData.highlight) {
+          object.userData.highlight.position.copy(object.position);
+        }
+      }
+    }
   }
   createExplodeTransforms(objects = null, explodeCenter = null, explodeFactor = 1.5) {
     const transformMap = new Map();
@@ -6664,6 +6715,15 @@ class DynamicGltfLoader {
   clearTransforms() {
     this.objectTransforms.clear();
     this._resetTransformData(true);
+    if (this.syncTransformsToOriginalObjects) {
+      for (const [obj, savedPos] of this._originalObjectMatrices) {
+        obj.position.copy(savedPos);
+        if (obj.userData.highlight) {
+          obj.userData.highlight.position.copy(savedPos);
+        }
+      }
+      this._originalObjectMatrices.clear();
+    }
   }
   clearHandleTransforms() {
     this.clearTransforms();