@inweb/viewer-three 26.12.6 → 27.1.0

package/src/Viewer/models/ModelImpl.ts

@@ -32,8 +32,29 @@ export class ModelImpl implements IModelImpl {
   public id: string;
   public scene: Object3D;
 
+  private handleToObjects: Map<any, Set<Object3D>>;
+  private originalObjects: Set<Object3D>;
+
   constructor(scene: Object3D) {
     this.scene = scene;
+
+    this.handleToObjects = new Map();
+    this.originalObjects = new Set();
+
+    this.scene.traverse((object) => {
+      this.originalObjects.add(object);
+
+      const handle = object.userData.handle;
+      if (!handle) return;
+
+      let objects = this.handleToObjects.get(handle);
+      if (!objects) {
+        objects = new Set();
+        this.handleToObjects.set(handle, objects);
+      }
+
+      objects.add(object);
+    });
   }
 
   dispose() {
@@ -73,6 +94,9 @@ export class ModelImpl implements IModelImpl {
       if (object.material) disposeMaterials(object.material);
     }
 
+    this.handleToObjects = undefined;
+    this.originalObjects = undefined;
+
     this.scene.traverse(disposeObject);
     this.scene.clear();
   }
@@ -250,74 +274,65 @@ export class ModelImpl implements IModelImpl {
   }
 
   getExtents(target: Box3): Box3 {
-    this.scene.traverseVisible((object) => !object.children.length && target.expandByObject(object));
+    this.scene.traverseVisible((object) => target.expandByObject(object));
     return target;
   }
 
   getObjects(): Object3D[] {
-    const objects = [];
-    this.scene.traverse((object) => objects.push(object));
-    return objects;
+    return Array.from(this.originalObjects);
   }
 
   getVisibleObjects(): Object3D[] {
     const objects = [];
     this.scene.traverseVisible((object) => objects.push(object));
-    return objects;
+    return objects.filter((object) => object.userData.handle);
   }
 
-  hasObject(object: Object3D): boolean {
-    while (object) {
-      if (object === this.scene) return true;
-      object = object.parent;
-    }
-    return false;
-  }
-
-  hasHandle(handle: string): boolean {
-    return !handle.includes(":") || handle.split(":", 1)[0] === this.id + "";
-  }
-
-  getOwnObjects(objects: Object3D | Object3D[]): Object3D[] {
-    if (!Array.isArray(objects)) objects = [objects];
-    return objects.filter((object) => this.hasObject(object));
-  }
-
-  getOwnHandles(handles: string | string[]): string[] {
+  getObjectsByHandles(handles: string | string[]): Object3D[] {
     if (!Array.isArray(handles)) handles = [handles];
-    return handles.filter((handle) => this.hasHandle(handle));
-  }
 
-  getObjectsByHandles(handles: string | string[]): Object3D[] {
-    const ownHandles = this.getOwnHandles(handles);
-    if (ownHandles.length === 0) return [];
+    const ownHandles = [];
+    handles.forEach((handle) => {
+      const index = handle.indexOf(":");
+      if (index !== -1) {
+        if (handle.slice(0, index) !== this.id) return;
+        handle = handle.slice(index + 1);
+      }
+      ownHandles.push(handle);
+    });
 
-    const handleSet = new Set(ownHandles.map((handle) => handle.slice(handle.indexOf(":") + 1)));
+    const handlesSet = new Set<string>(ownHandles);
 
     const objects = [];
-    this.scene.traverse((object) => {
-      const handle = object.userData.handle;
-      if (handle && handleSet.has(handle)) objects.push(object);
+    handlesSet.forEach((handle) => {
+      objects.push(Array.from(this.handleToObjects.get(handle) || []));
     });
 
-    return objects;
+    return objects.flat();
   }
 
   getHandlesByObjects(objects: Object3D | Object3D[]): string[] {
-    const ownObjects = this.getOwnObjects(objects);
-    if (ownObjects.length === 0) return [];
+    if (!Array.isArray(objects)) objects = [objects];
 
     const handleSet = new Set<string>();
-    ownObjects.forEach((object) => {
-      const handle = object.userData.handle;
-      if (handle) handleSet.add(`${this.id}:${handle}`);
-    });
+    objects
+      .filter((object) => this.originalObjects.has(object))
+      .forEach((object) => {
+        handleSet.add(`${this.id}:${object.userData.handle}`);
+      });
 
     return Array.from(handleSet);
   }
 
   hideObjects(objects: Object3D | Object3D[]): this {
-    this.getOwnObjects(objects).forEach((object) => (object.visible = false));
+    if (!Array.isArray(objects)) objects = [objects];
+
+    objects
+      .filter((object) => this.originalObjects.has(object))
+      .forEach((object) => {
+        object.visible = false;
+      });
+
     return this;
   }
 
@@ -327,17 +342,29 @@ export class ModelImpl implements IModelImpl {
 
   isolateObjects(objects: Object3D | Object3D[]): this {
     if (!Array.isArray(objects)) objects = [objects];
+
     const visibleSet = new Set(objects);
-    this.getOwnObjects(objects).forEach((object) => object.traverseAncestors((parent) => visibleSet.add(parent)));
+    objects
+      .filter((object) => this.originalObjects.has(object))
+      .forEach((object) => {
+        object.traverseAncestors((parent) => visibleSet.add(parent));
+      });
+
     this.scene.traverse((object) => (object.visible = visibleSet.has(object)));
+
     return this;
   }
 
   showObjects(objects: Object3D | Object3D[]): this {
-    this.getOwnObjects(objects).forEach((object) => {
-      object.visible = true;
-      object.traverseAncestors((parent) => (parent.visible = true));
-    });
+    if (!Array.isArray(objects)) objects = [objects];
+
+    objects
+      .filter((object) => this.originalObjects.has(object))
+      .forEach((object) => {
+        object.visible = true;
+        object.traverseAncestors((parent) => (parent.visible = true));
+      });
+
     return this;
   }
 
@@ -346,43 +373,66 @@ export class ModelImpl implements IModelImpl {
     return this;
   }
 
-  showOriginalObjects(objects: Object3D | Object3D[]): this {
+  highlightObjects(objects: Object3D | Object3D[]): this {
     return this;
   }
 
-  hideOriginalObjects(objects: Object3D | Object3D[]): this {
+  unhighlightObjects(objects: Object3D | Object3D[]): this {
     return this;
   }
 
   explode(scale = 0, coeff = 4): this {
+    const centers = new Map();
+
+    const getObjectCenter = (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);
+      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());
+
+      return target;
+    };
+
     function calcExplodeDepth(object: Object3D, depth: number): number {
-      let res = depth;
+      let result = depth;
       object.children.forEach((x: Object3D) => {
         const objectDepth = calcExplodeDepth(x, depth + 1);
-        if (res < objectDepth) res = objectDepth;
+        if (result < objectDepth) result = objectDepth;
       });
 
       object.userData.originalPosition = object.position.clone();
-      object.userData.originalCenter = new Box3().setFromObject(object).getCenter(new Vector3());
-      object.userData.isExplodeLocked = depth > 2 && object.children.length === 0;
+      object.userData.originalCenter = getObjectCenter(object, new Vector3());
 
-      return res;
+      return result;
     }
 
-    scale /= 100;
+    const explodeScale = scale / 100;
+    const explodeRoot = this.scene;
 
-    if (!this.scene.userData.explodeDepth) this.scene.userData.explodeDepth = calcExplodeDepth(this.scene, 1);
-    const maxDepth = this.scene.userData.explodeDepth;
+    if (!explodeRoot.userData.explodeDepth) explodeRoot.userData.explodeDepth = calcExplodeDepth(explodeRoot, 1);
+    const maxDepth = explodeRoot.userData.explodeDepth;
 
-    const scaledExplodeDepth = scale * maxDepth + 1;
+    const scaledExplodeDepth = explodeScale * maxDepth + 1;
     const explodeDepth = 0 | scaledExplodeDepth;
     const currentSegmentFraction = scaledExplodeDepth - explodeDepth;
 
-    function explodeObject(object: Object3D, depth: number) {
+    function explodeObject(object, depth: number) {
+      if (object.isCamera) return;
+      if (object.userData.isHighlightWireframe) return;
+
       object.position.copy(object.userData.originalPosition);
 
-      if (depth > 0 && depth <= explodeDepth && !object.userData.isExplodeLocked) {
-        let objectScale = scale * coeff;
+      if (depth > 0 && depth <= explodeDepth) {
+        let objectScale = explodeScale * coeff;
         if (depth === explodeDepth) objectScale *= currentSegmentFraction;
 
         const parentCenter = object.parent.userData.originalCenter;
@@ -392,10 +442,10 @@ export class ModelImpl implements IModelImpl {
         object.position.add(objectOffset);
       }
 
-      object.children.forEach((x) => explodeObject(x, depth + 1));
+      object.children.forEach((x: Object3D) => explodeObject(x, depth + 1));
     }
 
-    explodeObject(this.scene, 0);
+    explodeObject(explodeRoot, 0);
     this.scene.updateMatrixWorld();
 
     return this;