@inweb/viewer-three 26.8.0 → 26.8.2

package/src/Viewer/helpers/WCSHelper.ts

@@ -105,15 +105,18 @@ export class WCSHelper extends Object3D {
     this.quaternion.copy(this.camera.quaternion).invert();
     this.updateMatrixWorld();
 
-    const clippingPlanes = renderer.clippingPlanes;
-    const viewport = renderer.getViewport(new Vector4());
+    const oldAutoClear = renderer.autoClear;
+    const oldClippingPlanes = renderer.clippingPlanes;
+    const oldViewport = renderer.getViewport(new Vector4());
 
-    renderer.setViewport(this.position.x, this.position.y, this.size, this.size);
+    renderer.autoClear = false;
     renderer.clippingPlanes = [];
+    renderer.setViewport(this.position.x, this.position.y, this.size, this.size);
     renderer.clearDepth();
     renderer.render(this, this.orthoCamera);
 
-    renderer.setViewport(viewport);
-    renderer.clippingPlanes = clippingPlanes;
+    renderer.setViewport(oldViewport);
+    renderer.clippingPlanes = oldClippingPlanes;
+    renderer.autoClear = oldAutoClear;
   }
 }

package/src/Viewer/loaders/DynamicGltfLoader/DynamicGltfLoader.js

@@ -1,7 +1,6 @@
 import {
   BufferGeometry,
   PointsMaterial,
-  Material,
   Points,
   Mesh,
   TriangleStripDrawMode,
@@ -14,7 +13,7 @@ import {
   Quaternion,
   Matrix4,
   Box3,
-  MeshStandardMaterial,
+  MeshPhongMaterial,
   Color,
   MathUtils,
   PerspectiveCamera,
@@ -369,19 +368,19 @@ export class DynamicGltfLoader {
 
         let material;
         if (primitive.material !== undefined) {
-          material = node.structure.materials.get(primitive.material) || this.createDefaultMaterial();
+          material = node.structure.getCachedMaterial(primitive.material, primitive.mode);
+
+          if (!material) {
+            const materialDef = node.structure.json.materials[primitive.material];
+            material = node.structure.createMaterial(materialDef, primitive.mode);
+          }
         } else {
-          material = this.createDefaultMaterial();
+          material = this.createDefaultMaterial(primitive.mode);
         }
 
         let mesh;
         if (primitive.mode === GL_CONSTANTS.POINTS) {
-          const pointsMaterial = new PointsMaterial();
-          Material.prototype.copy.call(pointsMaterial, material);
-          pointsMaterial.color.copy(material.color);
-          pointsMaterial.map = material.map;
-          pointsMaterial.sizeAttenuation = false;
-          mesh = new Points(geometry, pointsMaterial);
+          mesh = new Points(geometry, material);
         } else if (
           primitive.mode === GL_CONSTANTS.TRIANGLES ||
           primitive.mode === GL_CONSTANTS.TRIANGLE_STRIP ||
@@ -660,6 +659,10 @@ export class DynamicGltfLoader {
         this.edgeNodes.push(uniqueNodeId);
       }
 
+      if (meshDef.extras && meshDef.extras.handle) {
+        handle = `${structure.id}_${meshDef.extras.handle}`;
+      }
+
       this.nodes.set(uniqueNodeId, {
         position: nodeGroup ? nodeGroup.position.clone() : new Vector3().setFromMatrixPosition(nodeMatrix),
         nodeIndex: nodeId,
@@ -780,12 +783,12 @@ export class DynamicGltfLoader {
     });
   }
 
-  createDefaultMaterial() {
-    if (this.currentPrimitiveMode === GL_CONSTANTS.POINTS) {
+  createDefaultMaterial(primitiveMode = undefined) {
+    if (primitiveMode === GL_CONSTANTS.POINTS) {
       return new PointsMaterial({
         color: new Color(0x808080),
         size: 0.05,
-        sizeAttenuation: true,
+        sizeAttenuation: false,
         alphaTest: 0.5,
         transparent: true,
         vertexColors: false,
@@ -793,11 +796,25 @@ export class DynamicGltfLoader {
         depthWrite: false,
         depthTest: true,
       });
+    } else if (
+      primitiveMode === GL_CONSTANTS.LINES ||
+      primitiveMode === GL_CONSTANTS.LINE_STRIP ||
+      primitiveMode === GL_CONSTANTS.LINE_LOOP
+    ) {
+      return new LineBasicMaterial({
+        color: 0x808080,
+        linewidth: 1.0,
+        alphaTest: 0.1,
+        depthTest: true,
+        depthWrite: true,
+        transparent: true,
+        opacity: 1.0,
+      });
     } else {
-      return new MeshStandardMaterial({
+      return new MeshPhongMaterial({
         color: 0x808080,
-        metalness: 0.0,
-        roughness: 1.0,
+        specular: 0x222222,
+        shininess: 10,
         side: DoubleSide,
       });
     }

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

@@ -23,13 +23,14 @@
 
 import { Box3, Object3D } from "three";
 
-import { ModelImpl } from "../../model";
+import { ModelImpl } from "../../models/ModelImpl";
 import { DynamicGltfLoader } from "./DynamicGltfLoader.js";
 
 // Dynamic model implementation.
 
 export class DynamicModelImpl extends ModelImpl {
   public gltfLoader: DynamicGltfLoader;
+  public modelId: number;
 
   override getExtents(target: Box3): Box3 {
     return target.union(this.gltfLoader.getTotalGeometryExtent());
@@ -55,26 +56,32 @@ export class DynamicModelImpl extends ModelImpl {
     const handlesSet = new Set(handles);
     const objects = [];
     handlesSet.forEach((handle) => {
-      const handles = this.gltfLoader.handleToObjects.get(handle) || [];
+      const handle2 = `${this.modelId}_${handle}`; // <- props fix: Dynamic Loader uses handle with structure ID prefix
+      const handles = this.gltfLoader.handleToObjects.get(handle2) || [];
       objects.push(...Array.from(handles));
     });
     return objects;
   }
 
+  override getHandlesByObjects(objects: Object3D | Object3D[]): string[] {
+    const handles = super.getHandlesByObjects(objects);
+    return handles.map((x) => x.split("_").pop()); // <- props fix: remove structure ID prefix by the Dynamic Loader
+  }
+
   override hideObjects(objects: Object3D | Object3D[]): this {
-    const handles = this.getHandlesByObjects(objects);
+    const handles = super.getHandlesByObjects(objects);
     this.gltfLoader.hideObjects(handles);
     return this;
   }
 
   override isolateObjects(objects: Object3D | Object3D[]): this {
-    const handles = this.getHandlesByObjects(objects);
+    const handles = super.getHandlesByObjects(objects);
     this.gltfLoader.isolateObjects(new Set(handles));
     return this;
   }
 
   override showObjects(objects: Object3D | Object3D[]): this {
-    const handles = this.getHandlesByObjects(objects);
+    const handles = super.getHandlesByObjects(objects);
     this.gltfLoader.showObjects(handles);
     return this;
   }

package/src/Viewer/loaders/DynamicGltfLoader/GltfStructure.js

@@ -1,4 +1,12 @@
-import { TextureLoader, BufferAttribute, Color, DoubleSide, MeshPhongMaterial } from "three";
+import {
+  TextureLoader,
+  BufferAttribute,
+  Color,
+  DoubleSide,
+  MeshPhongMaterial,
+  PointsMaterial,
+  LineBasicMaterial,
+} from "three";
 
 export const GL_COMPONENT_TYPES = {
   5120: Int8Array,
@@ -48,6 +56,7 @@ export class GltfStructure {
     this.textureLoader = new TextureLoader();
     this.materials = new Map();
     this.textureCache = new Map();
+    this.materialCache = new Map();
   }
 
   async initialize(loadController) {
@@ -346,19 +355,29 @@ export class GltfStructure {
     await Promise.all(texturePromises);
   }
 
-  async loadMaterials() {
+  loadMaterials() {
     if (!this.json.materials) return this.materials;
 
     for (let i = 0; i < this.json.materials.length; i++) {
       const materialDef = this.json.materials[i];
-      const material = await this.createMaterial(materialDef);
-      material.name = materialDef.name;
-      this.materials.set(i, material);
+
+      const materialCacheKey = `material_${i}`;
+      this.materialCache.set(materialCacheKey, {
+        mesh: this.createMaterial(materialDef, GL_CONSTANTS.TRIANGLES),
+        points: this.createMaterial(materialDef, GL_CONSTANTS.POINTS),
+        lines: this.createMaterial(materialDef, GL_CONSTANTS.LINES),
+      });
+
+      this.materialCache.get(materialCacheKey).mesh.name = materialDef.name;
+      this.materialCache.get(materialCacheKey).points.name = materialDef.name;
+      this.materialCache.get(materialCacheKey).lines.name = materialDef.name;
+
+      this.materials.set(i, this.materialCache.get(materialCacheKey).mesh);
     }
     return this.materials;
   }
 
-  createMaterial(materialDef) {
+  createMaterial(materialDef, primitiveMode = undefined) {
     const params = {};
 
     if (materialDef.pbrMetallicRoughness) {
@@ -373,21 +392,10 @@ export class GltfStructure {
       }
     }
 
-    params.specular = 0x222222;
-    params.shininess = 10;
-    params.reflectivity = 0.05;
-    params.polygonOffset = true;
-    params.polygonOffsetFactor = 1;
-    params.polygonOffsetUnits = 1;
-
     if (materialDef.emissiveFactor) {
       params.emissive = new Color().fromArray(materialDef.emissiveFactor);
     }
 
-    if (materialDef.normalTexture) {
-      params.normalMap = this.textureCache.get(materialDef.normalTexture.index);
-    }
-
     if (materialDef.alphaMode === "BLEND") {
       params.transparent = true;
     }
@@ -395,16 +403,61 @@ export class GltfStructure {
     if (materialDef.doubleSided) {
       params.side = DoubleSide;
     }
-    const material = new MeshPhongMaterial(params);
+    let material;
+
+    if (primitiveMode === GL_CONSTANTS.POINTS) {
+      params.sizeAttenuation = false;
+      material = new PointsMaterial(params);
+      material.sizeAttenuation = false;
+    } else if (
+      primitiveMode === GL_CONSTANTS.LINES ||
+      primitiveMode === GL_CONSTANTS.LINE_STRIP ||
+      primitiveMode === GL_CONSTANTS.LINE_LOOP
+    ) {
+      material = new LineBasicMaterial(params);
+    } else {
+      params.specular = 0x222222;
+      params.shininess = 10;
+      params.reflectivity = 0.05;
+      params.polygonOffset = true;
+      params.polygonOffsetFactor = 1;
+      params.polygonOffsetUnits = 1;
+
+      if (materialDef.normalTexture) {
+        params.normalMap = this.textureCache.get(materialDef.normalTexture.index);
+      }
+
+      material = new MeshPhongMaterial(params);
+    }
+
     return material;
   }
 
+  getCachedMaterial(materialIndex, primitiveMode) {
+    const materialCacheKey = `material_${materialIndex}`;
+    const materialCache = this.materialCache.get(materialCacheKey);
+
+    if (materialCache) {
+      if (primitiveMode === GL_CONSTANTS.POINTS) {
+        return materialCache.points;
+      } else if (
+        primitiveMode === GL_CONSTANTS.LINES ||
+        primitiveMode === GL_CONSTANTS.LINE_STRIP ||
+        primitiveMode === GL_CONSTANTS.LINE_LOOP
+      ) {
+        return materialCache.lines;
+      } else {
+        return materialCache.mesh;
+      }
+    }
+
+    return null;
+  }
+
   disposeMaterials() {
-    // Dispose all textures
     this.textureCache.forEach((texture) => texture.dispose());
     this.textureCache.clear();
 
-    // Dispose all materials
     this.materials.forEach((material) => {
       if (material.map) material.map.dispose();
       if (material.lightMap) material.lightMap.dispose();
@@ -419,6 +472,33 @@ export class GltfStructure {
       material.dispose();
     });
     this.materials.clear();
+
+    this.materialCache.forEach((materialCache) => {
+      if (materialCache.mesh) {
+        if (materialCache.mesh.map) materialCache.mesh.map.dispose();
+        if (materialCache.mesh.lightMap) materialCache.mesh.lightMap.dispose();
+        if (materialCache.mesh.bumpMap) materialCache.mesh.bumpMap.dispose();
+        if (materialCache.mesh.normalMap) materialCache.mesh.normalMap.dispose();
+        if (materialCache.mesh.specularMap) materialCache.mesh.specularMap.dispose();
+        if (materialCache.mesh.envMap) materialCache.mesh.envMap.dispose();
+        if (materialCache.mesh.aoMap) materialCache.mesh.aoMap.dispose();
+        if (materialCache.mesh.metalnessMap) materialCache.mesh.metalnessMap.dispose();
+        if (materialCache.mesh.roughnessMap) materialCache.mesh.roughnessMap.dispose();
+        if (materialCache.mesh.emissiveMap) materialCache.mesh.emissiveMap.dispose();
+        materialCache.mesh.dispose();
+      }
+
+      if (materialCache.points) {
+        if (materialCache.points.map) materialCache.points.map.dispose();
+        materialCache.points.dispose();
+      }
+
+      if (materialCache.lines) {
+        if (materialCache.lines.map) materialCache.lines.map.dispose();
+        materialCache.lines.dispose();
+      }
+    });
+    this.materialCache.clear();
   }
 
   estimateNodeSize(meshIndex) {

package/src/Viewer/loaders/GLTFCloudDynamicLoader.ts

@@ -57,12 +57,14 @@ export class GLTFCloudDynamicLoader implements ILoader {
 
     this.gltfLoader = new DynamicGltfLoader(this.viewer.camera, scene, this.viewer.renderer);
     this.gltfLoader.memoryLimit = this.viewer.options.memoryLimit;
+    this.gltfLoader.setVisibleEdges(this.viewer.options.edgeModel);
 
     this.gltfLoader.addEventListener("databasechunk", (data) => {
       const modelImpl = new DynamicModelImpl(scene);
       modelImpl.loader = this;
-      modelImpl.gltfLoader = this.gltfLoader;
       modelImpl.viewer = this.viewer;
+      modelImpl.gltfLoader = this.gltfLoader;
+      modelImpl.modelId = model.id;
 
       this.viewer.scene.add(scene);
       this.viewer.models.push(modelImpl);
@@ -124,7 +126,7 @@ export class GLTFCloudDynamicLoader implements ILoader {
       baseUrl: () => Promise.resolve(`${model.httpClient.serverUrl}${model.path}/`),
     };
 
-    const structure = new GltfStructure(1);
+    const structure = new GltfStructure(model.id);
     await structure.initialize(loadController);
 
     await this.gltfLoader.loadStructure(structure);

package/src/Viewer/loaders/GLTFFileLoader.ts

@@ -26,7 +26,7 @@ import { Loader } from "@inweb/viewer-core";
 
 import { Viewer } from "../Viewer";
 import { GLTFLoadingManager, GLTFLoadParams } from "./GLTFLoadingManager";
-import { ModelImpl } from "../model/ModelImpl";
+import { ModelImpl } from "../models/ModelImpl";
 
 export class GLTFFileLoader extends Loader {
   public viewer: Viewer;

package/src/Viewer/models/IModelImpl.ts

@@ -0,0 +1,67 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { Box3, Object3D } from "three";
+import { ILoader, IViewer } from "@inweb/viewer-core";
+
+/**
+ * Model interface.
+ */
+export interface IModelImpl {
+  handle: string;
+  scene: Object3D;
+  loader: ILoader;
+  viewer: IViewer;
+
+  dispose(): void;
+
+  getExtents(target: Box3): Box3;
+
+  getObjects(): Object3D[];
+
+  getVisibleObjects(): Object3D[];
+
+  hasObject(objects: Object3D): boolean;
+
+  getOwnObjects(objects: Object3D | Object3D[]): Object3D[];
+
+  getObjectsByHandles(handles: string | string[]): Object3D[];
+
+  getHandlesByObjects(objects: Object3D | Object3D[]): string[];
+
+  hideObjects(objects: Object3D | Object3D[]): this;
+
+  hideAllObjects(): this;
+
+  isolateObjects(objects: Object3D | Object3D[]): this;
+
+  showObjects(objects: Object3D | Object3D[]): this;
+
+  showAllObjects(): this;
+
+  showOriginalObjects(objects: Object3D | Object3D[]): this;
+
+  hideOriginalObjects(objects: Object3D | Object3D[]): this;
+
+  explode(scale: number, coeff?: number): this;
+}

package/src/Viewer/models/ModelImpl.ts

@@ -0,0 +1,214 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { Box3, Object3D, Vector3 } from "three";
+import { ILoader } from "@inweb/viewer-core";
+
+import { IModelImpl } from "./IModelImpl";
+import { Viewer } from "../Viewer";
+
+// Basic model implementation.
+
+export class ModelImpl implements IModelImpl {
+  public handle: string;
+  public scene: Object3D;
+  public loader: ILoader;
+  public viewer: Viewer;
+
+  constructor(scene: Object3D) {
+    this.handle = "1";
+    this.scene = scene;
+  }
+
+  dispose() {
+    function disposeMaterial(material: any) {
+      // if (material.alphaMap) material.alphaMap.dispose();
+      // if (material.anisotropyMap) material.anisotropyMap.dispose();
+      // if (material.aoMap) material.aoMap.dispose();
+      // if (material.bumpMap) material.bumpMap.dispose();
+      // if (material.clearcoatMap) material.clearcoatMap.dispose();
+      // if (material.clearcoatNormalMap) material.clearcoatNormalMap.dispose();
+      // if (material.clearcoatRoughnessMap) material.clearcoatRoughnessMap.dispose();
+      // if (material.displacementMap) material.displacementMap.dispose();
+      // if (material.emissiveMap) material.emissiveMap.dispose();
+      // if (material.gradientMap) material.gradientMap.dispose();
+      // if (material.envMap) material.envMap.dispose();
+      // if (material.iridescenceMap) material.iridescenceMap.dispose();
+      // if (material.lightMap) material.lightMap.dispose();
+      // if (material.map) material.map.dispose();
+      // if (material.metalnessMap) material.metalnessMap.dispose();
+      // if (material.normalMap) material.normalMap.dispose();
+      // if (material.roughnessMap) material.roughnessMap.dispose();
+      // if (material.sheenColorMap) material.sheenColorMap.dispose();
+      // if (material.sheenRoughnessMap) material.sheenRoughnessMap.dispose();
+      // if (material.specularMap) material.specularMap.dispose();
+      // if (material.thicknessMap) material.thicknessMap.dispose();
+      // if (material.transmissionMap) material.transmissionMap.dispose();
+      material.dispose();
+    }
+
+    function disposeMaterials(material: any) {
+      const materials = Array.isArray(material) ? material : [material];
+      materials.forEach((material: any) => disposeMaterial(material));
+    }
+
+    function disposeObject(object: any) {
+      if (object.geometry) object.geometry.dispose();
+      if (object.material) disposeMaterials(object.material);
+    }
+
+    this.scene.traverse(disposeObject);
+    this.scene.clear();
+  }
+
+  getExtents(target: Box3): Box3 {
+    this.scene.traverseVisible((object) => !object.children.length && target.expandByObject(object));
+    return target;
+  }
+
+  getObjects(): Object3D[] {
+    const objects = [];
+    this.scene.traverse((object) => objects.push(object));
+    return objects;
+  }
+
+  getVisibleObjects(): Object3D[] {
+    const objects = [];
+    this.scene.traverseVisible((object) => objects.push(object));
+    return objects;
+  }
+
+  hasObject(object: Object3D): boolean {
+    while (object) {
+      if (object === this.scene) return true;
+      object = object.parent;
+    }
+    return false;
+  }
+
+  getOwnObjects(objects: Object3D | Object3D[]): Object3D[] {
+    if (!Array.isArray(objects)) objects = [objects];
+    return objects.filter((object) => this.hasObject(object));
+  }
+
+  getObjectsByHandles(handles: string | string[]): Object3D[] {
+    const handleSet = new Set(handles);
+    const objects = [];
+    this.scene.traverse((object) => handleSet.has(object.userData.handle) && objects.push(object));
+    return objects;
+  }
+
+  getHandlesByObjects(objects: Object3D | Object3D[]): string[] {
+    if (!Array.isArray(objects)) objects = [objects];
+    const handlesSet = new Set<string>();
+    this.getOwnObjects(objects).forEach((object) => handlesSet.add(object.userData.handle));
+    return Array.from(handlesSet);
+  }
+
+  hideObjects(objects: Object3D | Object3D[]): this {
+    if (!Array.isArray(objects)) objects = [objects];
+    this.getOwnObjects(objects).forEach((object) => (object.visible = false));
+    return this;
+  }
+
+  hideAllObjects(): this {
+    return this.isolateObjects([]);
+  }
+
+  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)));
+    this.scene.traverse((object) => (object.visible = visibleSet.has(object)));
+    return this;
+  }
+
+  showObjects(objects: Object3D | Object3D[]): this {
+    if (!Array.isArray(objects)) objects = [objects];
+    this.getOwnObjects(objects).forEach((object) => {
+      object.visible = true;
+      object.traverseAncestors((parent) => (parent.visible = true));
+    });
+    return this;
+  }
+
+  showAllObjects(): this {
+    this.scene.traverse((object) => (object.visible = true));
+    return this;
+  }
+
+  showOriginalObjects(objects: Object3D | Object3D[]): this {
+    return this;
+  }
+
+  hideOriginalObjects(objects: Object3D | Object3D[]): this {
+    return this;
+  }
+
+  explode(scale = 0, coeff = 4): this {
+    function calcExplodeDepth(object: Object3D, depth: number): number {
+      let res = depth;
+      object.children.forEach((x: Object3D) => {
+        const objectDepth = calcExplodeDepth(x, depth + 1);
+        if (res < objectDepth) res = 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;
+
+      return res;
+    }
+
+    scale /= 100;
+
+    if (!this.scene.userData.explodeDepth) this.scene.userData.explodeDepth = calcExplodeDepth(this.scene, 1);
+    const maxDepth = this.scene.userData.explodeDepth;
+
+    const scaledExplodeDepth = scale * maxDepth + 1;
+    const explodeDepth = 0 | scaledExplodeDepth;
+    const currentSegmentFraction = scaledExplodeDepth - explodeDepth;
+
+    function explodeObject(object: Object3D, depth: number) {
+      object.position.copy(object.userData.originalPosition);
+
+      if (depth > 0 && depth <= explodeDepth && !object.userData.isExplodeLocked) {
+        let objectScale = scale * coeff;
+        if (depth === explodeDepth) 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);
+      }
+
+      object.children.forEach((x) => explodeObject(x, depth + 1));
+    }
+
+    explodeObject(this.scene, 0);
+    this.scene.updateMatrixWorld();
+
+    return this;
+  }
+}