@inweb/viewer-three 26.6.6 → 26.7.0

package/dist/viewer-three.js

@@ -58447,7 +58447,7 @@ void main() {
             this.transformDrag = (event) => {
                 this.orbit.enabled = !event.value;
             };
-            this.viewerExplode = () => {
+            this.updatePlaneSize = () => {
                 this.planeHelper.size = this.viewer.extents.getSize(new Vector3()).length();
                 this.viewer.update();
             };
@@ -58476,12 +58476,16 @@ void main() {
             this.transform.addEventListener("change", this.transformChange);
             this.transform.addEventListener("dragging-changed", this.transformDrag);
             this.viewer.helpers.add(this.transform.getHelper());
-            this.viewer.on("explode", this.viewerExplode);
+            this.viewer.on("explode", this.updatePlaneSize);
+            this.viewer.on("show", this.updatePlaneSize);
+            this.viewer.on("showall", this.updatePlaneSize);
             this.viewer.canvas.addEventListener("dblclick", this.onDoubleClick, true);
             this.viewer.update();
         }
         dispose() {
-            this.viewer.off("explode", this.viewerExplode);
+            this.viewer.off("explode", this.updatePlaneSize);
+            this.viewer.off("show", this.updatePlaneSize);
+            this.viewer.off("showAll", this.updatePlaneSize);
             this.viewer.canvas.removeEventListener("dblclick", this.onDoubleClick, true);
             this.transform.removeEventListener("change", this.transformChange);
             this.transform.removeEventListener("dragging-changed", this.transformDrag);
@@ -58663,6 +58667,7 @@ void main() {
             this.viewer.addEventListener("render", this.renderOverlay);
             this.viewer.addEventListener("hide", this.updateSnapper);
             this.viewer.addEventListener("isolate", this.updateSnapper);
+            this.viewer.addEventListener("show", this.updateSnapper);
             this.viewer.addEventListener("showall", this.updateSnapper);
         }
         dispose() {
@@ -58674,6 +58679,7 @@ void main() {
             this.viewer.removeEventListener("render", this.renderOverlay);
             this.viewer.removeEventListener("hide", this.updateSnapper);
             this.viewer.removeEventListener("isolate", this.updateSnapper);
+            this.viewer.removeEventListener("show", this.updateSnapper);
             this.viewer.removeEventListener("showall", this.updateSnapper);
             this.overlay.detach();
             this.overlay.dispose();
@@ -59384,8 +59390,6 @@ void main() {
     ///////////////////////////////////////////////////////////////////////////////
     function clearSelected(viewer) {
         const selection = viewer.getComponent("SelectionComponent");
-        if (!selection)
-            return;
         selection.clearSelection();
         viewer.update();
         viewer.emitEvent({ type: "select", data: undefined, handles: [] });
@@ -59466,44 +59470,8 @@ void main() {
     // By use of this software, its documentation or related materials, you
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
-    function calcExplodeDepth(object, depth) {
-        let res = depth;
-        object.children.forEach((x) => {
-            const objectDepth = calcExplodeDepth(x, depth + 1);
-            if (res < objectDepth)
-                res = objectDepth;
-        });
-        object.originalPosition = object.position.clone();
-        object.originalCenter = new Box3().setFromObject(object).getCenter(new Vector3());
-        object.isExplodeLocked = depth > 2 && object.children.length === 0;
-        return res;
-    }
-    function explodeModel(scene, scale = 0, coeff = 4) {
-        scale /= 100;
-        if (!scene.explodeDepth)
-            scene.explodeDepth = calcExplodeDepth(scene, 1);
-        const maxDepth = scene.explodeDepth;
-        const scaledExplodeDepth = scale * maxDepth + 1;
-        const explodeDepth = 0 | scaledExplodeDepth;
-        const currentSegmentFraction = scaledExplodeDepth - explodeDepth;
-        function explodeObject(object, depth) {
-            object.position.copy(object.originalPosition);
-            if (depth > 0 && depth <= explodeDepth && !object.isExplodeLocked) {
-                let objectScale = scale * coeff;
-                if (depth === explodeDepth)
-                    objectScale *= currentSegmentFraction;
-                const parentCenter = object.parent.originalCenter;
-                const objectCenter = object.originalCenter;
-                const objectOffset = objectCenter.clone().sub(parentCenter).multiplyScalar(objectScale);
-                object.position.add(objectOffset);
-            }
-            object.children.forEach((x) => explodeObject(x, depth + 1));
-        }
-        explodeObject(scene, 0);
-    }
     function explode(viewer, index = 0) {
-        viewer.models.forEach((model) => explodeModel(model, index));
-        viewer.scene.updateMatrixWorld();
+        viewer.models.forEach((model) => model.explode(index));
         viewer.update();
         viewer.emitEvent({ type: "explode", data: index });
     }
@@ -59664,7 +59632,7 @@ void main() {
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
     function getModels(viewer) {
-        return viewer.models.map((model) => { var _a; return ((_a = model.userData) === null || _a === undefined ? undefined : _a.handle) || ""; }).filter((handle) => handle);
+        return viewer.models.map((model) => model.handle);
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -59690,108 +59658,9 @@ void main() {
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
     function getSelected(viewer) {
-        return viewer.selected.map((object) => { var _a; return (_a = object.userData) === null || _a === undefined ? undefined : _a.handle; }).filter((handle) => handle);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // 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.
-    ///////////////////////////////////////////////////////////////////////////////
-    class SelectionComponent {
-        constructor(viewer) {
-            this.onPointerDown = (event) => {
-                if (!event.isPrimary || event.button !== 0)
-                    return;
-                this.getMousePosition(event, this.downPosition);
-            };
-            this.onPointerUp = (event) => {
-                if (!event.isPrimary)
-                    return;
-                const upPosition = this.getMousePosition(event, new Vector2());
-                if (this.downPosition.distanceTo(upPosition) !== 0)
-                    return;
-                const intersects = this.getPointerIntersects(upPosition);
-                this.clearSelection();
-                if (intersects.length > 0)
-                    this.select(intersects[0].object);
-                this.viewer.update();
-                this.viewer.emitEvent({ type: "select", data: undefined, handles: this.viewer.getSelected() });
-            };
-            this.onDoubleClick = (event) => {
-                if (event.button !== 0)
-                    return;
-                this.viewer.executeCommand("zoomToSelected");
-            };
-            this.initHighlighter = () => {
-                this.highlighter = this.viewer.getComponent("HighlighterComponent");
-            };
-            this.viewer = viewer;
-            this.raycaster = new Raycaster();
-            this.downPosition = new Vector2();
-            this.viewer.addEventListener("pointerdown", this.onPointerDown);
-            this.viewer.addEventListener("pointerup", this.onPointerUp);
-            this.viewer.addEventListener("dblclick", this.onDoubleClick);
-            this.viewer.addEventListener("initialize", this.initHighlighter);
-        }
-        dispose() {
-            this.viewer.removeEventListener("pointerdown", this.onPointerDown);
-            this.viewer.removeEventListener("pointerup", this.onPointerUp);
-            this.viewer.removeEventListener("dblclick", this.onDoubleClick);
-            this.viewer.removeEventListener("initialize", this.initHighlighter);
-        }
-        getMousePosition(event, target) {
-            return target.set(event.clientX, event.clientY);
-        }
-        getPointerIntersects(mouse) {
-            const rect = this.viewer.canvas.getBoundingClientRect();
-            const x = ((mouse.x - rect.left) / rect.width) * 2 - 1;
-            const y = (-(mouse.y - rect.top) / rect.height) * 2 + 1;
-            const coords = new Vector2(x, y);
-            this.raycaster.setFromCamera(coords, this.viewer.camera);
-            const objects = [];
-            this.viewer.scene.traverseVisible((child) => objects.push(child));
-            this.raycaster.params = this.raycaster.params = {
-                Mesh: {},
-                Line: { threshold: 0.25 },
-                Line2: { threshold: 0.25 },
-                LOD: {},
-                Points: { threshold: 0.1 },
-                Sprite: {},
-            };
-            return this.raycaster.intersectObjects(objects, false);
-        }
-        select(object) {
-            if (object.isSelected)
-                return;
-            object.isSelected = true;
-            this.highlighter.highlight(object);
-            this.viewer.selected.push(object);
-        }
-        clearSelection() {
-            this.viewer.selected.forEach((object) => {
-                object.isSelected = false;
-                this.highlighter.unhighlight(object);
-            });
-            this.viewer.selected.length = 0;
-        }
+        const handles = [];
+        viewer.models.forEach((model) => handles.push(...model.getHandlesByObjects(viewer.selected)));
+        return handles;
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -59817,10 +59686,9 @@ void main() {
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
     function hideSelected(viewer) {
-        viewer.selected.forEach((object) => (object.visible = false));
-        const selection = new SelectionComponent(viewer);
+        viewer.models.forEach((model) => model.hideObjects(viewer.selected));
+        const selection = viewer.getComponent("SelectionComponent");
         selection.clearSelection();
-        selection.dispose();
         viewer.update();
         viewer.emitEvent({ type: "hide" });
         viewer.emitEvent({ type: "select", data: undefined, handles: [] });
@@ -59849,12 +59717,7 @@ void main() {
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
     function isolateSelected(viewer) {
-        const visibleSet = new Set();
-        viewer.selected.forEach((object) => {
-            visibleSet.add(object);
-            object.traverseAncestors((object2) => visibleSet.add(object2));
-        });
-        viewer.scene.traverse((object) => (object.visible = visibleSet.has(object)));
+        viewer.models.forEach((model) => model.isolateObjects(viewer.selected));
         viewer.update();
         viewer.emitEvent({ type: "isolate" });
     }
@@ -59943,7 +59806,12 @@ void main() {
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
     function selectModel(viewer, handle) {
-        console.warn("selectModel not implemented");
+        const selection = viewer.getComponent("SelectionComponent");
+        selection.clearSelection();
+        viewer.models
+            .filter((model) => model.handle === handle)
+            .forEach((model) => selection.select(model.getObjects(), model));
+        viewer.update();
         viewer.emit({ type: "select", data: [] });
     }
 
@@ -60022,19 +59890,14 @@ void main() {
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
     function setSelected(viewer, handles = []) {
-        const handleSet = new Set(handles);
-        const objects = [];
-        viewer.scene.traverseVisible((child) => {
-            var _a;
-            if (handleSet.has((_a = child.userData) === null || _a === undefined ? undefined : _a.handle))
-                objects.push(child);
-        });
         const selection = viewer.getComponent("SelectionComponent");
-        if (!selection)
-            return;
         selection.clearSelection();
-        objects.forEach((object) => selection.select(object));
+        viewer.models.forEach((model) => {
+            const objects = model.getObjectsByHandles(handles);
+            selection.select(objects, model);
+        });
         viewer.update();
+        viewer.emitEvent({ type: "show" });
         viewer.emitEvent({ type: "select", data: undefined, handles });
     }
 
@@ -60061,7 +59924,7 @@ void main() {
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
     function showAll(viewer) {
-        viewer.scene.traverse((object) => (object.visible = true));
+        viewer.models.forEach((model) => model.showAllObjects());
         viewer.update();
         viewer.emitEvent({ type: "showall" });
     }
@@ -60280,6 +60143,7 @@ void main() {
         constructor(viewer) {
             this.syncOptions = () => {
                 this.backgroundColor.setHex(0xffffff);
+                this.viewer.renderer.setClearColor(this.backgroundColor);
             };
             this.viewer = viewer;
             this.backgroundColor = new Color(0xffffff);
@@ -60389,23 +60253,25 @@ void main() {
         constructor(viewer) {
             this.syncExtents = () => {
                 const extents = new Box3();
-                this.viewer.scene.traverseVisible((object) => !object.children.length && extents.expandByObject(object));
+                this.viewer.models.forEach((model) => model.getExtents(extents));
                 this.viewer.extents.copy(extents);
             };
             this.viewer = viewer;
             this.viewer.addEventListener("databasechunk", this.syncExtents);
             this.viewer.addEventListener("clear", this.syncExtents);
             this.viewer.on("explode", this.syncExtents);
-            this.viewer.on("isolate", this.syncExtents);
             this.viewer.on("hide", this.syncExtents);
+            this.viewer.on("isolate", this.syncExtents);
+            this.viewer.on("show", this.syncExtents);
             this.viewer.on("showall", this.syncExtents);
         }
         dispose() {
             this.viewer.removeEventListener("databasechunk", this.syncExtents);
             this.viewer.removeEventListener("clear", this.syncExtents);
             this.viewer.off("explode", this.syncExtents);
-            this.viewer.off("isolate", this.syncExtents);
             this.viewer.off("hide", this.syncExtents);
+            this.viewer.off("isolate", this.syncExtents);
+            this.viewer.off("show", this.syncExtents);
             this.viewer.off("showall", this.syncExtents);
         }
     }
@@ -61605,6 +61471,16 @@ void main() {
                 this.viewer.update();
             };
             this.viewer = viewer;
+            const gl2 = viewer.canvas.getContext("webgl2");
+            if (gl2) {
+                const size = viewer.renderer.getSize(new Vector2());
+                this.renderTarget = new WebGLRenderTarget(size.x, size.y, {
+                    format: RGBAFormat,
+                    stencilBuffer: false,
+                    samples: 4,
+                    type: UnsignedByteType,
+                });
+            }
             this.viewer.addEventListener("databasechunk", this.geometryEnd);
             this.viewer.addEventListener("optionschange", this.optionsChange);
             this.viewer.addEventListener("resize", this.viewerResize);
@@ -61615,52 +61491,210 @@ void main() {
             this.viewer.removeEventListener("optionschange", this.optionsChange);
             this.viewer.removeEventListener("resize", this.viewerResize);
         }
-        highlight(object) {
-            if (object.isHighlighted)
+        highlight(objects) {
+            if (!Array.isArray(objects))
+                objects = [objects];
+            if (!objects.length)
+                return;
+            objects.forEach((object) => {
+                if (object.isHighlighted)
+                    return;
+                if (object.isLine || object.isLineSegments) {
+                    const positions = object.geometry.attributes.position.array;
+                    const indices = object.geometry.index ? object.geometry.index.array : null;
+                    const lineGeometry = indices
+                        ? HighlighterUtils.fromIndexedLine(positions, indices)
+                        : HighlighterUtils.fromNonIndexedLine(positions, object.isLineSegments);
+                    const wireframe = new Wireframe(lineGeometry, this.highlightLineGlowMaterial);
+                    wireframe.position.copy(object.position);
+                    wireframe.rotation.copy(object.rotation);
+                    wireframe.scale.copy(object.scale);
+                    object.parent.add(wireframe);
+                    object.userData.highlightwireframe = wireframe;
+                    object.userData.originalMaterial = object.material;
+                    object.material = this.highlightLineMaterial;
+                    object.isHighlighted = true;
+                }
+                else if (object.isMesh) {
+                    const edgesGeometry = new EdgesGeometry(object.geometry, 30);
+                    const lineGeometry = new LineSegmentsGeometry().fromEdgesGeometry(edgesGeometry);
+                    const wireframe = new Wireframe(lineGeometry, this.outlineMaterial);
+                    wireframe.position.copy(object.position);
+                    wireframe.rotation.copy(object.rotation);
+                    wireframe.scale.copy(object.scale);
+                    object.parent.add(wireframe);
+                    object.userData.highlightwireframe = wireframe;
+                    object.userData.originalMaterial = object.material;
+                    object.material = this.highlightMaterial;
+                    object.isHighlighted = true;
+                }
+            });
+        }
+        unhighlight(objects) {
+            if (!Array.isArray(objects))
+                objects = [objects];
+            if (!objects.length)
+                return;
+            objects.forEach((object) => {
+                if (!object.isHighlighted)
+                    return;
+                object.isHighlighted = false;
+                object.material = object.userData.originalMaterial;
+                object.userData.highlightwireframe.removeFromParent();
+                delete object.userData.originalMaterial;
+                delete object.userData.highlightwireframe;
+            });
+        }
+        viewerResize(event) {
+            var _a, _b;
+            (_a = this.renderTarget) === null || _a === undefined ? undefined : _a.setSize(event.width, event.height);
+            (_b = this.outlineMaterial) === null || _b === undefined ? undefined : _b.resolution.set(event.width, event.height);
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // 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.
+    ///////////////////////////////////////////////////////////////////////////////
+    class SelectionComponent {
+        constructor(viewer) {
+            this.onPointerDown = (event) => {
+                if (!event.isPrimary || event.button !== 0)
+                    return;
+                this.getMousePosition(event, this.downPosition);
+            };
+            this.onPointerUp = (event) => {
+                if (!event.isPrimary)
+                    return;
+                const upPosition = this.getMousePosition(event, new Vector2());
+                if (upPosition.distanceTo(this.downPosition) !== 0)
+                    return;
+                let intersections = [];
+                this.viewer.models.forEach((model) => {
+                    const objects = model.getVisibleObjects();
+                    const intersects = this.getPointerIntersects(upPosition, objects);
+                    intersections.push(...intersects.map((x) => ({ ...x, model })));
+                });
+                intersections = intersections.sort((a, b) => a.distance - b.distance);
+                if (!event.shiftKey)
+                    this.clearSelection();
+                if (intersections.length > 0) {
+                    const model = intersections[0].model;
+                    const handles = model.getHandlesByObjects(intersections[0].object);
+                    const objects = model.getObjectsByHandles(handles);
+                    if (!event.shiftKey)
+                        this.select(objects, model);
+                    else
+                        this.toggleSelection(objects, model);
+                }
+                this.viewer.update();
+                this.viewer.emitEvent({ type: "select", data: undefined, handles: this.viewer.getSelected() });
+            };
+            this.onDoubleClick = (event) => {
+                if (event.button !== 0)
+                    return;
+                this.viewer.executeCommand("zoomToSelected");
+            };
+            this.initHighlighter = () => {
+                this.highlighter = this.viewer.getComponent("HighlighterComponent");
+            };
+            this.viewer = viewer;
+            this.raycaster = new Raycaster();
+            this.downPosition = new Vector2();
+            this.viewer.addEventListener("pointerdown", this.onPointerDown);
+            this.viewer.addEventListener("pointerup", this.onPointerUp);
+            this.viewer.addEventListener("dblclick", this.onDoubleClick);
+            this.viewer.addEventListener("initialize", this.initHighlighter);
+        }
+        dispose() {
+            this.viewer.removeEventListener("pointerdown", this.onPointerDown);
+            this.viewer.removeEventListener("pointerup", this.onPointerUp);
+            this.viewer.removeEventListener("dblclick", this.onDoubleClick);
+            this.viewer.removeEventListener("initialize", this.initHighlighter);
+        }
+        getMousePosition(event, target) {
+            return target.set(event.clientX, event.clientY);
+        }
+        getPointerIntersects(mouse, objects) {
+            const rect = this.viewer.canvas.getBoundingClientRect();
+            const x = ((mouse.x - rect.left) / rect.width) * 2 - 1;
+            const y = (-(mouse.y - rect.top) / rect.height) * 2 + 1;
+            const coords = new Vector2(x, y);
+            this.raycaster.setFromCamera(coords, this.viewer.camera);
+            this.raycaster.params = this.raycaster.params = {
+                Mesh: {},
+                Line: { threshold: 0.25 },
+                Line2: { threshold: 0.25 },
+                LOD: {},
+                Points: { threshold: 0.1 },
+                Sprite: {},
+            };
+            return this.raycaster.intersectObjects(objects, false);
+        }
+        select(objects, model) {
+            if (!model) {
+                this.viewer.models.forEach((model) => this.select(objects, model));
                 return;
-            if (object.isLine || object.isLineSegments) {
-                const positions = object.geometry.attributes.position.array;
-                const indices = object.geometry.index ? object.geometry.index.array : null;
-                const lineGeometry = indices
-                    ? HighlighterUtils.fromIndexedLine(positions, indices)
-                    : HighlighterUtils.fromNonIndexedLine(positions, object.isLineSegments);
-                const wireframe = new Wireframe(lineGeometry, this.highlightLineGlowMaterial);
-                wireframe.position.copy(object.position);
-                wireframe.rotation.copy(object.rotation);
-                wireframe.scale.copy(object.scale);
-                object.parent.add(wireframe);
-                object.userData.highlightwireframe = wireframe;
-                object.userData.originalMaterial = object.material;
-                object.material = this.highlightLineMaterial;
-                object.isHighlighted = true;
             }
-            else if (object.isMesh) {
-                const edgesGeometry = new EdgesGeometry(object.geometry, 30);
-                const lineGeometry = new LineSegmentsGeometry().fromEdgesGeometry(edgesGeometry);
-                const wireframe = new Wireframe(lineGeometry, this.outlineMaterial);
-                wireframe.position.copy(object.position);
-                wireframe.rotation.copy(object.rotation);
-                wireframe.scale.copy(object.scale);
-                object.parent.add(wireframe);
-                object.userData.highlightwireframe = wireframe;
-                object.userData.originalMaterial = object.material;
-                object.material = this.highlightMaterial;
-                object.isHighlighted = true;
+            if (!Array.isArray(objects))
+                objects = [objects];
+            if (!objects.length)
+                return;
+            model.showObjects(objects);
+            model.showOriginalObjects(objects);
+            this.highlighter.highlight(objects);
+            objects.forEach((object) => this.viewer.selected.push(object));
+            objects.forEach((object) => (object.isSelected = true));
+        }
+        deselect(objects, model) {
+            if (!model) {
+                this.viewer.models.forEach((model) => this.select(objects, model));
+                return;
             }
+            if (!Array.isArray(objects))
+                objects = [objects];
+            if (!objects.length)
+                return;
+            this.highlighter.unhighlight(objects);
+            model.hideOriginalObjects(objects);
+            this.viewer.selected = this.viewer.selected.filter((x) => !objects.includes(x));
+            objects.forEach((object) => (object.isSelected = false));
         }
-        unhighlight(object) {
-            if (!object.isHighlighted)
+        toggleSelection(objects, model) {
+            if (!Array.isArray(objects))
+                objects = [objects];
+            if (!objects.length)
                 return;
-            object.isHighlighted = false;
-            object.material = object.userData.originalMaterial;
-            object.userData.highlightwireframe.removeFromParent();
-            delete object.userData.originalMaterial;
-            delete object.userData.highlightwireframe;
+            if (objects[0].isSelected)
+                this.deselect(objects, model);
+            else
+                this.select(objects, model);
         }
-        viewerResize(event) {
-            if (!this.outlineMaterial)
+        clearSelection() {
+            if (!this.viewer.selected.length)
                 return;
-            this.outlineMaterial.resolution.set(event.width, event.height);
+            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.length = 0;
         }
     }
 
@@ -61869,73 +61903,362 @@ void main() {
     components.registerComponent("WCSHelperComponent", (viewer) => new WCSHelperComponent(viewer));
 
     /**
-     * @param {BufferGeometry} geometry
-     * @param {number} drawMode
+     * @param  {Array<BufferGeometry>} geometries
+     * @param  {Boolean} useGroups
      * @return {BufferGeometry}
      */
-    function toTrianglesDrawMode( geometry, drawMode ) {
+    function mergeGeometries( geometries, useGroups = false ) {
 
-    	if ( drawMode === TrianglesDrawMode ) {
+    	const isIndexed = geometries[ 0 ].index !== null;
 
-    		console.warn( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.' );
-    		return geometry;
+    	const attributesUsed = new Set( Object.keys( geometries[ 0 ].attributes ) );
+    	const morphAttributesUsed = new Set( Object.keys( geometries[ 0 ].morphAttributes ) );
 
-    	}
+    	const attributes = {};
+    	const morphAttributes = {};
 
-    	if ( drawMode === TriangleFanDrawMode || drawMode === TriangleStripDrawMode ) {
+    	const morphTargetsRelative = geometries[ 0 ].morphTargetsRelative;
 
-    		let index = geometry.getIndex();
+    	const mergedGeometry = new BufferGeometry();
 
-    		// generate index if not present
+    	let offset = 0;
 
-    		if ( index === null ) {
+    	for ( let i = 0; i < geometries.length; ++ i ) {
 
-    			const indices = [];
+    		const geometry = geometries[ i ];
+    		let attributesCount = 0;
 
-    			const position = geometry.getAttribute( 'position' );
+    		// ensure that all geometries are indexed, or none
 
-    			if ( position !== undefined ) {
+    		if ( isIndexed !== ( geometry.index !== null ) ) {
 
-    				for ( let i = 0; i < position.count; i ++ ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' );
+    			return null;
 
-    					indices.push( i );
+    		}
 
-    				}
+    		// gather attributes, exit early if they're different
 
-    				geometry.setIndex( indices );
-    				index = geometry.getIndex();
+    		for ( const name in geometry.attributes ) {
 
-    			} else {
+    			if ( ! attributesUsed.has( name ) ) {
 
-    				console.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.' );
-    				return geometry;
+    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure "' + name + '" attribute exists among all geometries, or in none of them.' );
+    				return null;
 
     			}
 
-    		}
+    			if ( attributes[ name ] === undefined ) attributes[ name ] = [];
 
-    		//
+    			attributes[ name ].push( geometry.attributes[ name ] );
 
-    		const numberOfTriangles = index.count - 2;
-    		const newIndices = [];
+    			attributesCount ++;
 
-    		if ( drawMode === TriangleFanDrawMode ) {
+    		}
 
-    			// gl.TRIANGLE_FAN
+    		// ensure geometries have the same number of attributes
 
-    			for ( let i = 1; i <= numberOfTriangles; i ++ ) {
+    		if ( attributesCount !== attributesUsed.size ) {
 
-    				newIndices.push( index.getX( 0 ) );
-    				newIndices.push( index.getX( i ) );
-    				newIndices.push( index.getX( i + 1 ) );
+    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of attributes.' );
+    			return null;
 
-    			}
+    		}
 
-    		} else {
+    		// gather morph attributes, exit early if they're different
 
-    			// gl.TRIANGLE_STRIP
+    		if ( morphTargetsRelative !== geometry.morphTargetsRelative ) {
 
-    			for ( let i = 0; i < numberOfTriangles; i ++ ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. .morphTargetsRelative must be consistent throughout all geometries.' );
+    			return null;
+
+    		}
+
+    		for ( const name in geometry.morphAttributes ) {
+
+    			if ( ! morphAttributesUsed.has( name ) ) {
+
+    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '.  .morphAttributes must be consistent throughout all geometries.' );
+    				return null;
+
+    			}
+
+    			if ( morphAttributes[ name ] === undefined ) morphAttributes[ name ] = [];
+
+    			morphAttributes[ name ].push( geometry.morphAttributes[ name ] );
+
+    		}
+
+    		if ( useGroups ) {
+
+    			let count;
+
+    			if ( isIndexed ) {
+
+    				count = geometry.index.count;
+
+    			} else if ( geometry.attributes.position !== undefined ) {
+
+    				count = geometry.attributes.position.count;
+
+    			} else {
+
+    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. The geometry must have either an index or a position attribute' );
+    				return null;
+
+    			}
+
+    			mergedGeometry.addGroup( offset, count, i );
+
+    			offset += count;
+
+    		}
+
+    	}
+
+    	// merge indices
+
+    	if ( isIndexed ) {
+
+    		let indexOffset = 0;
+    		const mergedIndex = [];
+
+    		for ( let i = 0; i < geometries.length; ++ i ) {
+
+    			const index = geometries[ i ].index;
+
+    			for ( let j = 0; j < index.count; ++ j ) {
+
+    				mergedIndex.push( index.getX( j ) + indexOffset );
+
+    			}
+
+    			indexOffset += geometries[ i ].attributes.position.count;
+
+    		}
+
+    		mergedGeometry.setIndex( mergedIndex );
+
+    	}
+
+    	// merge attributes
+
+    	for ( const name in attributes ) {
+
+    		const mergedAttribute = mergeAttributes( attributes[ name ] );
+
+    		if ( ! mergedAttribute ) {
+
+    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' attribute.' );
+    			return null;
+
+    		}
+
+    		mergedGeometry.setAttribute( name, mergedAttribute );
+
+    	}
+
+    	// merge morph attributes
+
+    	for ( const name in morphAttributes ) {
+
+    		const numMorphTargets = morphAttributes[ name ][ 0 ].length;
+
+    		if ( numMorphTargets === 0 ) break;
+
+    		mergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {};
+    		mergedGeometry.morphAttributes[ name ] = [];
+
+    		for ( let i = 0; i < numMorphTargets; ++ i ) {
+
+    			const morphAttributesToMerge = [];
+
+    			for ( let j = 0; j < morphAttributes[ name ].length; ++ j ) {
+
+    				morphAttributesToMerge.push( morphAttributes[ name ][ j ][ i ] );
+
+    			}
+
+    			const mergedMorphAttribute = mergeAttributes( morphAttributesToMerge );
+
+    			if ( ! mergedMorphAttribute ) {
+
+    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' morphAttribute.' );
+    				return null;
+
+    			}
+
+    			mergedGeometry.morphAttributes[ name ].push( mergedMorphAttribute );
+
+    		}
+
+    	}
+
+    	return mergedGeometry;
+
+    }
+
+    /**
+     * @param {Array<BufferAttribute>} attributes
+     * @return {BufferAttribute}
+     */
+    function mergeAttributes( attributes ) {
+
+    	let TypedArray;
+    	let itemSize;
+    	let normalized;
+    	let gpuType = -1;
+    	let arrayLength = 0;
+
+    	for ( let i = 0; i < attributes.length; ++ i ) {
+
+    		const attribute = attributes[ i ];
+
+    		if ( TypedArray === undefined ) TypedArray = attribute.array.constructor;
+    		if ( TypedArray !== attribute.array.constructor ) {
+
+    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.' );
+    			return null;
+
+    		}
+
+    		if ( itemSize === undefined ) itemSize = attribute.itemSize;
+    		if ( itemSize !== attribute.itemSize ) {
+
+    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.' );
+    			return null;
+
+    		}
+
+    		if ( normalized === undefined ) normalized = attribute.normalized;
+    		if ( normalized !== attribute.normalized ) {
+
+    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.' );
+    			return null;
+
+    		}
+
+    		if ( gpuType === -1 ) gpuType = attribute.gpuType;
+    		if ( gpuType !== attribute.gpuType ) {
+
+    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes.' );
+    			return null;
+
+    		}
+
+    		arrayLength += attribute.count * itemSize;
+
+    	}
+
+    	const array = new TypedArray( arrayLength );
+    	const result = new BufferAttribute( array, itemSize, normalized );
+    	let offset = 0;
+
+    	for ( let i = 0; i < attributes.length; ++ i ) {
+
+    		const attribute = attributes[ i ];
+    		if ( attribute.isInterleavedBufferAttribute ) {
+
+    			const tupleOffset = offset / itemSize;
+    			for ( let j = 0, l = attribute.count; j < l; j ++ ) {
+
+    				for ( let c = 0; c < itemSize; c ++ ) {
+
+    					const value = attribute.getComponent( j, c );
+    					result.setComponent( j + tupleOffset, c, value );
+
+    				}
+
+    			}
+
+    		} else {
+
+    			array.set( attribute.array, offset );
+
+    		}
+
+    		offset += attribute.count * itemSize;
+
+    	}
+
+    	if ( gpuType !== undefined ) {
+
+    		result.gpuType = gpuType;
+
+    	}
+
+    	return result;
+
+    }
+
+    /**
+     * @param {BufferGeometry} geometry
+     * @param {number} drawMode
+     * @return {BufferGeometry}
+     */
+    function toTrianglesDrawMode( geometry, drawMode ) {
+
+    	if ( drawMode === TrianglesDrawMode ) {
+
+    		console.warn( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.' );
+    		return geometry;
+
+    	}
+
+    	if ( drawMode === TriangleFanDrawMode || drawMode === TriangleStripDrawMode ) {
+
+    		let index = geometry.getIndex();
+
+    		// generate index if not present
+
+    		if ( index === null ) {
+
+    			const indices = [];
+
+    			const position = geometry.getAttribute( 'position' );
+
+    			if ( position !== undefined ) {
+
+    				for ( let i = 0; i < position.count; i ++ ) {
+
+    					indices.push( i );
+
+    				}
+
+    				geometry.setIndex( indices );
+    				index = geometry.getIndex();
+
+    			} else {
+
+    				console.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.' );
+    				return geometry;
+
+    			}
+
+    		}
+
+    		//
+
+    		const numberOfTriangles = index.count - 2;
+    		const newIndices = [];
+
+    		if ( drawMode === TriangleFanDrawMode ) {
+
+    			// gl.TRIANGLE_FAN
+
+    			for ( let i = 1; i <= numberOfTriangles; i ++ ) {
+
+    				newIndices.push( index.getX( 0 ) );
+    				newIndices.push( index.getX( i ) );
+    				newIndices.push( index.getX( i + 1 ) );
+
+    			}
+
+    		} else {
+
+    			// gl.TRIANGLE_STRIP
+
+    			for ( let i = 0; i < numberOfTriangles; i ++ ) {
 
     				if ( i % 2 === 0 ) {
 
@@ -66554,151 +66877,2514 @@ void main() {
 
     				}
 
-    			}
+    			}
+
+    		}
+
+    		// As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets.
+    		box.expandByVector( maxDisplacement );
+
+    	}
+
+    	geometry.boundingBox = box;
+
+    	const sphere = new Sphere();
+
+    	box.getCenter( sphere.center );
+    	sphere.radius = box.min.distanceTo( box.max ) / 2;
+
+    	geometry.boundingSphere = sphere;
+
+    }
+
+    /**
+     * @param {BufferGeometry} geometry
+     * @param {GLTF.Primitive} primitiveDef
+     * @param {GLTFParser} parser
+     * @return {Promise<BufferGeometry>}
+     */
+    function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
+
+    	const attributes = primitiveDef.attributes;
+
+    	const pending = [];
+
+    	function assignAttributeAccessor( accessorIndex, attributeName ) {
+
+    		return parser.getDependency( 'accessor', accessorIndex )
+    			.then( function ( accessor ) {
+
+    				geometry.setAttribute( attributeName, accessor );
+
+    			} );
+
+    	}
+
+    	for ( const gltfAttributeName in attributes ) {
+
+    		const threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase();
+
+    		// Skip attributes already provided by e.g. Draco extension.
+    		if ( threeAttributeName in geometry.attributes ) continue;
+
+    		pending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) );
+
+    	}
+
+    	if ( primitiveDef.indices !== undefined && ! geometry.index ) {
+
+    		const accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) {
+
+    			geometry.setIndex( accessor );
+
+    		} );
+
+    		pending.push( accessor );
+
+    	}
+
+    	if ( ColorManagement.workingColorSpace !== LinearSRGBColorSpace && 'COLOR_0' in attributes ) {
+
+    		console.warn( `THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${ColorManagement.workingColorSpace}" not supported.` );
+
+    	}
+
+    	assignExtrasToUserData( geometry, primitiveDef );
+
+    	computeBounds( geometry, primitiveDef, parser );
+
+    	return Promise.all( pending ).then( function () {
+
+    		return primitiveDef.targets !== undefined
+    			? addMorphTargets( geometry, primitiveDef.targets, parser )
+    			: geometry;
+
+    	} );
+
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // 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.
+    ///////////////////////////////////////////////////////////////////////////////
+    class GLTFLoadingManager extends LoadingManager {
+        constructor(file, params = {}) {
+            super();
+            this.path = "";
+            this.resourcePath = "";
+            this.fileURL = "";
+            this.dataURLs = new Map();
+            this.path = params.path || "";
+            const externalFiles = params.externalFiles || new Map();
+            if (typeof file === "string") {
+                this.fileURL = file;
+                this.resourcePath = LoaderUtils.extractUrlBase(file);
+            }
+            else {
+                externalFiles.forEach((value, key) => (this.fileURL = value === file ? key : this.fileURL));
+                externalFiles.set(this.fileURL, file);
+            }
+            externalFiles.forEach((value, key) => {
+                let dataURL;
+                if (typeof value === "string")
+                    dataURL = value;
+                else
+                    dataURL = URL.createObjectURL(new Blob([value]));
+                this.dataURLs.set(key, dataURL);
+            });
+            this.setURLModifier((url) => {
+                const key = decodeURI(url)
+                    .replace(this.path, "")
+                    .replace(this.resourcePath, "")
+                    .replace(/^(\.?\/)/, "");
+                const dataURL = this.dataURLs.get(key);
+                return dataURL !== null && dataURL !== undefined ? dataURL : url;
+            });
+        }
+        dispose() {
+            this.dataURLs.forEach(URL.revokeObjectURL);
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // 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.
+    ///////////////////////////////////////////////////////////////////////////////
+    /**
+     * Basic model implementation.
+     */
+    class ModelImpl {
+        constructor(scene) {
+            this.handle = "1";
+            this.scene = scene;
+        }
+        dispose() {
+            function disposeMaterial(material) {
+                // 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) {
+                const materials = Array.isArray(material) ? material : [material];
+                materials.forEach((material) => disposeMaterial(material));
+            }
+            function disposeObject(object) {
+                if (object.geometry)
+                    object.geometry.dispose();
+                if (object.material)
+                    disposeMaterials(object.material);
+            }
+            this.scene.traverse(disposeObject);
+            this.scene.clear();
+        }
+        getExtents(target) {
+            this.scene.traverseVisible((object) => !object.children.length && target.expandByObject(object));
+            return target;
+        }
+        getObjects() {
+            const objects = [];
+            this.scene.traverse((object) => objects.push(object));
+            return objects;
+        }
+        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;
+        }
+        getOwnObjects(objects) {
+            if (!Array.isArray(objects))
+                objects = [objects];
+            return objects.filter((object) => this.hasObject(object));
+        }
+        getObjectsByHandles(handles) {
+            const handleSet = new Set(handles);
+            const objects = [];
+            this.scene.traverse((object) => handleSet.has(object.userData.handle) && objects.push(object));
+            return objects;
+        }
+        getHandlesByObjects(objects) {
+            if (!Array.isArray(objects))
+                objects = [objects];
+            const handlesSet = new Set();
+            this.getOwnObjects(objects).forEach((object) => handlesSet.add(object.userData.handle));
+            return Array.from(handlesSet);
+        }
+        hideObjects(objects) {
+            if (!Array.isArray(objects))
+                objects = [objects];
+            this.getOwnObjects(objects).forEach((object) => (object.visible = false));
+            return this;
+        }
+        hideAllObjects() {
+            return this.isolateObjects([]);
+        }
+        isolateObjects(objects) {
+            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) {
+            if (!Array.isArray(objects))
+                objects = [objects];
+            this.getOwnObjects(objects).forEach((object) => {
+                object.visible = true;
+                object.traverseAncestors((parent) => (parent.visible = true));
+            });
+            return this;
+        }
+        showAllObjects() {
+            this.scene.traverse((object) => (object.visible = true));
+            return this;
+        }
+        showOriginalObjects(objects) {
+            return this;
+        }
+        hideOriginalObjects(objects) {
+            return this;
+        }
+        explode(scale = 0, coeff = 4) {
+            function calcExplodeDepth(object, depth) {
+                let res = depth;
+                object.children.forEach((x) => {
+                    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, depth) {
+                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;
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // 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.
+    ///////////////////////////////////////////////////////////////////////////////
+    class GLTFFileLoader extends Loader$1 {
+        constructor(viewer) {
+            super();
+            this.viewer = viewer;
+        }
+        isSupport(file, format) {
+            return ((typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) &&
+                /(gltf|glb)$/i.test(format));
+        }
+        async load(file, format, params) {
+            const manager = new GLTFLoadingManager(file, params);
+            const loader = new GLTFLoader(manager);
+            loader.setPath(manager.path);
+            loader.setCrossOrigin(params.crossOrigin || loader.crossOrigin);
+            loader.setWithCredentials(params.withCredentials || loader.withCredentials);
+            const progress = (event) => {
+                const { lengthComputable, loaded, total } = event;
+                const progress = lengthComputable ? loaded / total : 1;
+                this.viewer.emitEvent({ type: "geometryprogress", data: progress, file });
+            };
+            const gltf = await loader.loadAsync(manager.fileURL, progress);
+            if (!this.viewer.scene)
+                return this;
+            const modelImpl = new ModelImpl(gltf.scene);
+            modelImpl.loader = this;
+            modelImpl.viewer = this.viewer;
+            this.viewer.scene.add(modelImpl.scene);
+            this.viewer.models.push(modelImpl);
+            this.viewer.syncOptions();
+            this.viewer.syncOverlay();
+            this.viewer.update();
+            this.viewer.emitEvent({ type: "databasechunk", data: gltf.scene, file });
+            return this;
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // 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.
+    ///////////////////////////////////////////////////////////////////////////////
+    /**
+     * Dynamic model implementation.
+     */
+    class DynamicModelImpl extends ModelImpl {
+        getExtents(target) {
+            return target.union(this.gltfLoader.getTotalGeometryExtent());
+        }
+        getObjects() {
+            const objects = [];
+            this.gltfLoader.originalObjects.forEach((object) => {
+                objects.push(object);
+            });
+            return objects;
+        }
+        getVisibleObjects() {
+            return this.gltfLoader.getOriginalObjectForSelect();
+        }
+        hasObject(object) {
+            return this.gltfLoader.originalObjects.has(object);
+        }
+        getObjectsByHandles(handles) {
+            const handlesSet = new Set(handles);
+            const objects = [];
+            handlesSet.forEach((handle) => {
+                const handles = this.gltfLoader.handleToObjects.get(handle) || [];
+                objects.push(...Array.from(handles));
+            });
+            return objects;
+        }
+        hideObjects(objects) {
+            this.getOwnObjects(objects)
+                .map((object) => object.userData.handle)
+                .forEach((handle) => this.gltfLoader.hiddenHandles.add(handle));
+            this.gltfLoader.syncHiddenObjects();
+            return this;
+        }
+        isolateObjects(objects) {
+            const handles = this.getHandlesByObjects(objects);
+            this.gltfLoader.isolateObjects(new Set(handles));
+            return this;
+        }
+        showObjects(objects) {
+            this.getOwnObjects(objects)
+                .map((object) => object.userData.handle)
+                .forEach((handle) => this.gltfLoader.hiddenHandles.delete(handle));
+            this.gltfLoader.syncHiddenObjects();
+            return this;
+        }
+        showAllObjects() {
+            this.gltfLoader.hiddenHandles.clear();
+            this.gltfLoader.syncHiddenObjects();
+            return this;
+        }
+        showOriginalObjects(objects) {
+            this.getOwnObjects(objects).forEach((object) => (object.visible = true));
+            return this;
+        }
+        hideOriginalObjects(objects) {
+            this.getOwnObjects(objects).forEach((object) => (object.visible = false));
+            return this;
+        }
+    }
+
+    const GL_COMPONENT_TYPES = {
+      5120: Int8Array,
+      5121: Uint8Array,
+      5122: Int16Array,
+      5123: Uint16Array,
+      5125: Uint32Array,
+      5126: Float32Array,
+    };
+
+    const GL_CONSTANTS = {
+      POINTS: 0,
+      LINES: 1,
+      LINE_LOOP: 2,
+      LINE_STRIP: 3,
+      TRIANGLES: 4,
+      TRIANGLE_STRIP: 5,
+      TRIANGLE_FAN: 6};
+
+    class GltfStructure {
+      constructor(id) {
+        this.id = `${id}`;
+        this.json = null;
+        this.baseUrl = "";
+
+        // Binary manager properties
+        this.loadController = null;
+        // Request batching parameters
+        this.batchDelay = 10;
+        this.maxBatchSize = 5 * 1024 * 1024;
+        this.maxRangesPerRequest = 512;
+
+        // Request queue
+        this.pendingRequests = [];
+        this.batchTimeout = null;
+
+        // Material and texture properties
+        this.textureLoader = new TextureLoader();
+        this.materials = new Map();
+        this.textureCache = new Map();
+      }
+
+      async initialize(loadController) {
+        this.json = await loadController.loadJson();
+        this.baseUrl = await loadController.baseUrl();
+        this.loadController = loadController;
+      }
+
+      clear() {
+        this.json = null;
+        this.baseUrl = "";
+        this.loadController = null;
+        this.pendingRequests = [];
+        if (this.batchTimeout) {
+          clearTimeout(this.batchTimeout);
+          this.batchTimeout = null;
+        }
+
+        // Clear materials and textures
+        this.disposeMaterials();
+        this.textureCache.clear();
+        this.materials.clear();
+      }
+
+      getJson() {
+        return this.json;
+      }
+
+      // Schedule a request for processing
+      scheduleRequest(request) {
+        this.pendingRequests.push(request);
+
+        // Clear existing timeout
+        if (this.batchTimeout) {
+          clearTimeout(this.batchTimeout);
+        }
+
+        // Set new timeout for batch processing
+        this.batchTimeout = setTimeout(() => this.processBatch(), this.batchDelay);
+
+        // Return a promise that will resolve when the data is available
+        return new Promise((resolve, reject) => {
+          request.resolve = resolve;
+          request.reject = reject;
+        });
+      }
+
+      async processBatch() {
+        if (this.pendingRequests.length === 0) return;
+
+        // Take current batch of requests and clear timeout
+        const currentBatch = [...this.pendingRequests];
+        this.pendingRequests = [];
+
+        if (this.batchTimeout) {
+          clearTimeout(this.batchTimeout);
+          this.batchTimeout = null;
+        }
+        try {
+          // Split requests into smaller groups
+          for (let i = 0; i < currentBatch.length; i += this.maxRangesPerRequest) {
+            const batchRequests = currentBatch.slice(i, i + this.maxRangesPerRequest);
+            const buffer = await this.loadController.loadBinaryData(batchRequests);
+
+            let currentOffset = 0;
+            batchRequests.forEach((request) => {
+              const view = this.createTypedArray(buffer, currentOffset, request.length, request.componentType);
+              request.resolve(view);
+              currentOffset += request.length;
+            });
+          }
+        } catch (error) {
+          console.error("Error processing batch:", error);
+          currentBatch.forEach((request) => request.reject(error));
+        }
+
+        if (this.pendingRequests.length > 0) {
+          this.batchTimeout = setTimeout(() => this.processBatch(), this.batchDelay);
+        }
+      }
+
+      getBufferView(byteOffset, byteLength, componentType) {
+        return this.scheduleRequest({
+          offset: byteOffset,
+          length: byteLength,
+          componentType,
+        });
+      }
+
+      createTypedArray(buffer, offset, length, componentType) {
+        try {
+          // Validate parameters
+          if (!buffer || !(buffer instanceof ArrayBuffer)) {
+            throw new Error("Invalid buffer");
+          }
+
+          // Calculate element size for given type
+          let elementSize;
+          switch (componentType) {
+            case 5120:
+            case 5121:
+              elementSize = 1;
+              break; // BYTE, UNSIGNED_BYTE
+            case 5122:
+            case 5123:
+              elementSize = 2;
+              break; // SHORT, UNSIGNED_SHORT
+            case 5125:
+            case 5126:
+              elementSize = 4;
+              break; // UNSIGNED_INT, FLOAT
+            default:
+              throw new Error(`Unsupported component type: ${componentType}`);
+          }
+
+          // Check if requested length is correct
+          const numElements = length / elementSize;
+          if (!Number.isInteger(numElements)) {
+            throw new Error(`Invalid length ${length} for component type ${componentType}`);
+          }
+
+          // Check if buffer is large enough
+          if (length > buffer.byteLength) {
+            throw new Error(`Buffer too small: need ${length} bytes, but buffer is ${buffer.byteLength} bytes`);
+          }
+
+          // Create appropriate typed array
+          const ArrayType = GL_COMPONENT_TYPES[componentType];
+          return new ArrayType(buffer, offset, numElements);
+        } catch (error) {
+          if (error.name !== "AbortError") {
+            console.error("Error creating typed array:", {
+              bufferSize: buffer?.byteLength,
+              offset,
+              length,
+              componentType,
+              error,
+            });
+          }
+          throw error;
+        }
+      }
+
+      async createBufferAttribute(accessorIndex) {
+        if (!this.json) {
+          throw new Error("No GLTF structure loaded");
+        }
+
+        const gltf = this.json;
+        const accessor = gltf.accessors[accessorIndex];
+        const bufferView = gltf.bufferViews[accessor.bufferView];
+
+        try {
+          const byteOffset = (bufferView.byteOffset || 0) + (accessor.byteOffset || 0);
+          const components = this.getNumComponents(accessor.type);
+          const count = accessor.count;
+          const byteLength = count * components * this.getComponentSize(accessor.componentType);
+
+          const array = await this.getBufferView(byteOffset, byteLength, accessor.componentType);
+
+          const attribute = new BufferAttribute(array, components);
+
+          if (accessor.min !== undefined) attribute.min = accessor.min;
+          if (accessor.max !== undefined) attribute.max = accessor.max;
+
+          return attribute;
+        } catch (error) {
+          if (error.name !== "AbortError") {
+            console.error("Error creating buffer attribute:", {
+              error,
+              accessor,
+              bufferView,
+            });
+          }
+
+          throw error;
+        }
+      }
+
+      getComponentSize(componentType) {
+        switch (componentType) {
+          case 5120: // BYTE
+          case 5121: // UNSIGNED_BYTE
+            return 1;
+          case 5122: // SHORT
+          case 5123: // UNSIGNED_SHORT
+            return 2;
+          case 5125: // UNSIGNED_INT
+          case 5126: // FLOAT
+            return 4;
+          default:
+            throw new Error(`Unknown component type: ${componentType}`);
+        }
+      }
+
+      getNumComponents(type) {
+        switch (type) {
+          case "SCALAR":
+            return 1;
+          case "VEC2":
+            return 2;
+          case "VEC3":
+            return 3;
+          case "VEC4":
+            return 4;
+          case "MAT2":
+            return 4;
+          case "MAT3":
+            return 9;
+          case "MAT4":
+            return 16;
+          default:
+            throw new Error(`Unknown type: ${type}`);
+        }
+      }
+
+      async loadTextures() {
+        if (!this.json.textures) return;
+
+        const loadTexture = async (imageIndex) => {
+          const image = this.json.images[imageIndex];
+
+          if (image.uri) {
+            // Handle base64 or URL
+            if (image.uri.startsWith("data:")) {
+              return await this.textureLoader.loadAsync(image.uri);
+            } else {
+              const fullUrl = this.baseUrl + image.uri;
+              return await this.textureLoader.loadAsync(fullUrl);
+            }
+          } else if (image.bufferView !== undefined) {
+            // Handle embedded binary data
+            const bufferView = this.json.bufferViews[image.bufferView];
+            const array = await this.getBufferView(
+              bufferView.byteOffset || 0,
+              bufferView.byteLength,
+              5121 // UNSIGNED_BYTE
+            );
+            const blob = new Blob([array], { type: image.mimeType });
+            const url = URL.createObjectURL(blob);
+            const texture = await this.textureLoader.loadAsync(url);
+            URL.revokeObjectURL(url);
+            texture.flipY = false; // GLTF standard
+            return texture;
+          }
+        };
+
+        // Load all textures
+        const texturePromises = [];
+        for (let i = 0; i < this.json.textures.length; i++) {
+          texturePromises.push(
+            loadTexture(this.json.textures[i].source).then((texture) => this.textureCache.set(i, texture))
+          );
+        }
+        await Promise.all(texturePromises);
+      }
+
+      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 = this.createMaterial(materialDef);
+          this.materials.set(i, material);
+        }
+        return this.materials;
+      }
+
+      createMaterial(materialDef) {
+        const material = new MeshStandardMaterial();
+
+        // Base color
+        if (materialDef.pbrMetallicRoughness) {
+          const pbr = materialDef.pbrMetallicRoughness;
+
+          if (pbr.baseColorFactor) {
+            material.color.fromArray(pbr.baseColorFactor);
+            material.opacity = pbr.baseColorFactor[3];
+          }
+
+          if (pbr.baseColorTexture) {
+            material.map = this.textureCache.get(pbr.baseColorTexture.index);
+          }
+
+          // Metallic and roughness
+          if (pbr.metallicFactor !== undefined) {
+            material.metalness = pbr.metallicFactor;
+          }
+          if (pbr.roughnessFactor !== undefined) {
+            material.roughness = pbr.roughnessFactor;
+          }
+          if (pbr.metallicRoughnessTexture) {
+            material.metalnessMap = this.textureCache.get(pbr.metallicRoughnessTexture.index);
+            material.roughnessMap = material.metalnessMap;
+          }
+        }
+
+        // Normal map
+        if (materialDef.normalTexture) {
+          material.normalMap = this.textureCache.get(materialDef.normalTexture.index);
+          if (materialDef.normalTexture.scale !== undefined) {
+            material.normalScale.set(materialDef.normalTexture.scale, materialDef.normalTexture.scale);
+          }
+        }
+
+        // Emissive
+        if (materialDef.emissiveFactor) {
+          material.emissive.fromArray(materialDef.emissiveFactor);
+        }
+        if (materialDef.emissiveTexture) {
+          material.emissiveMap = this.textureCache.get(materialDef.emissiveTexture.index);
+        }
+
+        // Occlusion
+        if (materialDef.occlusionTexture) {
+          material.aoMap = this.textureCache.get(materialDef.occlusionTexture.index);
+          if (materialDef.occlusionTexture.strength !== undefined) {
+            material.aoMapIntensity = materialDef.occlusionTexture.strength;
+          }
+        }
+
+        // Alpha mode
+        if (materialDef.alphaMode === "BLEND") {
+          material.transparent = true;
+        } else if (materialDef.alphaMode === "MASK") {
+          material.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;
+        }
+
+        // Double sided
+        material.side = materialDef.doubleSided ? DoubleSide : FrontSide;
+
+        material.name = materialDef.name;
+
+        return material;
+      }
+
+      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();
+          if (material.bumpMap) material.bumpMap.dispose();
+          if (material.normalMap) material.normalMap.dispose();
+          if (material.specularMap) material.specularMap.dispose();
+          if (material.envMap) material.envMap.dispose();
+          if (material.aoMap) material.aoMap.dispose();
+          if (material.metalnessMap) material.metalnessMap.dispose();
+          if (material.roughnessMap) material.roughnessMap.dispose();
+          if (material.emissiveMap) material.emissiveMap.dispose();
+          material.dispose();
+        });
+        this.materials.clear();
+      }
+
+      estimateNodeSize(meshIndex) {
+        if (!this.json.meshes) return 0;
+
+        const meshDef = this.json.meshes[meshIndex];
+        if (!meshDef || !meshDef.primitives) return 0;
+
+        let totalSize = 0;
+
+        // Estimate size for each primitive
+        for (const primitive of meshDef.primitives) {
+          // Check for attributes
+          if (primitive.attributes) {
+            // Calculate attributes size
+            for (const [, accessorIndex] of Object.entries(primitive.attributes)) {
+              if (accessorIndex === undefined) continue;
+
+              const accessor = this.json.accessors[accessorIndex];
+              if (!accessor) continue;
+
+              const numComponents = this.getNumComponents(accessor.type);
+              const bytesPerComponent = this.getComponentSize(accessor.componentType);
+              totalSize += accessor.count * numComponents * bytesPerComponent;
+            }
+          }
+
+          // Calculate indices size if present
+          if (primitive.indices !== undefined) {
+            const accessor = this.json.accessors[primitive.indices];
+            if (accessor) {
+              const bytesPerComponent = this.getComponentSize(accessor.componentType);
+              totalSize += accessor.count * bytesPerComponent;
+            }
+          }
+        }
+
+        return totalSize;
+      }
+    }
+
+    class DynamicGltfLoader {
+      constructor(camera, scene, renderer) {
+        this.camera = camera;
+        this.scene = scene;
+        this.renderer = renderer;
+
+        this.eventHandlers = {
+          geometryprogress: [],
+          databasechunk: [],
+          geometryend: [],
+          geometryerror: [],
+          update: [],
+          geometrymemory: [],
+        };
+
+        this.loadDistance = 100;
+        this.unloadDistance = 150;
+        this.checkInterval = 1000;
+
+        this.nodes = new Map();
+        this.loadedMeshes = new Map();
+        this.nodesToLoad = [];
+        this.edgeNodes = [];
+        this.structures = [];
+        this.structureRoots = new Map();
+
+        this.memoryLimit = this.getAvailableMemory();
+        this.loadedGeometrySize = 0;
+        this.geometryCache = new Map();
+        this.materialCache = new Map();
+        this.textureCache = new Map();
+        this.currentMemoryUsage = 0;
+
+        this.updateMemoryIndicator();
+
+        this.loadedMaterials = new Map();
+        this.abortController = new AbortController();
+
+        this.batchSize = 10000;
+        this.frameDelay = 0;
+
+        this.graphicsObjectLimit = 10000;
+        this.totalLoadedObjects = 0;
+
+        this.lastUpdateTime = 0;
+        this.updateInterval = 1000;
+
+        this.handleToObjects = new Map();
+
+        this.originalObjects = new Set();
+        this.originalObjectsToSelection = new Set();
+
+        this.optimizedOriginalMap = new Map();
+        this.mergedMesh = new Set();
+        this.mergedLines = new Set();
+        this.mergedLineSegments = new Set();
+        this.mergedPoints = new Set();
+
+        this.isolatedObjects = [];
+        this.useVAO = !!window.WebGL2RenderingContext && this.renderer.getContext() instanceof WebGL2RenderingContext;
+
+        this.handleToOptimizedObjects = new Map();
+
+        this.hiddenHandles = new Set();
+        this.newOptimizedObjects = new Set();
+        this.oldOptimizeObjects = new Set();
+      }
+
+      getAvailableMemory() {
+        let memoryLimit = 6 * 1024 * 1024 * 1024;
+        try {
+          if (navigator.deviceMemory) {
+            memoryLimit = navigator.deviceMemory * 1024 * 1024 * 1024;
+          } else if (performance.memory) {
+            const jsHeapSizeLimit = performance.memory.jsHeapSizeLimit;
+            if (jsHeapSizeLimit) {
+              memoryLimit = Math.min(memoryLimit, jsHeapSizeLimit);
+            }
+          }
+
+          memoryLimit = Math.min(memoryLimit, 16 * 1024 * 1024 * 1024);
+          memoryLimit = Math.max(memoryLimit, 2 * 1024 * 1024 * 1024);
+
+          console.log(`Available memory set to ${Math.round(memoryLimit / (1024 * 1024 * 1024))}GB`);
+        } catch (error) {
+          console.warn("Error detecting available memory:", error);
+        }
+
+        return memoryLimit;
+      }
+
+      getAbortController() {
+        return this.abortController;
+      }
+
+      abortLoading() {
+        this.abortController.abort();
+      }
+
+      updateMemoryIndicator() {
+        this.dispatchEvent("geometrymemory", {
+          currentUsage: this.currentMemoryUsage,
+          limit: this.memoryLimit,
+        });
+      }
+
+      setMemoryLimit(bytesLimit) {
+        // this.memoryLimit = bytesLimit;
+        //this.updateMemoryIndicator();
+        // console.log(`Memory limit set to ${Math.round(bytesLimit / (1024 * 1024))}MB`);
+      }
+
+      estimateGeometrySize(nodeGroup) {
+        let totalSize = 0;
+        nodeGroup.traverse((child) => {
+          if (child.geometry) {
+            if (this.abortController.signal.aborted) {
+              throw new DOMException("Loading aborted", "AbortError");
+            }
+            const geometry = child.geometry;
+
+            if (geometry.attributes) {
+              Object.values(geometry.attributes).forEach((attribute) => {
+                if (attribute && attribute.array) {
+                  totalSize += attribute.array.byteLength;
+                }
+              });
+            }
+
+            if (geometry.index && geometry.index.array) {
+              totalSize += geometry.index.array.byteLength;
+            }
+          }
+        });
+
+        return totalSize;
+      }
+
+      recalculateScene() {
+        const geometries = [];
+        this.scene.traverse((object) => {
+          if (this.abortController.signal.aborted) {
+            throw new DOMException("Loading aborted", "AbortError");
+          }
+
+          if (object.geometry && !this.geometryCache.has(object.geometry.uuid)) {
+            const size = this.estimateGeometrySize(object);
+            this.geometryCache.set(object.geometry.uuid, size);
+            geometries.push({
+              object,
+              size,
+              distance: object.position.distanceTo(this.camera.position),
+            });
+          }
+        });
+
+        if (this.abortController.signal.aborted) {
+          throw new DOMException("Loading aborted", "AbortError");
+        }
+
+        geometries.sort((a, b) => b.distance - a.distance);
+
+        let currentMemoryUsage = 0;
+        for (const geo of geometries) {
+          currentMemoryUsage += geo.size;
+        }
+
+        if (currentMemoryUsage > this.memoryLimit) {
+          console.log(`Memory usage (${Math.round(currentMemoryUsage / (1024 * 1024))}MB) exceeds limit`);
+
+          for (const geo of geometries) {
+            if (currentMemoryUsage <= this.memoryLimit) break;
+
+            if (this.abortController.signal.aborted) {
+              throw new DOMException("Loading aborted", "AbortError");
+            }
+
+            const object = geo.object;
+            if (object.geometry) {
+              currentMemoryUsage -= geo.size;
+              this.geometryCache.delete(object.geometry.uuid);
+              object.geometry.dispose();
+              object.visible = false;
+            }
+          }
+        }
+
+        this.currentMemoryUsage = currentMemoryUsage;
+        this.updateMemoryIndicator();
+
+        console.log(`Final memory usage: ${Math.round(currentMemoryUsage / (1024 * 1024))}MB`);
+      }
+
+      async loadNode(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node || node.loaded || node.loading) return;
+
+        node.loading = true;
+        const meshDef = node.structure.getJson().meshes[node.meshIndex];
+
+        try {
+          for (const primitive of meshDef.primitives) {
+            const positionAccessor = primitive.attributes.POSITION;
+            const geometry = new BufferGeometry();
+            const attributes = new Map();
+
+            attributes.set("position", node.structure.createBufferAttribute(positionAccessor));
+
+            if (primitive.attributes.NORMAL !== undefined) {
+              attributes.set("normal", node.structure.createBufferAttribute(primitive.attributes.NORMAL));
+            }
+
+            if (primitive.attributes.TEXCOORD_0 !== undefined) {
+              attributes.set("uv", node.structure.createBufferAttribute(primitive.attributes.TEXCOORD_0));
+            }
+
+            const loadedAttributes = await Promise.all(
+              [...attributes.entries()].map(async ([name, promise]) => {
+                const attribute = await promise;
+                return [name, attribute];
+              })
+            );
+
+            loadedAttributes.forEach(([name, attribute]) => {
+              geometry.setAttribute(name, attribute);
+            });
+
+            if (primitive.indices !== undefined) {
+              const indexAttribute = await node.structure.createBufferAttribute(primitive.indices);
+              geometry.setIndex(indexAttribute);
+            }
+
+            this.currentPrimitiveMode = primitive.mode;
+
+            let material;
+            if (primitive.material !== undefined) {
+              material = node.structure.materials.get(primitive.material) || this.createDefaultMaterial();
+            } else {
+              material = this.createDefaultMaterial();
+            }
+
+            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; // glTF spec says points should be 1px
+
+              mesh = new Points(geometry, pointsMaterial);
+            } else if (
+              primitive.mode === GL_CONSTANTS.TRIANGLES ||
+              primitive.mode === GL_CONSTANTS.TRIANGLE_STRIP ||
+              primitive.mode === GL_CONSTANTS.TRIANGLE_FAN ||
+              primitive.mode === undefined
+            ) {
+              mesh = new Mesh(geometry, material);
+
+              if (primitive.mode === GL_CONSTANTS.TRIANGLE_STRIP) {
+                mesh.drawMode = TriangleStripDrawMode;
+              } else if (primitive.mode === GL_CONSTANTS.TRIANGLE_FAN) {
+                mesh.drawMode = TriangleFanDrawMode;
+              }
+            } else if (primitive.mode === GL_CONSTANTS.LINES) {
+              mesh = new LineSegments(geometry, material);
+            } else if (primitive.mode === GL_CONSTANTS.LINE_STRIP) {
+              mesh = new Line$1(geometry, material);
+            } else if (primitive.mode === GL_CONSTANTS.LINE_LOOP) {
+              mesh = new LineLoop(geometry, material);
+            }
+
+            if (node.extras) {
+              mesh.userData = { ...mesh.userData, ...node.extras };
+            }
+
+            if (meshDef.extras) {
+              mesh.userData = { ...mesh.userData, ...meshDef.extras };
+            }
+
+            if (primitive.extras) {
+              mesh.userData = { ...mesh.userData, ...primitive.extras };
+            }
+
+            if (node.handle) {
+              mesh.userData.handle = node.handle;
+            } else {
+              mesh.userData.handle = `${node.structure.id}_${mesh.userData.handle}`;
+            }
+
+            if (mesh.material.name === "edges") {
+              mesh.userData.isEdge = true;
+            } else {
+              mesh.userData.isEdge = false;
+            }
+
+            this.registerObjectWithHandle(mesh, mesh.userData.handle);
+
+            mesh.position.copy(node.position);
+
+            if (!geometry.attributes.normal) {
+              geometry.computeVertexNormals();
+            }
+
+            if (material.aoMap && geometry.attributes.uv) {
+              geometry.setAttribute("uv2", geometry.attributes.uv);
+            }
+            if (node.group) {
+              node.group.add(mesh);
+            } else {
+              this.scene.add(mesh);
+            }
+            node.object = mesh;
+
+            this.totalLoadedObjects++;
+            mesh.visible = this.totalLoadedObjects < this.graphicsObjectLimit;
+          }
+
+          node.loaded = true;
+          node.loading = false;
+
+          const geometrySize = this.estimateGeometrySize(node.object);
+          this.geometryCache.set(node.object.uuid, geometrySize);
+          this.currentMemoryUsage += geometrySize;
+        } catch (error) {
+          if (error.name !== "AbortError") {
+            console.error(`Error loading node ${nodeId}:`, error);
+          }
+          node.loading = false;
+        }
+      }
+
+      unloadNode(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node || !node.loaded) return;
+
+        if (node.object) {
+          if (node.object.parent) {
+            node.object.parent.remove(node.object);
+          } else {
+            this.scene.remove(node.object);
+          }
+
+          node.object.traverse((child) => {
+            if (child.geometry) {
+              const geometrySize = this.geometryCache.get(child.geometry.uuid) || 0;
+              this.currentMemoryUsage -= geometrySize;
+              this.geometryCache.delete(child.geometry.uuid);
+              child.geometry.dispose();
+            }
+          });
+
+          node.object = null;
+          node.loaded = false;
+          this.updateMemoryIndicator();
+          console.log(`Unloaded node: ${nodeId}`);
+        }
+      }
+
+      checkDistances() {
+        const cameraPosition = this.camera.position;
+
+        this.nodes.forEach((node, nodeId) => {
+          const distance = cameraPosition.distanceTo(node.position);
+
+          if (node.loaded) {
+            if (distance > this.unloadDistance) {
+              this.unloadNode(nodeId);
+            }
+          } else if (!node.loading) {
+            if (distance < this.loadDistance) {
+              this.loadNode(nodeId);
+            }
+          }
+        });
+      }
+
+      async loadStructure(structures) {
+        this.clear();
+
+        const structureArray = Array.isArray(structures) ? structures : [structures];
+
+        for (const structure of structureArray) {
+          this.structures.push(structure);
+        }
+
+        for (const structure of this.structures) {
+          try {
+            await structure.loadTextures();
+            await structure.loadMaterials();
+          } catch (error) {
+            console.error("Error loading materials:", error);
+            throw error;
+          }
+        }
+
+        await this.processSceneHierarchy();
+      }
+
+      async processSceneHierarchy() {
+        if (this.structures.length === 0) {
+          throw new Error("No GLTF structures loaded");
+        }
+
+        this.nodesToLoad = [];
+
+        let estimatedSize = 0;
+
+        for (const structure of this.structures) {
+          const gltf = structure.getJson();
+
+          if (!gltf.scenes || !gltf.scenes.length) {
+            console.warn("No scenes found in GLTF structure");
+            continue;
+          }
+
+          estimatedSize += gltf.buffers[0].byteLength;
+
+          const rootGroup = new Group$1();
+          rootGroup.name = `structure_${structure.id}_root`;
+          this.scene.add(rootGroup);
+          this.structureRoots.set(structure.id, rootGroup);
+
+          const scene = gltf.scenes[gltf.scene || 0];
+
+          for (const nodeIndex of scene.nodes) {
+            await this.processNodeHierarchy(structure, nodeIndex, rootGroup);
+          }
+        }
+
+        const ignoreEdges = estimatedSize * 2 > this.memoryLimit;
+
+        this.nodesToLoad.sort((a, b) => {
+          const nodeA = this.nodes.get(a);
+          const nodeB = this.nodes.get(b);
+
+          if (!nodeA?.geometryExtents || !nodeB?.geometryExtents) {
+            return 0;
+          }
+
+          const sizeA = nodeA.geometryExtents.getSize(new Vector3());
+          const sizeB = nodeB.geometryExtents.getSize(new Vector3());
+          const volumeA = sizeA.x * sizeA.y * sizeA.z;
+          const volumeB = sizeB.x * sizeB.y * sizeB.z;
+
+          return volumeB - volumeA;
+        });
+
+        if (!ignoreEdges) {
+          this.nodesToLoad.push(...this.edgeNodes);
+        }
+
+        this.dispatchEvent("databasechunk", {
+          totalNodes: this.nodesToLoad.length,
+          structures: this.structures.map((s) => ({
+            id: s.id,
+            nodeCount: this.nodesToLoad.filter((nodeId) => nodeId.startsWith(s.id)).length,
+          })),
+        });
+      }
+
+      async processNodeHierarchy(structure, nodeId, parentGroup) {
+        const nodeDef = structure.json.nodes[nodeId];
+        let nodeGroup = null;
+
+        let handle = null;
+        if (nodeDef.extras?.handle) {
+          handle = `${structure.id}_${nodeDef.extras.handle}`;
+        }
+
+        if (nodeDef.camera !== undefined) {
+          const camera = this.loadCamera(structure, nodeDef.camera, nodeDef);
+          if (nodeDef.extras) {
+            camera.userData = { ...camera.userData, ...nodeDef.extras };
+          }
+          this.scene.add(camera);
+          return;
+        }
+
+        const needsGroup = this.needsGroupForNode(structure, nodeDef);
+
+        if (needsGroup) {
+          nodeGroup = new Group$1();
+          nodeGroup.name = nodeDef.name || `node_${nodeId}`;
+
+          if (nodeDef.extras) {
+            nodeGroup.userData = { ...nodeDef.extras };
+            if (nodeGroup.userData.handle) {
+              nodeGroup.userData.handle = `${structure.id}_${nodeGroup.userData.handle}`;
+            }
+          }
+
+          if (nodeDef.matrix) {
+            nodeGroup.matrix.fromArray(nodeDef.matrix);
+            nodeGroup.matrixAutoUpdate = false;
+          } else if (nodeDef.translation || nodeDef.rotation || nodeDef.scale) {
+            const position = nodeDef.translation ? new Vector3().fromArray(nodeDef.translation) : new Vector3();
+            const quaternion = nodeDef.rotation ? new Quaternion().fromArray(nodeDef.rotation) : new Quaternion();
+            const scale = nodeDef.scale ? new Vector3().fromArray(nodeDef.scale) : new Vector3(1, 1, 1);
+            nodeGroup.matrix.compose(position, quaternion, scale);
+            nodeGroup.matrixAutoUpdate = false;
+          }
+
+          if (parentGroup) {
+            parentGroup.add(nodeGroup);
+          }
+        }
+
+        if (nodeDef.mesh !== undefined) {
+          const nodeMatrix = new Matrix4();
+          const uniqueNodeId = `${structure.id}_${nodeId}`;
+          const meshDef = structure.json.meshes[nodeDef.mesh];
+          const geometryExtents = new Box3();
+
+          for (const primitive of meshDef.primitives) {
+            const positionAccessor = structure.json.accessors[primitive.attributes.POSITION];
+            if (positionAccessor && positionAccessor.min && positionAccessor.max) {
+              const primitiveBox = new Box3(
+                new Vector3().fromArray(positionAccessor.min),
+                new Vector3().fromArray(positionAccessor.max)
+              );
+              geometryExtents.union(primitiveBox);
+            }
+          }
+
+          let isEdge = false;
+          if (meshDef.primitives[0].material !== undefined) {
+            const material = structure.json.materials[meshDef.primitives[0].material];
+            if (material?.name === "edges") {
+              isEdge = true;
+            }
+          }
+
+          if (!isEdge) {
+            this.nodesToLoad.push(uniqueNodeId);
+          } else {
+            this.edgeNodes.push(uniqueNodeId);
+          }
+
+          this.nodes.set(uniqueNodeId, {
+            position: nodeGroup ? nodeGroup.position.clone() : new Vector3().setFromMatrixPosition(nodeMatrix),
+            nodeIndex: nodeId,
+            meshIndex: nodeDef.mesh,
+            loaded: false,
+            loading: false,
+            object: null,
+            group: nodeGroup || parentGroup,
+            structure,
+            extras: nodeDef.extras,
+            geometryExtents,
+            handle,
+          });
+        }
+
+        if (nodeDef.children) {
+          for (const childId of nodeDef.children) {
+            await this.processNodeHierarchy(structure, childId, nodeGroup || parentGroup);
+          }
+        }
+
+        return nodeGroup;
+      }
+
+      needsGroupForNode(structure, nodeDef) {
+        const hasTransforms = nodeDef.matrix || nodeDef.translation || nodeDef.rotation || nodeDef.scale;
+
+        const hasMultiplePrimitives =
+          nodeDef.mesh !== undefined && structure.json.meshes[nodeDef.mesh].primitives.length > 1;
+
+        return hasTransforms !== undefined || hasMultiplePrimitives;
+      }
+
+      async processNodes() {
+        const nodesToLoad = this.nodesToLoad;
+        let loadedCount = 0;
+        const totalNodes = nodesToLoad.length;
+
+        try {
+          while (loadedCount < totalNodes) {
+            const batch = nodesToLoad.slice(loadedCount, loadedCount + this.batchSize);
+            const batchPromises = [];
+
+            for (const nodeId of batch) {
+              if (this.abortController.signal.aborted) {
+                throw new DOMException("Loading aborted", "AbortError");
+              }
+
+              const estimatedSize = await this.estimateNodeSize(nodeId);
+
+              if (this.currentMemoryUsage + estimatedSize > this.memoryLimit) {
+                console.log(`Memory limit reached after loading ${loadedCount} nodes`);
+                this.dispatchEvent("geometryerror", { message: "Memory limit reached" });
+                this.dispatchEvent("update");
+                return loadedCount;
+              }
+
+              batchPromises.push(this.loadNode(nodeId));
+            }
+
+            await Promise.all(batchPromises);
+            loadedCount += batch.length;
+
+            this.updateMemoryIndicator();
+            this.dispatchEvent("geometryprogress", {
+              percentage: Math.round((loadedCount / totalNodes) * 100),
+              loaded: loadedCount,
+              total: totalNodes,
+            });
+
+            const currentTime = Date.now();
+            if (currentTime - this.lastUpdateTime >= this.updateInterval) {
+              this.dispatchEvent("update");
+              this.lastUpdateTime = currentTime;
+            }
+
+            await new Promise((resolve) => {
+              setTimeout(resolve, 0);
+            });
+          }
+
+          this.dispatchEvent("geometryend", {
+            totalLoaded: loadedCount,
+            totalNodes,
+          });
+
+          return loadedCount;
+        } catch (error) {
+          this.dispatchEvent("geometryerror", { error });
+          throw error;
+        }
+      }
+
+      async loadNodes() {
+        console.time("process nodes");
+        await this.processNodes();
+        console.timeEnd("process nodes");
+
+        console.time("optimize scene");
+        await this.optimizeScene();
+        console.timeEnd("optimize scene");
+      }
+
+      cleanupPartialLoad() {
+        this.nodesToLoad.forEach((nodeId) => {
+          const node = this.nodes.get(nodeId);
+          if (node && node.loading) {
+            this.unloadNode(nodeId);
+          }
+        });
+      }
+
+      createDefaultMaterial() {
+        if (this.currentPrimitiveMode === GL_CONSTANTS.POINTS) {
+          return new PointsMaterial({
+            color: new Color(0x808080),
+            size: 0.05,
+            sizeAttenuation: true,
+            alphaTest: 0.5,
+            transparent: true,
+            vertexColors: false,
+            blending: NormalBlending,
+            depthWrite: false,
+            depthTest: true,
+          });
+        } else {
+          return new MeshStandardMaterial({
+            color: 0x808080,
+            metalness: 0.0,
+            roughness: 1.0,
+            side: DoubleSide,
+          });
+        }
+      }
+
+      async estimateNodeSize(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return 0;
+        return await node.structure.estimateNodeSize(node.meshIndex);
+      }
+
+      getTotalGeometryExtent() {
+        const totalExtent = new Box3();
+
+        for (const node of this.nodes.values()) {
+          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);
+            }
+          }
+          totalExtent.union(transformedBox);
+        }
+
+        return totalExtent;
+      }
+
+      loadCamera(structure, cameraIndex, nodeDef) {
+        const cameraDef = structure.getJson().cameras[cameraIndex];
+        const params = cameraDef[cameraDef.type];
+
+        let camera;
+        if (cameraDef.type === "perspective") {
+          camera = new PerspectiveCamera(
+            MathUtils.radToDeg(params.yfov),
+            params.aspectRatio || 1,
+            params.znear || 1,
+            params.zfar || 2e6
+          );
+        } else if (cameraDef.type === "orthographic") {
+          camera = new OrthographicCamera(
+            params.xmag / -2,
+            params.xmag / 2,
+            params.ymag / 2,
+            params.ymag / -2,
+            params.znear,
+            params.zfar
+          );
+        }
+
+        if (nodeDef.matrix) {
+          camera.matrix.fromArray(nodeDef.matrix);
+          camera.matrix.decompose(camera.position, camera.quaternion, camera.scale);
+        } else {
+          if (nodeDef.translation) {
+            camera.position.fromArray(nodeDef.translation);
+          }
+          if (nodeDef.rotation) {
+            camera.quaternion.fromArray(nodeDef.rotation);
+          }
+          if (nodeDef.scale) {
+            camera.scale.fromArray(nodeDef.scale);
+          }
+        }
+
+        return camera;
+      }
+
+      clearNodesToLoad() {
+        this.nodesToLoad = [];
+      }
+
+      async addStructure(loadController) {
+        const structure = new GltfStructure();
+        await structure.initialize(loadController);
+        this.structures.push(structure);
+        return structure;
+      }
+
+      removeOptimization() {
+        this.originalObjects.forEach((obj) => (obj.visible = true));
+
+        const disposeMerged = (obj) => {
+          if (obj.parent) {
+            obj.parent.remove(obj);
+          }
+          if (obj.geometry) {
+            obj.geometry.dispose();
+          }
+        };
+
+        if (this.structureGroups) {
+          for (const group of this.structureGroups.values()) {
+            group.meshes.forEach(disposeMerged);
+            group.lines.forEach(disposeMerged);
+            group.lineSegments.forEach(disposeMerged);
+            group.meshes.clear();
+            group.lines.clear();
+            group.lineSegments.clear();
+          }
+        }
+        this.optimizedOriginalMap.clear();
+        this.mergedMesh.clear();
+        this.mergedLines.clear();
+        this.mergedLineSegments.clear();
+        this.originalObjects.clear();
+        this.originalObjectsToSelection.clear();
+      }
+
+      clear() {
+        // Clear all structures
+        this.structures.forEach((structure) => {
+          if (structure) {
+            structure.clear();
+          }
+        });
+        this.structures = [];
+
+        // Clear all nodes and unload their objects
+        this.nodes.forEach((node) => {
+          if (node.object) {
+            if (node.object.parent) {
+              node.object.parent.remove(node.object);
+            }
+            if (node.object.geometry) {
+              node.object.geometry.dispose();
+            }
+            if (node.object.material) {
+              if (Array.isArray(node.object.material)) {
+                node.object.material.forEach((material) => material.dispose());
+              } else {
+                node.object.material.dispose();
+              }
+            }
+          }
+        });
+        this.nodes.clear();
+
+        // Clear all loaded meshes
+        this.loadedMeshes.forEach((mesh) => {
+          if (mesh.geometry) mesh.geometry.dispose();
+          if (mesh.material) {
+            if (Array.isArray(mesh.material)) {
+              mesh.material.forEach((material) => material.dispose());
+            } else {
+              mesh.material.dispose();
+            }
+          }
+        });
+        this.loadedMeshes.clear();
+
+        // Clear all structure roots and their children
+        this.structureRoots.forEach((rootGroup) => {
+          if (rootGroup) {
+            rootGroup.traverse((child) => {
+              if (child.geometry) child.geometry.dispose();
+              if (child.material) {
+                if (Array.isArray(child.material)) {
+                  child.material.forEach((material) => material.dispose());
+                } else {
+                  child.material.dispose();
+                }
+              }
+            });
+            if (rootGroup.parent) {
+              rootGroup.parent.remove(rootGroup);
+            }
+          }
+        });
+        this.structureRoots.clear();
+
+        // Clear all optimized objects
+        this.mergedMesh.forEach((mesh) => {
+          if (mesh.geometry) mesh.geometry.dispose();
+          if (mesh.material) {
+            if (Array.isArray(mesh.material)) {
+              mesh.material.forEach((material) => material.dispose());
+            } else {
+              mesh.material.dispose();
+            }
+          }
+          if (mesh.parent) mesh.parent.remove(mesh);
+        });
+        this.mergedMesh.clear();
+
+        this.mergedLines.forEach((line) => {
+          if (line.geometry) line.geometry.dispose();
+          if (line.material) line.material.dispose();
+          if (line.parent) line.parent.remove(line);
+        });
+        this.mergedLines.clear();
+
+        this.mergedLineSegments.forEach((lineSegment) => {
+          if (lineSegment.geometry) lineSegment.geometry.dispose();
+          if (lineSegment.material) lineSegment.material.dispose();
+          if (lineSegment.parent) lineSegment.parent.remove(lineSegment);
+        });
+        this.mergedLineSegments.clear();
+
+        this.mergedPoints.forEach((points) => {
+          if (points.geometry) points.geometry.dispose();
+          if (points.material) points.material.dispose();
+          if (points.parent) points.parent.remove(points);
+        });
+        this.mergedPoints.clear();
+
+        // Clear all caches
+        this.geometryCache.clear();
+        this.materialCache.clear();
+        this.textureCache.clear();
+        this.loadedMaterials.clear();
+
+        // Clear all maps and sets
+        this.nodesToLoad = [];
+        this.handleToObjects.clear();
+        this.originalObjects.clear();
+        this.originalObjectsToSelection.clear();
+        this.optimizedOriginalMap.clear();
+        this.handleToOptimizedObjects.clear();
+        this.hiddenHandles.clear();
+        this.newOptimizedObjects.clear();
+        this.oldOptimizeObjects.clear();
+        this.isolatedObjects = [];
+
+        // Reset counters and state
+        this.totalLoadedObjects = 0;
+        this.lastUpdateTime = 0;
+        this.currentMemoryUsage = 0;
+        this.loadedGeometrySize = 0;
+
+        this.abortController = new AbortController();
+        this.updateMemoryIndicator();
+      }
+
+      setStructureTransform(structureId, matrix) {
+        const rootGroup = this.structureRoots.get(structureId);
+        if (rootGroup) {
+          rootGroup.matrix.copy(matrix);
+          rootGroup.matrix.decompose(rootGroup.position, rootGroup.quaternion, rootGroup.scale);
+          return true;
+        }
+        return false;
+      }
+
+      getStructureRootGroup(structureId) {
+        return this.structureRoots.get(structureId);
+      }
+
+      addEventListener(event, handler) {
+        if (this.eventHandlers[event]) {
+          this.eventHandlers[event].push(handler);
+        }
+      }
+
+      removeEventListener(event, handler) {
+        if (this.eventHandlers[event]) {
+          this.eventHandlers[event] = this.eventHandlers[event].filter((h) => h !== handler);
+        }
+      }
+
+      dispatchEvent(event, data) {
+        if (this.eventHandlers[event]) {
+          this.eventHandlers[event].forEach((handler) => handler(data));
+        }
+      }
+
+      registerObjectWithHandle(object, handle) {
+        if (!handle) return;
+
+        const fullHandle = object.userData.handle;
+        if (!this.handleToObjects.has(fullHandle)) {
+          this.handleToObjects.set(fullHandle, new Set());
+        }
+        this.handleToObjects.get(fullHandle).add(object);
+
+        object.userData.structureId = object.userData.handle.split("_")[0];
+      }
+
+      getObjectsByHandle(handle) {
+        if (!handle) return [];
+        return Array.from(this.handleToObjects.get(handle) || []);
+      }
+
+      getHandlesByObjects(objects) {
+        if (!objects.length) return [];
+        const handles = new Set();
+        objects.forEach((obj) => {
+          if (this.originalObjects.has(obj)) handles.add(obj.userData.handle);
+        });
+        return Array.from(handles);
+      }
+
+      getMaterialId(material, index) {
+        const props = {
+          type: material.type,
+          color: material.color?.getHex(),
+          map: material.map?.uuid,
+          transparent: material.transparent,
+          opacity: material.opacity,
+          side: material.side,
+          index: index ? 1 : 0,
+        };
+        return JSON.stringify(props);
+      }
+
+      addToMaterialGroup(object, groupsMap, optimizeGroupList) {
+        const VERTEX_LIMIT = 100_000;
+        const INDEX_LIMIT = 100_000;
+
+        const objectGeometryVertexCount = object.geometry.attributes.position.count;
+        const objectGeometryIndexCount = object.geometry.index ? object.geometry.index.count : 0;
+
+        const material = object.material;
+        let materialId = this.getMaterialId(material, object.geometry.index !== null);
+
+        let group;
+        if (!groupsMap.has(materialId)) {
+          group = {
+            material,
+            objects: [object],
+            totalVertices: objectGeometryVertexCount,
+            totalIndices: objectGeometryIndexCount,
+          };
+          groupsMap.set(materialId, group);
+          optimizeGroupList.push(group);
+        } else {
+          group = groupsMap.get(materialId);
+          if (
+            group.totalVertices + objectGeometryVertexCount > VERTEX_LIMIT ||
+            group.totalIndices + objectGeometryIndexCount > INDEX_LIMIT
+          ) {
+            const newGroup = {
+              material,
+              objects: [object],
+              totalVertices: objectGeometryVertexCount,
+              totalIndices: objectGeometryIndexCount,
+            };
+            materialId = this.getMaterialId(material, object.geometry.index !== null);
+            groupsMap.set(materialId, newGroup);
+            optimizeGroupList.push(newGroup);
+          } else {
+            group.objects.push(object);
+            group.totalVertices += objectGeometryVertexCount;
+            group.totalIndices += objectGeometryIndexCount;
+          }
+        }
+
+        this.originalObjects.add(object);
+      }
+
+      optimizeScene() {
+        this.originalObjects.clear();
+        this.originalObjectsToSelection.clear();
+        const structureGroups = new Map();
+
+        this.scene.traverse((object) => {
+          if (object.userData.structureId) {
+            const structureId = object.userData.structureId;
+            if (!structureGroups.has(structureId)) {
+              structureGroups.set(structureId, {
+                mapMeshes: new Map(),
+                mapLines: new Map(),
+                mapLineSegments: new Map(),
+                mapPoints: new Map(),
+
+                meshes: [],
+                lines: [],
+                lineSegments: [],
+                points: [],
+                rootGroup: this.structureRoots.get(structureId),
+              });
+            }
+
+            const group = structureGroups.get(structureId);
+
+            if (object instanceof Mesh) {
+              this.addToMaterialGroup(object, group.mapMeshes, group.meshes);
+            } else if (object instanceof LineSegments) {
+              this.addToMaterialGroup(object, group.mapLineSegments, group.lineSegments);
+            } else if (object instanceof Line$1) {
+              this.addToMaterialGroup(object, group.mapLines, group.lines);
+            } else if (object instanceof Points) {
+              this.addToMaterialGroup(object, group.mapPoints, group.points);
+            }
+          }
+        });
+
+        for (const group of structureGroups.values()) {
+          group.mapMeshes.clear();
+          group.mapLines.clear();
+          group.mapLineSegments.clear();
+          group.mapPoints.clear();
+
+          this.mergeMeshGroups(group.meshes, group.rootGroup);
+          this.mergeLineGroups(group.lines, group.rootGroup);
+          this.mergeLineSegmentGroups(group.lineSegments, group.rootGroup);
+          this.mergePointsGroups(group.points, group.rootGroup);
+        }
+
+        this.originalObjects.forEach((obj) => {
+          obj.visible = false;
+          if (!(obj instanceof Points) && !obj.userData.isEdge) {
+            this.originalObjectsToSelection.add(obj);
+          }
+        });
+
+        this.dispatchEvent("update");
+      }
+
+      mergeMeshGroups(materialGroups, rootGroup) {
+        for (const group of materialGroups) {
+          try {
+            const geometries = [];
+            const handles = new Set();
+            const optimizedObjects = [];
+
+            for (const mesh of group.objects) {
+              const geometry = mesh.geometry.clone();
+              mesh.updateWorldMatrix(true, false);
+              geometry.applyMatrix4(mesh.matrixWorld);
+              geometries.push(geometry);
+
+              optimizedObjects.push(mesh);
+              handles.add(mesh.userData.handle);
+            }
+
+            const mergedObjects = [];
+
+            if (geometries.length > 0) {
+              const mergedGeometry = mergeGeometries(geometries);
+              if (this.useVAO) {
+                this.createVAO(mergedGeometry);
+              }
+
+              const mergedMesh = new Mesh(mergedGeometry, group.material);
+              rootGroup.add(mergedMesh);
+
+              this.mergedMesh.add(mergedMesh);
+              this.optimizedOriginalMap.set(mergedMesh, optimizedObjects);
+
+              mergedObjects.push(mergedMesh);
+
+              geometries.forEach((geometry) => {
+                geometry.dispose();
+              });
+            }
+
+            handles.forEach((handle) => {
+              if (this.handleToOptimizedObjects.has(handle)) {
+                const existingObjects = this.handleToOptimizedObjects.get(handle);
+                existingObjects.push(...mergedObjects);
+                this.handleToOptimizedObjects.set(handle, existingObjects);
+              } else {
+                this.handleToOptimizedObjects.set(handle, mergedObjects);
+              }
+            });
+          } catch (error) {
+            console.error("Failed to merge meshes for material:", error);
+            group.objects.forEach((mesh) => {
+              mesh.visible = true;
+            });
+          }
+        }
+      }
+
+      mergeLineGroups(materialGroups, rootGroup) {
+        for (const group of materialGroups) {
+          if (group.objects.length === 0) continue;
+
+          const handles = new Set();
+          let totalVertices = 0;
+          group.objects.map((line) => {
+            handles.add(line.userData.handle);
+            totalVertices += line.geometry.attributes.position.count;
+          });
+
+          const positions = new Float32Array(totalVertices * 3);
+          let posOffset = 0;
+
+          const indices = [];
+          let vertexOffset = 0;
+
+          group.objects.forEach((line) => {
+            const geometry = line.geometry;
+            const positionAttr = geometry.attributes.position;
+            const vertexCount = positionAttr.count;
+
+            line.updateWorldMatrix(true, false);
+            const matrix = line.matrixWorld;
+            const vector = new Vector3();
+
+            for (let i = 0; i < vertexCount; i++) {
+              vector.fromBufferAttribute(positionAttr, i);
+              vector.applyMatrix4(matrix);
+              positions[posOffset++] = vector.x;
+              positions[posOffset++] = vector.y;
+              positions[posOffset++] = vector.z;
+            }
+
+            for (let i = 0; i < vertexCount - 1; i++) {
+              indices.push(vertexOffset + i, vertexOffset + i + 1);
+            }
+
+            vertexOffset += vertexCount;
+          });
+
+          const geometry = new BufferGeometry();
+          geometry.setAttribute("position", new BufferAttribute(positions, 3));
+          geometry.setIndex(indices);
+          geometry.computeBoundingSphere();
+          geometry.computeBoundingBox();
+
+          const mergedLine = new LineSegments(geometry, group.material);
+          const mergedObjects = [mergedLine];
+          if (this.useVAO) {
+            this.createVAO(mergedLine);
+          }
+          rootGroup.add(mergedLine);
+          this.mergedLines.add(mergedLine);
+          this.optimizedOriginalMap.set(mergedLine, group.objects);
+
+          handles.forEach((handle) => {
+            if (this.handleToOptimizedObjects.has(handle)) {
+              const existingObjects = this.handleToOptimizedObjects.get(handle);
+              existingObjects.push(...mergedObjects);
+              this.handleToOptimizedObjects.set(handle, existingObjects);
+            } else {
+              this.handleToOptimizedObjects.set(handle, mergedObjects);
+            }
+          });
+        }
+      }
+
+      mergeLineSegmentGroups(materialGroups, rootGroup) {
+        for (const group of materialGroups) {
+          try {
+            const geometries = [];
+            const optimizedObjects = [];
+            const handles = new Set();
+
+            for (const line of group.objects) {
+              const geometry = line.geometry.clone();
+              line.updateWorldMatrix(true, false);
+              geometry.applyMatrix4(line.matrixWorld);
+              geometries.push(geometry);
+              optimizedObjects.push(line);
+              handles.add(line.userData.handle);
+            }
+
+            const mergedObjects = [];
+
+            if (geometries.length > 0) {
+              const mergedGeometry = mergeGeometries(geometries, false);
+              const mergedLine = new LineSegments(mergedGeometry, group.material);
+
+              if (this.useVAO) {
+                this.createVAO(mergedLine);
+              }
+
+              rootGroup.add(mergedLine);
+              this.mergedLineSegments.add(mergedLine);
+              this.optimizedOriginalMap.set(mergedLine, optimizedObjects);
+              mergedObjects.push(mergedLine);
+
+              geometries.forEach((geometry) => {
+                geometry.dispose();
+              });
+            }
+
+            handles.forEach((handle) => {
+              if (this.handleToOptimizedObjects.has(handle)) {
+                const existingObjects = this.handleToOptimizedObjects.get(handle);
+                existingObjects.push(...mergedObjects);
+                this.handleToOptimizedObjects.set(handle, existingObjects);
+              } else {
+                this.handleToOptimizedObjects.set(handle, mergedObjects);
+              }
+            });
+          } catch (error) {
+            console.warn("Failed to merge line segments for material:", error);
+            group.objects.forEach((line) => {
+              line.visible = true;
+            });
+          }
+        }
+      }
+
+      mergePointsGroups(materialGroups, rootGroup) {
+        for (const group of materialGroups) {
+          try {
+            const geometries = [];
+            const optimizedObjects = [];
+            const handles = new Set();
+
+            for (const points of group.objects) {
+              const geometry = points.geometry.clone();
+              points.updateWorldMatrix(true, false);
+              geometry.applyMatrix4(points.matrixWorld);
+              geometries.push(geometry);
+              optimizedObjects.push(points);
+              handles.add(points.userData.handle);
+            }
+
+            const mergedObjects = [];
+
+            if (geometries.length > 0) {
+              const mergedGeometry = mergeGeometries(geometries, false);
+              const mergedPoints = new Points(mergedGeometry, group.material);
+
+              if (this.useVAO) {
+                this.createVAO(mergedPoints);
+              }
+
+              rootGroup.add(mergedPoints);
+
+              this.mergedPoints.add(mergedPoints);
+              this.optimizedOriginalMap.set(mergedPoints, optimizedObjects);
+              mergedObjects.push(mergedPoints);
+
+              geometries.forEach((geometry) => {
+                geometry.dispose();
+              });
+            }
+
+            handles.forEach((handle) => {
+              if (this.handleToOptimizedObjects.has(handle)) {
+                const existingObjects = this.handleToOptimizedObjects.get(handle);
+                existingObjects.push(...mergedObjects);
+                this.handleToOptimizedObjects.set(handle, existingObjects);
+              } else {
+                this.handleToOptimizedObjects.set(handle, mergedObjects);
+              }
+            });
+          } catch (error) {
+            console.warn("Failed to merge points for material:", error);
+            group.objects.forEach((points) => {
+              points.visible = true;
+            });
+          }
+        }
+      }
+
+      mergeInSingleSegment(structureId, rootGroup) {
+        const lineSegmentsArray = [...this.mergedLineSegments, ...this.mergedLines].filter(
+          (obj) => obj.userData.structureId === structureId
+        );
+
+        if (lineSegmentsArray.length === 0) return;
+
+        try {
+          const geometriesWithIndex = [];
+          const hasNormals = lineSegmentsArray.some((segment) => segment.geometry.attributes.normal !== undefined);
+
+          lineSegmentsArray.forEach((segment) => {
+            const clonedGeometry = segment.geometry.clone();
+            segment.updateWorldMatrix(true, false);
+            clonedGeometry.applyMatrix4(segment.matrixWorld);
+
+            if (hasNormals && !clonedGeometry.attributes.normal) {
+              clonedGeometry.computeVertexNormals();
+            }
+            if (!hasNormals && clonedGeometry.attributes.normal) {
+              clonedGeometry.deleteAttribute("normal");
+            }
+
+            const colorArray = new Float32Array(clonedGeometry.attributes.position.count * 3);
+            for (let i = 0; i < colorArray.length; i += 3) {
+              colorArray[i] = segment.material.color.r;
+              colorArray[i + 1] = segment.material.color.g;
+              colorArray[i + 2] = segment.material.color.b;
+            }
+            clonedGeometry.setAttribute("color", new BufferAttribute(colorArray, 3));
+
+            if (!clonedGeometry.index) {
+              const indices = [];
+              const posCount = clonedGeometry.attributes.position.count;
+              for (let i = 0; i < posCount - 1; i += 2) {
+                indices.push(i, i + 1);
+              }
+              clonedGeometry.setIndex(indices);
+            }
+
+            geometriesWithIndex.push(clonedGeometry);
+          });
+
+          const finalGeometry = mergeGeometries(geometriesWithIndex, false);
+          const material = new LineBasicMaterial({
+            vertexColors: true,
+          });
+
+          if (this.useVAO) {
+            this.createVAO(finalGeometry);
+          }
+
+          const mergedLine = new LineSegments(finalGeometry, material);
+          mergedLine.userData.structureId = structureId;
+          rootGroup.add(mergedLine);
+          this.mergedLineSegments.add(mergedLine);
+
+          lineSegmentsArray.forEach((obj) => {
+            if (obj.parent) {
+              obj.parent.remove(obj);
+            }
+            obj.geometry.dispose();
+          });
+        } catch (error) {
+          console.error("Failed to merge geometries:", error);
+          lineSegmentsArray.forEach((obj) => {
+            obj.visible = true;
+            rootGroup.add(obj);
+          });
+        }
+      }
+
+      showOriginalObjects(objects) {
+        objects.forEach((obj) => {
+          if (this.originalObjects.has(obj)) {
+            obj.visible = true;
+          }
+        });
+      }
+
+      hideOriginalObjects(objects) {
+        objects.forEach((obj) => {
+          if (this.originalObjects.has(obj)) {
+            obj.visible = false;
+          }
+        });
+      }
+
+      createVAO(geometry) {
+        if (!this.useVAO) {
+          return;
+        }
 
-    		}
+        if (geometry.attributes?.position?.count < 1000) {
+          return;
+        }
 
-    		// As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets.
-    		box.expandByVector( maxDisplacement );
+        const gl = this.renderer.getContext();
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
 
-    	}
+        for (const name in geometry.attributes) {
+          const attribute = geometry.attributes[name];
+          const buffer = this.renderer.properties.get(attribute).buffer;
 
-    	geometry.boundingBox = box;
+          gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+          gl.enableVertexAttribArray(attribute.itemSize);
+          gl.vertexAttribPointer(attribute.itemSize, attribute.itemSize, gl.FLOAT, false, 0, 0);
+        }
 
-    	const sphere = new Sphere();
+        if (geometry.index) {
+          const indexBuffer = this.renderer.properties.get(geometry.index).buffer;
+          gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+        }
 
-    	box.getCenter( sphere.center );
-    	sphere.radius = box.min.distanceTo( box.max ) / 2;
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
 
-    	geometry.boundingSphere = sphere;
+        geometry.vao = vao;
+      }
 
-    }
+      getOriginalObjectForSelect() {
+        const optimizedOriginals = [];
 
-    /**
-     * @param {BufferGeometry} geometry
-     * @param {GLTF.Primitive} primitiveDef
-     * @param {GLTFParser} parser
-     * @return {Promise<BufferGeometry>}
-     */
-    function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
+        for (const obj of this.originalObjectsToSelection) {
+          if (this.hiddenHandles.has(obj.userData.handle)) {
+            continue;
+          }
 
-    	const attributes = primitiveDef.attributes;
+          optimizedOriginals.push(obj);
+        }
 
-    	const pending = [];
+        return optimizedOriginals;
+      }
 
-    	function assignAttributeAccessor( accessorIndex, attributeName ) {
+      isolateObjects(handles) {
+        if (this.hiddenHandles.size !== 0) {
+          this.hiddenHandles.clear();
+          this.syncHiddenObjects();
+        }
 
-    		return parser.getDependency( 'accessor', accessorIndex )
-    			.then( function ( accessor ) {
+        for (const handle of this.handleToOptimizedObjects.keys()) {
+          if (!handles.has(handle)) {
+            this.hiddenHandles.add(handle);
+          }
+        }
 
-    				geometry.setAttribute( attributeName, accessor );
+        this.syncHiddenObjects();
+      }
 
-    			} );
+      showAllHiddenObjects() {
+        this.hiddenHandles.clear();
+        this.syncHiddenObjects();
+      }
 
-    	}
+      hideObjects(handles) {
+        handles.forEach((handle) => {
+          this.hiddenHandles.add(handle);
+        });
+        this.syncHiddenObjects();
+      }
 
-    	for ( const gltfAttributeName in attributes ) {
+      showObjects(handles) {
+        handles.forEach((handle) => {
+          this.hiddenHandles.delete(handle);
+        });
+        this.syncHiddenObjects();
+      }
 
-    		const threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase();
+      syncHiddenObjects() {
+        if (this.oldOptimizeObjects.size !== 0) {
+          for (const obj of this.oldOptimizeObjects) {
+            obj.visible = true;
+          }
+          this.oldOptimizeObjects.clear();
+        }
 
-    		// Skip attributes already provided by e.g. Draco extension.
-    		if ( threeAttributeName in geometry.attributes ) continue;
+        if (this.newOptimizedObjects.size !== 0) {
+          for (const obj of this.newOptimizedObjects) {
+            obj.visible = false;
+            obj.geometry.dispose();
+            obj.parent.remove(obj);
+          }
+          this.newOptimizedObjects.clear();
+        }
 
-    		pending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) );
+        if (this.hiddenHandles.size === 0) {
+          return;
+        }
 
-    	}
+        this.hiddenHandles.forEach((handle) => {
+          const objects = this.handleToOptimizedObjects.get(handle);
+          if (objects) {
+            objects.forEach((x) => this.oldOptimizeObjects.add(x));
+          }
+        });
 
-    	if ( primitiveDef.indices !== undefined && ! geometry.index ) {
+        this.oldOptimizeObjects.forEach((optimizedObject) => {
+          optimizedObject.visible = false;
 
-    		const accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) {
+          const originObjects = this.optimizedOriginalMap.get(optimizedObject);
+          const updateListToOptimize = [];
+          originObjects.forEach((obj) => {
+            if (!this.hiddenHandles.has(obj.userData.handle)) {
+              updateListToOptimize.push(obj);
+            }
+          });
 
-    			geometry.setIndex( accessor );
+          const firstObject = updateListToOptimize[0];
 
-    		} );
+          if (firstObject instanceof Mesh || firstObject instanceof LineSegments) {
+            const geometries = updateListToOptimize.map((obj) => {
+              const geometry = obj.geometry.clone();
+              obj.updateWorldMatrix(true, false);
+              geometry.applyMatrix4(obj.matrixWorld);
+              return geometry;
+            });
 
-    		pending.push( accessor );
+            const newMergedGeometry = mergeGeometries(geometries);
+            const mergedObject =
+              firstObject instanceof Mesh
+                ? new Mesh(newMergedGeometry, optimizedObject.material)
+                : new LineSegments(newMergedGeometry, optimizedObject.material);
 
-    	}
+            mergedObject.visible = true;
+            optimizedObject.parent.add(mergedObject);
+            this.newOptimizedObjects.add(mergedObject);
 
-    	if ( ColorManagement.workingColorSpace !== LinearSRGBColorSpace && 'COLOR_0' in attributes ) {
+            geometries.forEach((geometry) => {
+              geometry.dispose();
+            });
+          } else if (firstObject instanceof Line$1) {
+            let totalVertices = 0;
+            updateListToOptimize.map((line) => {
+              totalVertices += line.geometry.attributes.position.count;
+            });
 
-    		console.warn( `THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${ColorManagement.workingColorSpace}" not supported.` );
+            const positions = new Float32Array(totalVertices * 3);
+            let posOffset = 0;
 
-    	}
+            const indices = [];
+            let vertexOffset = 0;
 
-    	assignExtrasToUserData( geometry, primitiveDef );
+            updateListToOptimize.forEach((line) => {
+              const geometry = line.geometry;
+              const positionAttr = geometry.attributes.position;
+              const vertexCount = positionAttr.count;
 
-    	computeBounds( geometry, primitiveDef, parser );
+              line.updateWorldMatrix(true, false);
+              const matrix = line.matrixWorld;
+              const vector = new Vector3();
 
-    	return Promise.all( pending ).then( function () {
+              for (let i = 0; i < vertexCount; i++) {
+                vector.fromBufferAttribute(positionAttr, i);
+                vector.applyMatrix4(matrix);
+                positions[posOffset++] = vector.x;
+                positions[posOffset++] = vector.y;
+                positions[posOffset++] = vector.z;
+              }
 
-    		return primitiveDef.targets !== undefined
-    			? addMorphTargets( geometry, primitiveDef.targets, parser )
-    			: geometry;
+              for (let i = 0; i < vertexCount - 1; i++) {
+                indices.push(vertexOffset + i, vertexOffset + i + 1);
+              }
 
-    	} );
+              vertexOffset += vertexCount;
+            });
 
-    }
+            const geometry = new BufferGeometry();
+            geometry.setAttribute("position", new BufferAttribute(positions, 3));
+            geometry.setIndex(indices);
+            geometry.computeBoundingSphere();
+            geometry.computeBoundingBox();
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // 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.
-    ///////////////////////////////////////////////////////////////////////////////
-    class GLTFLoadingManager extends LoadingManager {
-        constructor(file, params = {}) {
-            super();
-            this.path = "";
-            this.resourcePath = "";
-            this.fileURL = "";
-            this.dataURLs = new Map();
-            this.path = params.path || "";
-            const externalFiles = params.externalFiles || new Map();
-            if (typeof file === "string") {
-                this.fileURL = file;
-                this.resourcePath = LoaderUtils.extractUrlBase(file);
-            }
-            else {
-                externalFiles.forEach((value, key) => (this.fileURL = value === file ? key : this.fileURL));
-                externalFiles.set(this.fileURL, file);
-            }
-            externalFiles.forEach((value, key) => {
-                let dataURL;
-                if (typeof value === "string")
-                    dataURL = value;
-                else
-                    dataURL = URL.createObjectURL(new Blob([value]));
-                this.dataURLs.set(key, dataURL);
-            });
-            this.setURLModifier((url) => {
-                const key = decodeURI(url)
-                    .replace(this.path, "")
-                    .replace(this.resourcePath, "")
-                    .replace(/^(\.?\/)/, "");
-                const dataURL = this.dataURLs.get(key);
-                return dataURL !== null && dataURL !== undefined ? dataURL : url;
-            });
-        }
-        dispose() {
-            this.dataURLs.forEach(URL.revokeObjectURL);
-        }
+            const mergedLine = new LineSegments(geometry, optimizedObject.material);
+            mergedLine.visible = true;
+            optimizedObject.parent.add(mergedLine);
+            this.newOptimizedObjects.add(mergedLine);
+          }
+        });
+      }
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -66723,93 +69409,82 @@ void main() {
     // By use of this software, its documentation or related materials, you
     // acknowledge and accept the above terms.
     ///////////////////////////////////////////////////////////////////////////////
-    class GLTFFileLoader extends Loader$1 {
+    class GLTFCloudDynamicLoader {
         constructor(viewer) {
-            super();
+            this.requestId = 0;
             this.viewer = viewer;
+            this.scene = new Group$1();
         }
-        isSupport(file, format) {
-            return ((typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) &&
-                /(gltf|glb)$/i.test(format));
-        }
-        async load(file, format, params) {
-            const manager = new GLTFLoadingManager(file, params);
-            const loader = new GLTFLoader(manager);
-            loader.setPath(manager.path);
-            loader.setCrossOrigin(params.crossOrigin || loader.crossOrigin);
-            loader.setWithCredentials(params.withCredentials || loader.withCredentials);
-            const progress = (event) => {
-                const { lengthComputable, loaded, total } = event;
-                const progress = lengthComputable ? loaded / total : 1;
-                this.viewer.emitEvent({ type: "geometryprogress", data: progress, file });
-            };
-            const gltf = await loader.loadAsync(manager.fileURL, progress);
-            if (!this.viewer.scene)
-                return this;
-            this.viewer.scene.add(gltf.scene);
-            this.viewer.models.push(gltf.scene);
-            this.viewer.syncOptions();
-            this.viewer.syncOverlay();
-            this.viewer.update();
-            this.viewer.emitEvent({ type: "databasechunk", data: gltf.scene, file });
-            return this;
-        }
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // 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.
-    ///////////////////////////////////////////////////////////////////////////////
-    class GLTFCloudModelLoader extends Loader$1 {
-        constructor(viewer) {
-            super();
-            this.viewer = viewer;
+        dispose() {
+            if (this.gltfLoader)
+                this.gltfLoader.clear();
         }
-        isSupport(model) {
-            return (typeof model === "object" &&
-                typeof model.database === "string" &&
-                typeof model.downloadResource === "function" &&
-                /.gltf$/i.test(model.database));
+        isSupport(file) {
+            return (typeof file === "object" &&
+                typeof file.database === "string" &&
+                typeof file.downloadResource === "function" &&
+                typeof file.downloadResourceRange === "function" &&
+                /.gltf$/i.test(file.database));
         }
-        async load(model) {
-            const url = `${model.httpClient.serverUrl}${model.path}/${model.database}`;
-            const manager = new GLTFLoadingManager(url);
-            const loader = new GLTFLoader(manager);
-            loader.setRequestHeader(model.httpClient.headers);
-            const progress = (event) => {
-                const { lengthComputable, loaded, total } = event;
-                const progress = lengthComputable ? loaded / total : 1;
+        async load(model, format, params) {
+            this.gltfLoader = new DynamicGltfLoader(this.viewer.camera, this.viewer.scene, this.viewer.renderer);
+            this.gltfLoader.memoryLimit = this.viewer.options.memoryLimit;
+            this.gltfLoader.addEventListener("databasechunk", (data) => {
+                const modelImpl = new DynamicModelImpl(this.scene);
+                modelImpl.loader = this;
+                modelImpl.gltfLoader = this.gltfLoader;
+                modelImpl.viewer = this.viewer;
+                this.viewer.scene.add(this.scene);
+                this.viewer.models.push(modelImpl);
+                this.viewer.syncOptions();
+                this.viewer.syncOverlay();
+                this.viewer.update();
+                this.viewer.emitEvent({ type: "databasechunk", data, file: model.file, model });
+            });
+            this.gltfLoader.addEventListener("geometryprogress", (data) => {
+                const progress = data.loaded / data.total;
                 this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model.file, model });
+            });
+            this.gltfLoader.addEventListener("geometrymemory", (data) => {
+                this.viewer.emit({ type: "geometryprogress", data });
+            });
+            this.gltfLoader.addEventListener("geometryerror", (data) => {
+                this.viewer.emitEvent({ type: "geometryerror", data, file: model.file, model });
+            });
+            this.gltfLoader.addEventListener("update", (data) => {
+                this.viewer.update();
+            });
+            const loadController = {
+                loadJson: async () => {
+                    const progress = (progress) => {
+                        this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model });
+                    };
+                    const arrayBuffer = await model.downloadResource(model.database, progress, this.gltfLoader.getAbortController().signal);
+                    const text = new TextDecoder().decode(arrayBuffer);
+                    const json = JSON.parse(text);
+                    return json;
+                },
+                loadBinaryData: (requests) => {
+                    const ranges = requests.map((request) => ({
+                        begin: request.offset,
+                        end: request.offset + request.length - 1,
+                        requestId: this.requestId++,
+                    }));
+                    return model.downloadResourceRange(model.geometry[0], undefined, ranges, undefined, this.gltfLoader.getAbortController().signal);
+                },
+                baseUrl: () => Promise.resolve(`${model.httpClient.serverUrl}${model.path}/`),
             };
-            const gltf = await loader.loadAsync(url, progress);
-            if (!this.viewer.scene)
-                return this;
-            this.viewer.scene.add(gltf.scene);
-            this.viewer.models.push(gltf.scene);
-            this.viewer.syncOptions();
-            this.viewer.syncOverlay();
-            this.viewer.update();
-            this.viewer.emitEvent({ type: "databasechunk", data: gltf.scene, file: model.file, model });
+            const structure = new GltfStructure(1);
+            await structure.initialize(loadController);
+            await this.gltfLoader.loadStructure(structure);
+            await this.gltfLoader.loadNodes();
             return this;
         }
+        cancel() {
+            if (this.gltfLoader) {
+                this.gltfLoader.abortLoading();
+            }
+        }
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -66902,7 +69577,7 @@ void main() {
     const loaders = loadersRegistry("threejs");
     // build-in loaders
     loaders.registerLoader("gltf-file", (viewer) => new GLTFFileLoader(viewer));
-    loaders.registerLoader("gltf-cloud-model", (viewer) => new GLTFCloudModelLoader(viewer));
+    loaders.registerLoader("gltf-cloud", (viewer) => new GLTFCloudDynamicLoader(viewer));
 
     class EventEmitter2 {
         constructor() {
@@ -81357,8 +84032,8 @@ void main() {
             this.client = client;
             this.canvasEvents = CANVAS_EVENTS;
             this.canvaseventlistener = (event) => this.emit(event);
-            this.models = [];
             this.loaders = [];
+            this.models = [];
             this.selected = [];
             this.extents = new Box3();
             this.target = new Vector3();
@@ -81390,14 +84065,22 @@ void main() {
             this.addEventListener("optionschange", (event) => this.syncOptions(event.data));
             this.scene = new Scene();
             this.helpers = new Scene();
+            const pixelRatio = window.devicePixelRatio;
             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.01, 1000);
             this.camera.up.set(0, 0, 1);
-            this.renderer = new WebGLRenderer({ canvas, antialias: true, preserveDrawingBuffer: true });
-            this.renderer.setPixelRatio(window.devicePixelRatio);
+            this.renderer = new WebGLRenderer({
+                canvas,
+                antialias: true,
+                alpha: true,
+                preserveDrawingBuffer: true,
+                powerPreference: "high-performance",
+                logarithmicDepthBuffer: false,
+            });
+            this.renderer.setPixelRatio(pixelRatio);
             this.renderer.setSize(width, height);
             this.renderer.toneMapping = LinearToneMapping;
             this.canvas = canvas;
@@ -81440,6 +84123,12 @@ void main() {
         isInitialized() {
             return !!this.renderer;
         }
+        update(force = false) {
+            this.renderNeeded = true;
+            if (force)
+                this.render(performance.now());
+            this.emitEvent({ type: "update", data: force });
+        }
         render(time) {
             var _a, _b;
             if (!this.renderNeeded)
@@ -81460,15 +84149,6 @@ void main() {
             this.renderTime = time;
             this.emitEvent({ type: "render", time, deltaTime });
         }
-        update(force = false) {
-            this.renderNeeded = true;
-            if (force)
-                this.render(performance.now());
-            this.emitEvent({ type: "update", data: force });
-        }
-        syncOptions(options = this.options) {
-            // this.update();
-        }
         loadReferences(model) {
             // todo: load reference as text fonts
             return Promise.resolve(this);
@@ -81601,34 +84281,25 @@ void main() {
         clear() {
             if (!this.renderer)
                 return this;
-            function disposeMaterial(material) {
-                const materials = Array.isArray(material) ? material : [material];
-                materials.forEach((material) => material.dispose());
-            }
-            function disposeObject(object) {
-                if (object.geometry)
-                    object.geometry.dispose();
-                if (object.material)
-                    disposeMaterial(object.material);
-            }
             this.setActiveDragger();
             this.clearSlices();
             this.clearOverlay();
             this.clearSelected();
-            this.helpers.traverse(disposeObject);
-            this.helpers.clear();
-            this.models.forEach((model) => model.traverse(disposeObject));
-            this.models.forEach((model) => model.removeFromParent());
-            this.models = [];
-            this.scene.clear();
             this.loaders.forEach((loader) => loader.dispose());
             this.loaders = [];
+            this.models.forEach((model) => model.dispose());
+            this.models = [];
+            this.helpers.clear();
+            this.scene.clear();
             this.syncOptions();
             this.syncOverlay();
             this.update(true);
             this.emitEvent({ type: "clear" });
             return this;
         }
+        syncOptions(options = this.options) {
+            // this.update();
+        }
         syncOverlay() {
             if (!this.renderer)
                 return;
@@ -81898,6 +84569,7 @@ void main() {
     exports.GLTFLoadingManager = GLTFLoadingManager;
     exports.Loader = Loader$1;
     exports.Markup = KonvaMarkup;
+    exports.ModelImpl = ModelImpl;
     exports.Options = Options;
     exports.Viewer = Viewer;
     exports.commands = commands;