@inweb/viewer-three 26.12.5 → 26.12.7

package/dist/viewer-three.js

@@ -33829,6 +33829,7 @@ void main() {
             this.changed = false;
             this.viewer = viewer;
             this.viewer.addEventListener("databasechunk", this.updateControls);
+            this.viewer.addEventListener("clear", this.updateControls);
             this.viewer.on("viewposition", this.updateControls);
             this.viewer.addEventListener("zoom", this.updateControls);
             this.viewer.addEventListener("drawviewpoint", this.updateControls);
@@ -33840,6 +33841,7 @@ void main() {
         initialize() { }
         dispose() {
             this.viewer.removeEventListener("databasechunk", this.updateControls);
+            this.viewer.removeEventListener("clear", this.updateControls);
             this.viewer.off("viewposition", this.updateControls);
             this.viewer.removeEventListener("zoom", this.updateControls);
             this.viewer.removeEventListener("drawviewpoint", this.updateControls);
@@ -33937,20 +33939,25 @@ void main() {
         }
     }
 
+    const DisplayUnits = {
+        Meters: { name: "Meters", symbol: "m", scale: 1.0 },
+        Centimeters: { name: "Centimeters", symbol: "cm", scale: 0.01 },
+        Millimeters: { name: "Millimeters", symbol: "mm", scale: 0.001 },
+        Feet: { name: "Feet", symbol: "ft", scale: 0.3048 },
+        Inches: { name: "Inches", symbol: "in", scale: 0.0254 },
+        Yards: { name: "Yards", symbol: "yd", scale: 0.9144 },
+        Kilometers: { name: "Kilometers", symbol: "km", scale: 1000.0 },
+        Miles: { name: "Miles", symbol: "mi", scale: 1609.344 },
+        Micrometers: { name: "Micrometers", symbol: "µm", scale: 0.000001 },
+        Mils: { name: "Mils", symbol: "mil", scale: 0.0000254 },
+        MicroInches: { name: "Micro-inches", symbol: "µin", scale: 0.0000000254 },
+        Default: { name: "File units", symbol: "", scale: 1.0 },
+    };
     const ModelUnits = {
-        Meters: { name: "Meters", type: "m", scale: 1.0 },
-        Centimeters: { name: "Centimeters", type: "cm", scale: 0.01 },
-        Millimeters: { name: "Millimeters", type: "mm", scale: 0.001 },
-        Feet: { name: "Feet", type: "ft", scale: 0.3048 },
-        Inches: { name: "Inches", type: "in", scale: 0.0254 },
-        Yards: { name: "Yards", type: "yd", scale: 0.9144 },
-        Kilometers: { name: "Kilometers", type: "km", scale: 1000.0 },
-        Miles: { name: "Miles", type: "mi", scale: 1609.344 },
-        Micrometers: { name: "Micrometers", type: "µm", scale: 0.000001 },
-        Mils: { name: "Mils", type: "mil", scale: 0.0000254 },
-        MicroInches: { name: "Micro-inches", type: "µin", scale: 0.0000000254 },
-        Default: { name: "File units", type: "unit", scale: 1.0 },
+        Default: { name: "", symbol: "", scale: 1.0 },
     };
+    Object.keys(DisplayUnits).forEach((key) => (ModelUnits[key] = DisplayUnits[key]));
+    Object.keys(DisplayUnits).forEach((key) => (ModelUnits[DisplayUnits[key].symbol] = DisplayUnits[key]));
     function convertUnits(fromUnits, toUnits, distance) {
         const fromFactor = 1 / (ModelUnits[fromUnits] || ModelUnits.Default).scale;
         const toFactor = (ModelUnits[toUnits] || ModelUnits.Default).scale || 1;
@@ -33958,7 +33965,7 @@ void main() {
     }
 
     function getDisplayUnit(units) {
-        return (ModelUnits[units] || ModelUnits.Default).type;
+        return (ModelUnits[units] || ModelUnits.Default).symbol;
     }
     function calculatePrecision(value) {
         const distance = Math.abs(value);
@@ -33995,7 +34002,7 @@ void main() {
         else if (digits > 10)
             digits = 10;
         if (ModelUnits[units]) {
-            return formatNumber(distance, digits, precision) + " " + ModelUnits[units].type;
+            return formatNumber(distance, digits, precision) + " " + ModelUnits[units].symbol;
         }
         else if (units) {
             return formatNumber(distance, digits, precision) + " " + units;
@@ -34018,6 +34025,7 @@ void main() {
             this.camera = camera;
             this.renderer = renderer;
             this.canvas = canvas;
+            this.threshold = 0.0001;
             this.raycaster = new Raycaster();
             this.detectRadiusInPixels = this.isMobile() ? MOBILE_SNAP_DISTANCE : DESKTOP_SNAP_DISTANCE;
             this.edgesCache = new WeakMap();
@@ -34038,10 +34046,10 @@ void main() {
             this.raycaster.setFromCamera(coords, this.camera);
             this.raycaster.params = {
                 Mesh: {},
-                Line: { threshold: 0.05 },
-                Line2: { threshold: 0.05 },
+                Line: { threshold: this.threshold },
+                Line2: { threshold: this.threshold },
                 LOD: {},
-                Points: { threshold: 0.01 },
+                Points: { threshold: this.threshold },
                 Sprite: {},
             };
             let intersects = this.raycaster.intersectObjects(objects, false);
@@ -34210,6 +34218,7 @@ void main() {
             this.line = new MeasureLine(this.overlay, this.scale, this.units, this.precision);
             this.overlay.addLine(this.line);
             this.snapper = new Snapper(viewer.camera, viewer.renderer, viewer.canvas);
+            this.snapper.threshold = viewer.extents.getSize(new Vector3()).length() / 10000;
             this.objects = [];
             this.updateObjects();
             this.updateUnits();
@@ -35213,7 +35222,7 @@ void main() {
         const boxCenter = box.getCenter(new Vector3());
         const boxSize = box.getBoundingSphere(new Sphere()).radius;
         const rendererSize = viewer.renderer.getSize(new Vector2());
-        const aspect = rendererSize.x / rendererSize.y;
+        const aspectRatio = rendererSize.x / rendererSize.y;
         const camera = viewer.camera;
         if (camera.isPerspectiveCamera) {
             const offset = new Vector3(0, 0, 1)
@@ -35225,8 +35234,8 @@ void main() {
         if (camera.isOrthographicCamera) {
             camera.top = boxSize;
             camera.bottom = -boxSize;
-            camera.left = camera.bottom * aspect;
-            camera.right = camera.top * aspect;
+            camera.left = camera.bottom * aspectRatio;
+            camera.right = camera.top * aspectRatio;
             camera.zoom = 1;
             camera.updateProjectionMatrix();
             const offset = new Vector3(0, 0, 1)
@@ -35287,9 +35296,9 @@ void main() {
     function getSelected2(viewer) {
         const handles2 = [];
         viewer.models.forEach((model) => {
-            handles2.push(...model.getHandlesByObjects(viewer.selected));
+            handles2.push(model.getHandlesByObjects(viewer.selected));
         });
-        return handles2;
+        return handles2.flat();
     }
 
     function hideSelected(viewer) {
@@ -35313,7 +35322,6 @@ void main() {
     }
 
     function resetView(viewer) {
-        const reset = viewer.getComponent("ResetComponent");
         viewer.executeCommand("setActiveDragger");
         viewer.executeCommand("clearSlices");
         viewer.executeCommand("clearOverlay");
@@ -35322,7 +35330,6 @@ void main() {
         viewer.executeCommand("showAll");
         viewer.executeCommand("explode", 0);
         viewer.executeCommand("zoomToExtents", true);
-        reset.resetCameraPosition();
         viewer.emit({ type: "resetview" });
     }
 
@@ -35515,15 +35522,15 @@ void main() {
         switchCamera(camera) {
             const extentsSize = this.viewer.extents.getBoundingSphere(new Sphere()).radius * 2 || 1;
             const rendererSize = this.viewer.renderer.getSize(new Vector2());
-            const aspect = rendererSize.x / rendererSize.y;
+            const aspectRatio = rendererSize.x / rendererSize.y;
             if (camera.isPerspectiveCamera) {
-                camera.aspect = aspect;
+                camera.aspect = aspectRatio;
                 camera.near = extentsSize / 1000;
                 camera.far = extentsSize * 1000;
             }
             if (camera.isOrthographicCamera) {
-                camera.left = camera.bottom * aspect;
-                camera.right = camera.top * aspect;
+                camera.left = camera.bottom * aspectRatio;
+                camera.right = camera.top * aspectRatio;
                 camera.near = 0;
                 camera.far = extentsSize * 1000;
             }
@@ -35571,10 +35578,12 @@ void main() {
 
     class ExtentsComponent {
         constructor(viewer) {
-            this.syncExtents = () => {
+            this.syncExtents = (event) => {
                 const extents = new Box3();
                 this.viewer.models.forEach((model) => model.getExtents(extents));
                 this.viewer.extents.copy(extents);
+                if (event.type !== "databasechunk" && event.target !== "clear")
+                    return;
                 if (this.viewer.models.length > 1)
                     return;
                 this.viewer.extents.getCenter(this.viewer.target);
@@ -36580,12 +36589,12 @@ void main() {
             const { edgesVisibility } = this.viewer.options;
             if (!Array.isArray(objects))
                 objects = [objects];
-            if (!objects.length)
+            if (objects.length === 0)
                 return;
             objects
                 .filter((object) => !object.userData.isEdge)
                 .forEach((object) => {
-                if (object.isHighlighted)
+                if (object.userData.isHighlighted)
                     return;
                 if (object.isLine || object.isLineSegments) {
                     const positions = object.geometry.attributes.position.array;
@@ -36594,43 +36603,39 @@ void main() {
                         ? HighlighterUtils.fromIndexedLine(positions, indices)
                         : HighlighterUtils.fromNonIndexedLine(positions, object.isLineSegments);
                     const wireframe = new Wireframe(lineGeometry, this.lineGlowMaterial);
-                    wireframe.position.copy(object.position);
-                    wireframe.rotation.copy(object.rotation);
-                    wireframe.scale.copy(object.scale);
                     wireframe.visible = edgesVisibility;
-                    object.parent.add(wireframe);
+                    wireframe.userData.isHighlightWireframe = true;
+                    object.add(wireframe);
                     object.userData.highlightWireframe = wireframe;
                     object.userData.originalMaterial = object.material;
                     object.material = this.lineMaterial;
-                    object.isHighlighted = true;
+                    object.userData.isHighlighted = true;
                 }
                 else if (object.isMesh) {
                     const edgesGeometry = new EdgesGeometry(object.geometry, 89);
                     const lineGeometry = new LineSegmentsGeometry().fromEdgesGeometry(edgesGeometry);
                     const wireframe = new Wireframe(lineGeometry, this.edgesMaterial);
-                    wireframe.position.copy(object.position);
-                    wireframe.rotation.copy(object.rotation);
-                    wireframe.scale.copy(object.scale);
                     wireframe.visible = edgesVisibility;
-                    object.parent.add(wireframe);
+                    wireframe.userData.isHighlightWireframe = true;
+                    object.add(wireframe);
                     object.userData.highlightWireframe = wireframe;
                     object.userData.originalMaterial = object.material;
                     object.material = this.facesMaterial;
-                    object.isHighlighted = true;
+                    object.userData.isHighlighted = true;
                 }
             });
         }
         unhighlight(objects) {
             if (!Array.isArray(objects))
                 objects = [objects];
-            if (!objects.length)
+            if (objects.length === 0)
                 return;
             objects.forEach((object) => {
-                if (!object.isHighlighted)
+                if (!object.userData.isHighlighted)
                     return;
-                object.isHighlighted = false;
                 object.material = object.userData.originalMaterial;
                 object.userData.highlightWireframe.removeFromParent();
+                delete object.userData.isHighlighted;
                 delete object.userData.originalMaterial;
                 delete object.userData.highlightWireframe;
             });
@@ -36678,6 +36683,7 @@ void main() {
                 if (upPosition.distanceTo(this.downPosition) !== 0)
                     return;
                 const snapper = new Snapper(this.viewer.camera, this.viewer.renderer, this.viewer.canvas);
+                snapper.threshold = this.viewer.extents.getSize(new Vector3()).length() / 10000;
                 let intersections = [];
                 this.viewer.models.forEach((model) => {
                     const objects = model.getVisibleObjects();
@@ -36732,12 +36738,12 @@ void main() {
             }
             if (!Array.isArray(objects))
                 objects = [objects];
-            if (!objects.length)
+            if (objects.length === 0)
                 return;
-            model.showOriginalObjects(objects);
+            model.highlightObjects(objects);
             this.highlighter.highlight(objects);
             objects.forEach((object) => this.viewer.selected.push(object));
-            objects.forEach((object) => (object.isSelected = true));
+            objects.forEach((object) => (object.userData.isSelected = true));
         }
         deselect(objects, model) {
             if (!model) {
@@ -36746,29 +36752,29 @@ void main() {
             }
             if (!Array.isArray(objects))
                 objects = [objects];
-            if (!objects.length)
+            if (objects.length === 0)
                 return;
+            model.unhighlightObjects(objects);
             this.highlighter.unhighlight(objects);
-            model.hideOriginalObjects(objects);
             this.viewer.selected = this.viewer.selected.filter((x) => !objects.includes(x));
-            objects.forEach((object) => (object.isSelected = false));
+            objects.forEach((object) => (object.userData.isSelected = false));
         }
         toggleSelection(objects, model) {
             if (!Array.isArray(objects))
                 objects = [objects];
-            if (!objects.length)
+            if (objects.length === 0)
                 return;
-            if (objects[0].isSelected)
+            if (objects[0].userData.isSelected)
                 this.deselect(objects, model);
             else
                 this.select(objects, model);
         }
         clearSelection() {
-            if (!this.viewer.selected.length)
+            if (this.viewer.selected.length === 0)
                 return;
+            this.viewer.models.forEach((model) => model.unhighlightObjects(this.viewer.selected));
             this.highlighter.unhighlight(this.viewer.selected);
-            this.viewer.models.forEach((model) => model.hideOriginalObjects(this.viewer.selected));
-            this.viewer.selected.forEach((object) => (object.isSelected = false));
+            this.viewer.selected.forEach((object) => (object.userData.isSelected = false));
             this.viewer.selected.length = 0;
         }
     }
@@ -36896,19 +36902,22 @@ void main() {
                     direction: this.viewer.camera.getWorldDirection(new Vector3()),
                 };
             };
+            this.resetCameraPosition = () => {
+                if (this.savedCameraPosition) {
+                    this.viewer.camera.position.copy(this.savedCameraPosition.position);
+                    this.viewer.camera.up.copy(this.savedCameraPosition.up);
+                    this.viewer.camera.lookAt(this.savedCameraPosition.position.clone().add(this.savedCameraPosition.direction));
+                    this.viewer.camera.updateProjectionMatrix();
+                }
+            };
             this.viewer = viewer;
             this.viewer.addEventListener("databasechunk", this.onDatabaseChunk);
+            this.viewer.on("resetview", this.resetCameraPosition);
         }
         dispose() {
+            this.viewer.off("resetview", this.resetCameraPosition);
             this.viewer.removeEventListener("databasechunk", this.onDatabaseChunk);
         }
-        resetCameraPosition() {
-            if (this.savedCameraPosition) {
-                this.viewer.camera.position.copy(this.savedCameraPosition.position);
-                this.viewer.camera.up.copy(this.savedCameraPosition.up);
-                this.viewer.camera.lookAt(this.savedCameraPosition.position.clone().add(this.savedCameraPosition.direction));
-            }
-        }
     }
 
     const components = componentsRegistry("threejs");
@@ -36927,6 +36936,20 @@ void main() {
     class ModelImpl {
         constructor(scene) {
             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() {
             function disposeMaterial(material) {
@@ -36942,6 +36965,8 @@ void main() {
                 if (object.material)
                     disposeMaterials(object.material);
             }
+            this.handleToObjects = undefined;
+            this.originalObjects = undefined;
             this.scene.traverse(disposeObject);
             this.scene.clear();
         }
@@ -37084,67 +37109,56 @@ void main() {
             return info;
         }
         getExtents(target) {
-            this.scene.traverseVisible((object) => !object.children.length && target.expandByObject(object));
+            this.scene.traverseVisible((object) => target.expandByObject(object));
             return target;
         }
         getObjects() {
-            const objects = [];
-            this.scene.traverse((object) => objects.push(object));
-            return objects;
+            return Array.from(this.originalObjects);
         }
         getVisibleObjects() {
             const objects = [];
             this.scene.traverseVisible((object) => objects.push(object));
-            return objects;
-        }
-        hasObject(object) {
-            while (object) {
-                if (object === this.scene)
-                    return true;
-                object = object.parent;
-            }
-            return false;
-        }
-        hasHandle(handle) {
-            return !handle.includes(":") || handle.split(":", 1)[0] === this.id + "";
+            return objects.filter((object) => object.userData.handle);
         }
-        getOwnObjects(objects) {
-            if (!Array.isArray(objects))
-                objects = [objects];
-            return objects.filter((object) => this.hasObject(object));
-        }
-        getOwnHandles(handles) {
+        getObjectsByHandles(handles) {
             if (!Array.isArray(handles))
                 handles = [handles];
-            return handles.filter((handle) => this.hasHandle(handle));
-        }
-        getObjectsByHandles(handles) {
-            const ownHandles = this.getOwnHandles(handles);
-            if (ownHandles.length === 0)
-                return [];
-            const handleSet = new Set(ownHandles.map((handle) => handle.slice(handle.indexOf(":") + 1)));
+            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 handlesSet = new Set(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) {
-            const ownObjects = this.getOwnObjects(objects);
-            if (ownObjects.length === 0)
-                return [];
+            if (!Array.isArray(objects))
+                objects = [objects];
             const handleSet = new Set();
-            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) {
-            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;
         }
         hideAllObjects() {
@@ -37154,12 +37168,20 @@ void main() {
             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) {
-            this.getOwnObjects(objects).forEach((object) => {
+            if (!Array.isArray(objects))
+                objects = [objects];
+            objects
+                .filter((object) => this.originalObjects.has(object))
+                .forEach((object) => {
                 object.visible = true;
                 object.traverseAncestors((parent) => (parent.visible = true));
             });
@@ -37169,36 +37191,55 @@ void main() {
             this.scene.traverse((object) => (object.visible = true));
             return this;
         }
-        showOriginalObjects(objects) {
+        highlightObjects(objects) {
             return this;
         }
-        hideOriginalObjects(objects) {
+        unhighlightObjects(objects) {
             return this;
         }
         explode(scale = 0, coeff = 4) {
+            const centers = new Map();
+            const getObjectCenter = (object, target) => {
+                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) => extents.expandByObject(x));
+                extents.getCenter(target);
+                centers.set(handle, target.clone());
+                return target;
+            };
             function calcExplodeDepth(object, depth) {
-                let res = depth;
+                let result = depth;
                 object.children.forEach((x) => {
                     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;
-                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;
+                object.userData.originalCenter = getObjectCenter(object, new Vector3());
+                return result;
+            }
+            const explodeScale = scale / 100;
+            const explodeRoot = this.scene;
+            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) {
+                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;
@@ -37208,7 +37249,7 @@ void main() {
                 }
                 object.children.forEach((x) => explodeObject(x, depth + 1));
             }
-            explodeObject(this.scene, 0);
+            explodeObject(explodeRoot, 0);
             this.scene.updateMatrixWorld();
             return this;
         }
@@ -37246,29 +37287,24 @@ void main() {
         getVisibleObjects() {
             return this.gltfLoader.getOriginalObjectForSelect();
         }
-        hasObject(object) {
-            return this.gltfLoader.originalObjects.has(object);
-        }
         getObjectsByHandles(handles) {
-            const ownHandles = this.getOwnHandles(handles);
-            if (ownHandles.length === 0)
-                return [];
-            const handlesSet = new Set(ownHandles);
+            if (!Array.isArray(handles))
+                handles = [handles];
+            const handlesSet = new Set(handles);
             const objects = [];
             handlesSet.forEach((handle) => {
-                objects.push(...this.gltfLoader.getObjectsByHandle(handle));
+                objects.push(this.gltfLoader.getObjectsByHandle(handle));
             });
-            return objects;
+            return objects.flat();
         }
         getHandlesByObjects(objects) {
-            const ownObjects = this.getOwnObjects(objects);
-            if (ownObjects.length === 0)
-                return [];
+            if (!Array.isArray(objects))
+                objects = [objects];
             const handleSet = new Set();
-            ownObjects.forEach((object) => {
-                const handle = object.userData.handle;
-                if (handle)
-                    handleSet.add(handle);
+            objects
+                .filter((object) => this.gltfLoader.originalObjects.has(object))
+                .forEach((object) => {
+                handleSet.add(object.userData.handle);
             });
             return Array.from(handleSet);
         }
@@ -37291,14 +37327,78 @@ void main() {
             this.gltfLoader.showAllHiddenObjects();
             return this;
         }
-        showOriginalObjects(objects) {
+        highlightObjects(objects) {
             this.gltfLoader.showOriginalObjects(objects);
             return this;
         }
-        hideOriginalObjects(objects) {
+        unhighlightObjects(objects) {
             this.gltfLoader.hideOriginalObjects(objects);
             return this;
         }
+        explode(scale = 0, coeff = 4) {
+            const centers = 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);
+                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());
+                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;
+                });
+                object.userData.originalPosition = object.position.clone();
+                object.userData.originalCenter = calcObjectCenter(object, new Vector3());
+                return result;
+            }
+            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;
+            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) {
+                    let objectScale = explodeScale * 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);
+                    const matrix = new Matrix4().makeTranslation(objectOffset.x, objectOffset.y, objectOffset.z);
+                    transformMap.set(object, matrix);
+                }
+                object.children
+                    .filter((x) => !x.userData.isOptimized)
+                    .forEach((x) => explodeObject(x, depth + 1));
+            }
+            explodeObject(explodeRoot, 0);
+            this.scene.updateMatrixWorld();
+            this.gltfLoader.applyObjectTransforms(transformMap);
+            return this;
+        }
     }
 
     const GL_COMPONENT_TYPES = {
@@ -37347,7 +37447,7 @@ void main() {
         this.textureCache = new Map();
         this.materialCache = new Map();
         this.uri = "";
-        this._nextObjectId = 0;
+        this._nextObjectId = 1;
         this.loadingAborted = false;
         this.criticalError = null;
       }
@@ -38015,6 +38115,8 @@ void main() {
         this.hiddenHandles = new Set();
         this.newOptimizedObjects = new Set();
         this.oldOptimizeObjects = new Set();
+        this.objectTransforms = new Map();
+        this.transformedGeometries = new Map();
         this.activeChunkLoads = 0;
         this.chunkQueue = [];
         this.objectIdToIndex = new Map();
@@ -38776,14 +38878,32 @@ void main() {
           if (!node.geometryExtents) continue;
           if (node.object && this.hiddenHandles.has(node.object.userData.handle)) continue;
           const transformedBox = node.geometryExtents.clone();
-          if (node.group && node.group.matrix) {
-            transformedBox.applyMatrix4(node.group.matrix);
-            if (node.group.parent && node.group.parent.matrix) {
-              transformedBox.applyMatrix4(node.group.parent.matrix);
+          const structureRoot = node.structure ? this.structureRoots.get(node.structure.id) : null;
+          if (node.group) {
+            const matrices = [];
+            let currentGroup = node.group;
+            while (currentGroup && currentGroup !== structureRoot) {
+              if (currentGroup.matrix && currentGroup.matrixAutoUpdate === false) {
+                matrices.unshift(currentGroup.matrix);
+              }
+              currentGroup = currentGroup.parent;
             }
+            for (const matrix of matrices) {
+              transformedBox.applyMatrix4(matrix);
+            }
+          }
+          if (structureRoot && structureRoot.matrix) {
+            transformedBox.applyMatrix4(structureRoot.matrix);
+          }
+          const transform = this.objectTransforms.get(node.object);
+          if (transform) {
+            transformedBox.applyMatrix4(transform);
           }
           totalExtent.union(transformedBox);
         }
+        if (this.scene && this.scene.matrix && !totalExtent.isEmpty()) {
+          totalExtent.applyMatrix4(this.scene.matrix);
+        }
         return totalExtent;
       }
       loadCamera(structure, cameraIndex, nodeDef) {
@@ -38859,7 +38979,6 @@ void main() {
           for (let i = 0; i < this.maxObjectId; i++) {
             this.objectVisibility[i] = 1.0;
           }
-          console.log(`Initialized object visibility array: ${this.maxObjectId} objects`);
         }
       }
       createVisibilityMaterial(material) {
@@ -38996,6 +39115,8 @@ void main() {
         this.newOptimizedObjects.clear();
         this.oldOptimizeObjects.clear();
         this.isolatedObjects = [];
+        this.objectTransforms.clear();
+        this.transformedGeometries.clear();
         this.totalLoadedObjects = 0;
         this.lastUpdateTime = 0;
         this.currentMemoryUsage = 0;
@@ -39693,6 +39814,171 @@ void main() {
           mergedObject.geometry.attributes.visibility.needsUpdate = true;
         }
       }
+      applyObjectTransforms(objectTransformMap) {
+        if (this.mergedObjectMap.size === 0) {
+          console.warn("No merged objects to transform");
+          return;
+        }
+        this.objectTransforms = new Map(objectTransformMap);
+        for (const mesh of this.mergedMesh) {
+          this._applyTransformToMergedObject(mesh);
+        }
+        for (const line of this.mergedLines) {
+          this._applyTransformToMergedObject(line);
+        }
+        for (const lineSegment of this.mergedLineSegments) {
+          this._applyTransformToMergedObject(lineSegment);
+        }
+        for (const point of this.mergedPoints) {
+          this._applyTransformToMergedObject(point);
+        }
+      }
+      createExplodeTransforms(objects = null, explodeCenter = null, explodeFactor = 1.5) {
+        const transformMap = new Map();
+        if (!explodeCenter) {
+          explodeCenter = new Vector3();
+          const extent = this.getTotalGeometryExtent();
+          if (!extent.isEmpty()) {
+            extent.getCenter(explodeCenter);
+          }
+        }
+        const objectsArray = objects
+          ? Array.isArray(objects)
+            ? objects
+            : Array.from(objects)
+          : Array.from(this.originalObjects);
+        for (const obj of objectsArray) {
+          if (!obj.geometry || !obj.geometry.attributes.position) continue;
+          const boundingBox = new Box3().setFromBufferAttribute(obj.geometry.attributes.position);
+          if (obj.matrixWorld) {
+            boundingBox.applyMatrix4(obj.matrixWorld);
+          }
+          if (boundingBox.isEmpty()) continue;
+          const objectCenter = new Vector3();
+          boundingBox.getCenter(objectCenter);
+          const direction = objectCenter.clone().sub(explodeCenter);
+          const distance = direction.length();
+          if (distance > 0) {
+            direction.normalize();
+            const offset = direction.multiplyScalar(distance * (explodeFactor - 1.0));
+            const matrix = new Matrix4().makeTranslation(offset.x, offset.y, offset.z);
+            transformMap.set(obj, matrix);
+          }
+        }
+        return transformMap;
+      }
+      clearTransforms() {
+        this.objectTransforms.clear();
+        for (const mesh of this.mergedMesh) {
+          this._restoreOriginalGeometry(mesh);
+        }
+        for (const line of this.mergedLines) {
+          this._restoreOriginalGeometry(line);
+        }
+        for (const lineSegment of this.mergedLineSegments) {
+          this._restoreOriginalGeometry(lineSegment);
+        }
+        for (const point of this.mergedPoints) {
+          this._restoreOriginalGeometry(point);
+        }
+      }
+      clearHandleTransforms() {
+        this.clearTransforms();
+      }
+      _applyTransformToMergedObject(mergedObject) {
+        const objectData = this.mergedObjectMap.get(mergedObject.uuid);
+        if (!objectData || !objectData.objectMapping) return;
+        const geometry = mergedObject.geometry;
+        if (!geometry || !geometry.attributes.position) return;
+        const positionAttr = geometry.attributes.position;
+        const positions = positionAttr.array;
+        if (!this.transformedGeometries.has(mergedObject.uuid)) {
+          this.transformedGeometries.set(mergedObject.uuid, new Float32Array(positions));
+        }
+        const originalPositions = this.transformedGeometries.get(mergedObject.uuid);
+        const tempVector = new Vector3();
+        for (const [originalMesh, mappingData] of objectData.objectMapping) {
+          const transform = this.objectTransforms.get(originalMesh);
+          if (!transform) {
+            const startIdx = mappingData.startVertexIndex * 3;
+            const endIdx = (mappingData.startVertexIndex + mappingData.vertexCount) * 3;
+            for (let i = startIdx; i < endIdx; i++) {
+              positions[i] = originalPositions[i];
+            }
+            continue;
+          }
+          const startVertex = mappingData.startVertexIndex;
+          const vertexCount = mappingData.vertexCount;
+          for (let i = 0; i < vertexCount; i++) {
+            const idx = (startVertex + i) * 3;
+            tempVector.set(originalPositions[idx], originalPositions[idx + 1], originalPositions[idx + 2]);
+            tempVector.applyMatrix4(transform);
+            positions[idx] = tempVector.x;
+            positions[idx + 1] = tempVector.y;
+            positions[idx + 2] = tempVector.z;
+          }
+        }
+        if (geometry.attributes.normal) {
+          this._updateNormalsForTransform(geometry, objectData, originalPositions);
+        }
+        positionAttr.needsUpdate = true;
+        geometry.computeBoundingSphere();
+        geometry.computeBoundingBox();
+      }
+      _updateNormalsForTransform(geometry, objectData, originalPositions) {
+        const normalAttr = geometry.attributes.normal;
+        if (!normalAttr) return;
+        const normals = normalAttr.array;
+        const tempVector = new Vector3();
+        const normalMatrix = new Matrix4();
+        const normalsKey = `${geometry.uuid}_normals`;
+        if (!this.transformedGeometries.has(normalsKey)) {
+          this.transformedGeometries.set(normalsKey, new Float32Array(normals));
+        }
+        const originalNormals = this.transformedGeometries.get(normalsKey);
+        for (const [originalMesh, mappingData] of objectData.objectMapping) {
+          const transform = this.objectTransforms.get(originalMesh);
+          if (!transform) {
+            const startIdx = mappingData.startVertexIndex * 3;
+            const endIdx = (mappingData.startVertexIndex + mappingData.vertexCount) * 3;
+            for (let i = startIdx; i < endIdx; i++) {
+              normals[i] = originalNormals[i];
+            }
+            continue;
+          }
+          normalMatrix.copy(transform).invert().transpose();
+          const startVertex = mappingData.startVertexIndex;
+          const vertexCount = mappingData.vertexCount;
+          for (let i = 0; i < vertexCount; i++) {
+            const idx = (startVertex + i) * 3;
+            tempVector.set(originalNormals[idx], originalNormals[idx + 1], originalNormals[idx + 2]);
+            tempVector.applyMatrix4(normalMatrix).normalize();
+            normals[idx] = tempVector.x;
+            normals[idx + 1] = tempVector.y;
+            normals[idx + 2] = tempVector.z;
+          }
+        }
+        normalAttr.needsUpdate = true;
+      }
+      _restoreOriginalGeometry(mergedObject) {
+        const geometry = mergedObject.geometry;
+        if (!geometry || !geometry.attributes.position) return;
+        const originalPositions = this.transformedGeometries.get(mergedObject.uuid);
+        if (originalPositions) {
+          const positions = geometry.attributes.position.array;
+          positions.set(originalPositions);
+          geometry.attributes.position.needsUpdate = true;
+        }
+        const normalsKey = `${geometry.uuid}_normals`;
+        const originalNormals = this.transformedGeometries.get(normalsKey);
+        if (originalNormals && geometry.attributes.normal) {
+          const normals = geometry.attributes.normal.array;
+          normals.set(originalNormals);
+          geometry.attributes.normal.needsUpdate = true;
+        }
+        geometry.computeBoundingSphere();
+        geometry.computeBoundingBox();
+      }
       syncHiddenObjects() {
         if (this.mergedObjectMap.size === 0) {
           console.log("No merged objects to sync");
@@ -39724,19 +40010,33 @@ void main() {
       }
       getStructureGeometryExtent(structureId) {
         const extent = new Box3();
+        const structureRoot = this.structureRoots.get(structureId);
         for (const [nodeId, node] of this.nodes.entries()) {
           if (!node.geometryExtents) continue;
           if (!nodeId.startsWith(structureId + "_")) continue;
           if (node.object && this.hiddenHandles && this.hiddenHandles.has(node.object.userData.handle)) continue;
           const transformedBox = node.geometryExtents.clone();
-          if (node.group && node.group.matrix) {
-            transformedBox.applyMatrix4(node.group.matrix);
-            if (node.group.parent && node.group.parent.matrix) {
-              transformedBox.applyMatrix4(node.group.parent.matrix);
+          if (node.group) {
+            const matrices = [];
+            let currentGroup = node.group;
+            while (currentGroup && currentGroup !== structureRoot) {
+              if (currentGroup.matrix && currentGroup.matrixAutoUpdate === false) {
+                matrices.unshift(currentGroup.matrix);
+              }
+              currentGroup = currentGroup.parent;
             }
+            for (const matrix of matrices) {
+              transformedBox.applyMatrix4(matrix);
+            }
+          }
+          if (structureRoot && structureRoot.matrix) {
+            transformedBox.applyMatrix4(structureRoot.matrix);
           }
           extent.union(transformedBox);
         }
+        if (this.scene && this.scene.matrix && !extent.isEmpty()) {
+          extent.applyMatrix4(this.scene.matrix);
+        }
         return extent;
       }
       setMaxConcurrentChunks(maxChunks) {
@@ -54402,7 +54702,7 @@ js: import "konva/skia-backend";
         }
         getViewpoint(viewpoint) {
             if (!viewpoint)
-                viewpoint = {};
+                viewpoint = { custom_fields: {} };
             viewpoint.lines = this.getMarkupLines();
             viewpoint.texts = this.getMarkupTexts();
             viewpoint.arrows = this.getMarkupArrows();
@@ -54410,8 +54710,8 @@ js: import "konva/skia-backend";
             viewpoint.ellipses = this.getMarkupEllipses();
             viewpoint.images = this.getMarkupImages();
             viewpoint.rectangles = this.getMarkupRectangles();
-            viewpoint.custom_fields = { markup_color: this.getMarkupColor() };
             viewpoint.snapshot = { data: this.combineMarkupWithDrawing() };
+            viewpoint.custom_fields.markup_color = this.getMarkupColor();
             return viewpoint;
         }
         enableEditMode(mode) {
@@ -55122,8 +55422,8 @@ js: import "konva/skia-backend";
             const rect = canvas.parentElement.getBoundingClientRect();
             const width = rect.width || 1;
             const height = rect.height || 1;
-            const aspect = width / height;
-            this.camera = new PerspectiveCamera(45, aspect, 0.001, 1000);
+            const aspectRatio = width / height;
+            this.camera = new PerspectiveCamera(45, aspectRatio, 0.001, 1000);
             this.camera.up.set(0, 1, 0);
             this.camera.position.set(0, 0, 1);
             this.camera.lookAt(this.target);
@@ -55220,14 +55520,14 @@ js: import "konva/skia-backend";
             if (!this.renderer)
                 return;
             const camera = this.camera;
-            const aspect = width / height;
+            const aspectRatio = width / height;
             if (camera.isPerspectiveCamera) {
-                camera.aspect = aspect;
+                camera.aspect = aspectRatio;
                 camera.updateProjectionMatrix();
             }
             if (camera.isOrthographicCamera) {
-                camera.left = camera.bottom * aspect;
-                camera.right = camera.top * aspect;
+                camera.left = camera.bottom * aspectRatio;
+                camera.right = camera.top * aspectRatio;
                 camera.updateProjectionMatrix();
             }
             this.renderer.setSize(width, height, updateStyle);
@@ -55454,12 +55754,12 @@ js: import "konva/skia-backend";
                 if (orthogonal_camera) {
                     const extentsSize = this.extents.getBoundingSphere(new Sphere()).radius * 2;
                     const rendererSize = this.renderer.getSize(new Vector2());
-                    const aspect = rendererSize.x / rendererSize.y;
+                    const aspectRatio = rendererSize.x / rendererSize.y;
                     const camera = new OrthographicCamera();
                     camera.top = orthogonal_camera.field_height / 2;
                     camera.bottom = -orthogonal_camera.field_height / 2;
-                    camera.left = camera.bottom * aspect;
-                    camera.right = camera.top * aspect;
+                    camera.left = camera.bottom * aspectRatio;
+                    camera.right = camera.top * aspectRatio;
                     camera.near = 0;
                     camera.far = extentsSize * 1000;
                     camera.zoom = orthogonal_camera.view_to_world_scale;
@@ -55472,6 +55772,7 @@ js: import "konva/skia-backend";
                     this.renderPass.camera = camera;
                     this.helpersPass.camera = camera;
                     this.ssaaRenderPass.camera = camera;
+                    this.options.cameraMode = "orthographic";
                     this.emitEvent({ type: "changecameramode", mode: "orthographic" });
                 }
             };
@@ -55479,10 +55780,10 @@ js: import "konva/skia-backend";
                 if (perspective_camera) {
                     const extentsSize = this.extents.getBoundingSphere(new Sphere()).radius * 2;
                     const rendererSize = this.renderer.getSize(new Vector2());
-                    const aspect = rendererSize.x / rendererSize.y;
+                    const aspectRatio = rendererSize.x / rendererSize.y;
                     const camera = new PerspectiveCamera();
                     camera.fov = perspective_camera.field_of_view;
-                    camera.aspect = aspect;
+                    camera.aspect = aspectRatio;
                     camera.near = extentsSize / 1000;
                     camera.far = extentsSize * 1000;
                     camera.updateProjectionMatrix();
@@ -55494,6 +55795,7 @@ js: import "konva/skia-backend";
                     this.renderPass.camera = camera;
                     this.helpersPass.camera = camera;
                     this.ssaaRenderPass.camera = camera;
+                    this.options.cameraMode = "perspective";
                     this.emitEvent({ type: "changecameramode", mode: "perspective" });
                 }
             };
@@ -55523,6 +55825,7 @@ js: import "konva/skia-backend";
             setSelection(((_b = viewpoint.custom_fields) === null || _b === void 0 ? void 0 : _b.selection2) || viewpoint.selection);
             this._markup.setViewpoint(viewpoint);
             this.target.copy(getVector3FromPoint3d((_d = (_c = viewpoint.custom_fields) === null || _c === void 0 ? void 0 : _c.camera_target) !== null && _d !== void 0 ? _d : this.target));
+            this.syncOverlay();
             this.setActiveDragger(draggerName);
             this.emitEvent({ type: "drawviewpoint", data: viewpoint });
             this.update();