@inweb/viewer-three 27.2.2 → 27.3.0

package/src/Viewer/loaders/DynamicGltfLoader/DynamicModelImpl.ts

@@ -133,7 +133,7 @@ export class DynamicModelImpl extends ModelImpl {
   }
 
   override explode(scale = 0, coeff = 4): this {
-    const centers = new Map();
+    const centersCache = new Map();
 
     const calcObjectCenter = (object: Object3D, target: Vector3): Vector3 => {
       const extents = new Box3().setFromObject(object);
@@ -141,74 +141,85 @@ export class DynamicModelImpl extends ModelImpl {
       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: Object3D) => extents.expandByObject(x));
       extents.getCenter(target);
 
-      centers.set(handle, target.clone());
+      centersCache.set(handle, target.clone());
 
       return target;
     };
 
-    function calcExplodeDepth(object: Object3D, depth: number): number {
-      let result = depth;
-      object.children
-        .filter((x: Object3D) => !x.userData.isOptimized)
-        .forEach((x: Object3D) => {
-          const objectDepth = calcExplodeDepth(x, depth + 1);
-          if (result < objectDepth) result = objectDepth;
-        });
+    const calcObjectDepth = (object: Object3D): number => {
+      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);
-    const maxDepth = explodeRoot.userData.explodeDepth;
+    if (!explodeRoot.userData.explodeDepth) {
+      let maxDepth = 0;
+
+      this.gltfLoader.originalObjects.forEach((object: Object3D) => {
+        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();
+    const offsetCache = new Map();
+
+    const calcObjectOffset = (object: Object3D, target: Vector3): Vector3 => {
+      if (offsetCache.has(object)) return target.copy(offsetCache.get(object));
 
-    function explodeObject(object, depth: number) {
-      if (object.isCamera) return;
-      if (object.userData.isHighlightWireframe) return;
+      const parent = object.parent;
+      if (parent && object !== explodeRoot) calcObjectOffset(parent, target);
 
-      object.position.copy(object.userData.originalPosition);
+      const depth = object.userData.depth;
 
-      if (depth > 0 && depth <= explodeDepth && !object.userData.isExplodeLocked) {
+      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);
+        const localOffset = 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);
+        target.add(localOffset);
       }
 
-      object.children
-        .filter((x: Object3D) => !x.userData.isOptimized)
-        .forEach((x: Object3D) => explodeObject(x, depth + 1));
-    }
+      offsetCache.set(object, target.clone());
 
-    explodeObject(explodeRoot, 0);
-    this.scene.updateMatrixWorld();
+      return target;
+    };
+
+    const transformMap = new Map();
+
+    this.gltfLoader.originalObjects.forEach((object: Object3D) => {
+      const globalOffset = calcObjectOffset(object, new Vector3());
+      transformMap.set(object, new Matrix4().makeTranslation(globalOffset));
+    });
 
     this.gltfLoader.applyObjectTransforms(transformMap);
+    this.scene.updateMatrixWorld();
 
     return this;
   }

package/src/Viewer/measurement/Snapper.ts

@@ -84,7 +84,12 @@ export class Snapper {
     return target.set(event.clientX, event.clientY);
   }
 
-  getPointerIntersects(mouse: Vector2, objects: Object3D[]): Array<Intersection<Object3D>> {
+  getPointerIntersects(
+    mouse: Vector2,
+    objects: Object3D[],
+    recursive = false,
+    clip = true
+  ): Array<Intersection<Object3D>> {
     const rect = this.canvas.getBoundingClientRect();
     const x = ((mouse.x - rect.left) / rect.width) * 2 - 1;
     const y = (-(mouse.y - rect.top) / rect.height) * 2 + 1;
@@ -101,11 +106,14 @@ export class Snapper {
       Sprite: {},
     };
 
-    let intersects = this.raycaster.intersectObjects(objects, false);
+    let intersects = this.raycaster.intersectObjects(objects, recursive);
 
-    (this.renderer.clippingPlanes || []).forEach((plane: Plane) => {
-      intersects = intersects.filter((intersect) => plane.distanceToPoint(intersect.point) >= 0);
-    });
+    if (clip) {
+      const clippingPlanes = this.renderer.clippingPlanes || [];
+      clippingPlanes.forEach((plane: Plane) => {
+        intersects = intersects.filter((intersect) => plane.distanceToPoint(intersect.point) >= 0);
+      });
+    }
 
     return intersects;
   }

package/src/Viewer/models/ModelImpl.ts

@@ -383,35 +383,36 @@ export class ModelImpl implements IModelImpl {
   }
 
   explode(scale = 0, coeff = 4): this {
-    const centers = new Map();
+    const centersCache = new Map();
 
-    const getObjectCenter = (object: Object3D, target: Vector3): Vector3 => {
+    const calcObjectCenter = (object: Object3D, target: Vector3): Vector3 => {
       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: Object3D) => extents.expandByObject(x));
       extents.getCenter(target);
 
-      centers.set(handle, target.clone());
+      centersCache.set(handle, target.clone());
 
       return target;
     };
 
     function calcExplodeDepth(object: Object3D, depth: number): number {
       let result = depth;
+
       object.children.forEach((x: Object3D) => {
         const objectDepth = calcExplodeDepth(x, depth + 1);
         if (result < objectDepth) result = objectDepth;
       });
 
       object.userData.originalPosition = object.position.clone();
-      object.userData.originalCenter = getObjectCenter(object, new Vector3());
+      object.userData.originalCenter = calcObjectCenter(object, new Vector3());
 
       return result;
     }
@@ -419,14 +420,16 @@ export class ModelImpl implements IModelImpl {
     const explodeScale = scale / 100;
     const explodeRoot = this.scene;
 
-    if (!explodeRoot.userData.explodeDepth) explodeRoot.userData.explodeDepth = calcExplodeDepth(explodeRoot, 1);
-    const maxDepth = 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;
     const currentSegmentFraction = scaledExplodeDepth - explodeDepth;
 
-    function explodeObject(object, depth: number) {
+    function explodeObject(object: any, depth: number) {
       if (object.isCamera) return;
       if (object.userData.isHighlightWireframe) return;
 
@@ -438,9 +441,9 @@ export class ModelImpl implements IModelImpl {
 
         const parentCenter = object.parent.userData.originalCenter;
         const objectCenter = object.userData.originalCenter;
-        const objectOffset = objectCenter.clone().sub(parentCenter).multiplyScalar(objectScale);
+        const localOffset = objectCenter.clone().sub(parentCenter).multiplyScalar(objectScale);
 
-        object.position.add(objectOffset);
+        object.position.add(localOffset);
       }
 
       object.children.forEach((x: Object3D) => explodeObject(x, depth + 1));