@inweb/viewer-three 27.2.3 → 27.3.0

package/dist/viewer-three.js

@@ -38048,19 +38048,19 @@ void main() {
             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) {
@@ -38071,13 +38071,14 @@ void main() {
                         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;
@@ -38094,8 +38095,8 @@ void main() {
                         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));
             }
@@ -38187,67 +38188,73 @@ void main() {
             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;
         }
     }
@@ -38973,6 +38980,8 @@ void main() {
         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();
@@ -40127,6 +40136,7 @@ void main() {
         this.isolatedObjects = [];
         this.objectTransforms.clear();
         this.transformedGeometries.clear();
+        this._originalObjectMatrices.clear();
         this.totalLoadedObjects = 0;
         this.currentMemoryUsage = 0;
         this.pendingMemoryUsage = 0;
@@ -40972,6 +40982,47 @@ void main() {
             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();
@@ -41055,6 +41106,15 @@ void main() {
       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();