@inweb/viewer-three 26.6.6 → 26.7.0

package/dist/viewer-three.module.js

@@ -2,7 +2,7 @@ import { draggersRegistry, commandsRegistry, componentsRegistry, Loader, loaders
 
 export * from "@inweb/viewer-core";
 
-import { Line, Vector3, BufferGeometry, Float32BufferAttribute, LineBasicMaterial, Mesh, MeshBasicMaterial, DoubleSide, EventDispatcher, MOUSE, TOUCH, Spherical, Quaternion, Vector2, Plane, Object3D, Matrix4, Vector4, Raycaster, Controls, Clock, Box3, Sphere, MathUtils, Color, AmbientLight, DirectionalLight, HemisphereLight, EdgesGeometry, OrthographicCamera, CylinderGeometry, Sprite, CanvasTexture, SRGBColorSpace, SpriteMaterial, LoadingManager, LoaderUtils, Scene, PerspectiveCamera, WebGLRenderer, LinearToneMapping } from "three";
+import { Line, Vector3, BufferGeometry, Float32BufferAttribute, LineBasicMaterial, Mesh, MeshBasicMaterial, DoubleSide, EventDispatcher, MOUSE, TOUCH, Spherical, Quaternion, Vector2, Plane, Object3D, Matrix4, Vector4, Raycaster, Controls, Clock, Sphere, MathUtils, Box3, Color, AmbientLight, DirectionalLight, HemisphereLight, WebGLRenderTarget, UnsignedByteType, RGBAFormat, EdgesGeometry, OrthographicCamera, CylinderGeometry, Sprite, CanvasTexture, SRGBColorSpace, SpriteMaterial, LoadingManager, LoaderUtils, TextureLoader, BufferAttribute, MeshStandardMaterial, FrontSide, PointsMaterial, Material, Points, TriangleStripDrawMode, TriangleFanDrawMode, LineSegments, LineLoop, Group, NormalBlending, PerspectiveCamera, Scene, WebGLRenderer, LinearToneMapping } from "three";
 
 import { TransformControls } from "three/examples/jsm/controls/TransformControls.js";
 
@@ -843,7 +843,7 @@ class CuttingPlaneDragger extends OrbitDragger {
         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();
         };
@@ -871,12 +871,16 @@ class CuttingPlaneDragger extends OrbitDragger {
         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);
@@ -965,6 +969,7 @@ class MeasureLineDragger extends OrbitDragger {
         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() {
@@ -976,6 +981,7 @@ class MeasureLineDragger extends OrbitDragger {
         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();
@@ -1492,7 +1498,6 @@ function clearMarkup(viewer) {
 
 function clearSelected(viewer) {
     const selection = viewer.getComponent("SelectionComponent");
-    if (!selection) return;
     selection.clearSelection();
     viewer.update();
     viewer.emitEvent({
@@ -1511,43 +1516,8 @@ function createPreview(viewer, type = "image/jpeg", encoderOptions = .25) {
     return viewer.canvas.toDataURL(type, encoderOptions);
 }
 
-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",
@@ -1629,107 +1599,19 @@ function getDefaultViewPositions() {
 }
 
 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));
 }
 
 function getSelected(viewer) {
-    return viewer.selected.map((object => {
-        var _a;
-        return (_a = object.userData) === null || _a === undefined ? undefined : _a.handle;
-    })).filter((handle => handle));
-}
-
-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: .25
-            },
-            Line2: {
-                threshold: .25
-            },
-            LOD: {},
-            Points: {
-                threshold: .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;
 }
 
 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"
@@ -1742,12 +1624,7 @@ function hideSelected(viewer) {
 }
 
 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"
@@ -1776,7 +1653,10 @@ function resetView(viewer) {
 }
 
 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: []
@@ -1792,17 +1672,16 @@ function setMarkupColor(viewer, r = 255, g = 0, b = 0) {
 }
 
 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,
@@ -1811,7 +1690,7 @@ function setSelected(viewer, handles = []) {
 }
 
 function showAll(viewer) {
-    viewer.scene.traverse((object => object.visible = true));
+    viewer.models.forEach((model => model.showAllObjects()));
     viewer.update();
     viewer.emitEvent({
         type: "showall"
@@ -1938,6 +1817,7 @@ class BackgroundComponent {
     constructor(viewer) {
         this.syncOptions = () => {
             this.backgroundColor.setHex(16777215);
+            this.viewer.renderer.setClearColor(this.backgroundColor);
         };
         this.viewer = viewer;
         this.backgroundColor = new Color(16777215);
@@ -1998,23 +1878,25 @@ class ExtentsComponent {
     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);
     }
 }
@@ -2209,6 +2091,16 @@ class HighlighterComponent {
             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);
@@ -2219,46 +2111,174 @@ class HighlighterComponent {
         this.viewer.removeEventListener("optionschange", this.optionsChange);
         this.viewer.removeEventListener("resize", this.viewerResize);
     }
-    highlight(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(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;
+    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) {
-        if (!this.outlineMaterial) return;
-        this.outlineMaterial.resolution.set(event.width, event.height);
+        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);
+    }
+}
+
+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: 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: .25
+            },
+            Line2: {
+                threshold: .25
+            },
+            LOD: {},
+            Points: {
+                threshold: .1
+            },
+            Sprite: {}
+        };
+        return this.raycaster.intersectObjects(objects, false);
+    }
+    select(objects, model) {
+        if (!model) {
+            this.viewer.models.forEach((model => this.select(objects, model)));
+            return;
+        }
+        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));
+    }
+    toggleSelection(objects, model) {
+        if (!Array.isArray(objects)) objects = [ objects ];
+        if (!objects.length) return;
+        if (objects[0].isSelected) this.deselect(objects, model); else this.select(objects, model);
+    }
+    clearSelection() {
+        if (!this.viewer.selected.length) return;
+        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;
     }
 }
 
@@ -2419,6 +2439,132 @@ class GLTFLoadingManager extends LoadingManager {
     }
 }
 
+class ModelImpl {
+    constructor(scene) {
+        this.handle = "1";
+        this.scene = scene;
+    }
+    dispose() {
+        function disposeMaterial(material) {
+            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;
+    }
+}
+
 class GLTFFileLoader extends Loader {
     constructor(viewer) {
         super();
@@ -2444,8 +2590,11 @@ class GLTFFileLoader extends Loader {
         };
         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);
+        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();
@@ -2458,61 +2607,1980 @@ class GLTFFileLoader extends Loader {
     }
 }
 
-class GLTFCloudModelLoader extends Loader {
-    constructor(viewer) {
-        super();
-        this.viewer = viewer;
+class DynamicModelImpl extends ModelImpl {
+    getExtents(target) {
+        return target.union(this.gltfLoader.getTotalGeometryExtent());
     }
-    isSupport(model) {
-        return typeof model === "object" && typeof model.database === "string" && typeof model.downloadResource === "function" && /.gltf$/i.test(model.database);
+    getObjects() {
+        const objects = [];
+        this.gltfLoader.originalObjects.forEach((object => {
+            objects.push(object);
+        }));
+        return objects;
     }
-    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: lengthComputable, loaded: loaded, total: total} = event;
-            const progress = lengthComputable ? loaded / total : 1;
-            this.viewer.emitEvent({
-                type: "geometryprogress",
-                data: progress,
-                file: model.file,
-                model: model
-            });
-        };
-        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: model
-        });
+    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;
     }
-}
-
-const loaders = loadersRegistry("threejs");
-
-loaders.registerLoader("gltf-file", (viewer => new GLTFFileLoader(viewer)));
-
-loaders.registerLoader("gltf-cloud-model", (viewer => new GLTFCloudModelLoader(viewer)));
-
-class Viewer extends EventEmitter2 {
+    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 = "";
+        this.loadController = null;
+        this.batchDelay = 10;
+        this.maxBatchSize = 5 * 1024 * 1024;
+        this.maxRangesPerRequest = 512;
+        this.pendingRequests = [];
+        this.batchTimeout = null;
+        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;
+        }
+        this.disposeMaterials();
+        this.textureCache.clear();
+        this.materials.clear();
+    }
+    getJson() {
+        return this.json;
+    }
+    scheduleRequest(request) {
+        this.pendingRequests.push(request);
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+        }
+        this.batchTimeout = setTimeout((() => this.processBatch()), this.batchDelay);
+        return new Promise(((resolve, reject) => {
+            request.resolve = resolve;
+            request.reject = reject;
+        }));
+    }
+    async processBatch() {
+        if (this.pendingRequests.length === 0) return;
+        const currentBatch = [ ...this.pendingRequests ];
+        this.pendingRequests = [];
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
+        try {
+            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: componentType
+        });
+    }
+    createTypedArray(buffer, offset, length, componentType) {
+        try {
+            if (!buffer || !(buffer instanceof ArrayBuffer)) {
+                throw new Error("Invalid buffer");
+            }
+            let elementSize;
+            switch (componentType) {
+              case 5120:
+              case 5121:
+                elementSize = 1;
+                break;
+
+              case 5122:
+              case 5123:
+                elementSize = 2;
+                break;
+
+              case 5125:
+              case 5126:
+                elementSize = 4;
+                break;
+
+              default:
+                throw new Error(`Unsupported component type: ${componentType}`);
+            }
+            const numElements = length / elementSize;
+            if (!Number.isInteger(numElements)) {
+                throw new Error(`Invalid length ${length} for component type ${componentType}`);
+            }
+            if (length > buffer.byteLength) {
+                throw new Error(`Buffer too small: need ${length} bytes, but buffer is ${buffer.byteLength} bytes`);
+            }
+            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: offset,
+                    length: length,
+                    componentType: componentType,
+                    error: 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: error,
+                    accessor: accessor,
+                    bufferView: bufferView
+                });
+            }
+            throw error;
+        }
+    }
+    getComponentSize(componentType) {
+        switch (componentType) {
+          case 5120:
+          case 5121:
+            return 1;
+
+          case 5122:
+          case 5123:
+            return 2;
+
+          case 5125:
+          case 5126:
+            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) {
+                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) {
+                const bufferView = this.json.bufferViews[image.bufferView];
+                const array = await this.getBufferView(bufferView.byteOffset || 0, bufferView.byteLength, 5121);
+                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;
+                return texture;
+            }
+        };
+        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;
+        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);
+            }
+            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;
+            }
+        }
+        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);
+            }
+        }
+        if (materialDef.emissiveFactor) {
+            material.emissive.fromArray(materialDef.emissiveFactor);
+        }
+        if (materialDef.emissiveTexture) {
+            material.emissiveMap = this.textureCache.get(materialDef.emissiveTexture.index);
+        }
+        if (materialDef.occlusionTexture) {
+            material.aoMap = this.textureCache.get(materialDef.occlusionTexture.index);
+            if (materialDef.occlusionTexture.strength !== undefined) {
+                material.aoMapIntensity = materialDef.occlusionTexture.strength;
+            }
+        }
+        if (materialDef.alphaMode === "BLEND") {
+            material.transparent = true;
+        } else if (materialDef.alphaMode === "MASK") {
+            material.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : .5;
+        }
+        material.side = materialDef.doubleSided ? DoubleSide : FrontSide;
+        material.name = materialDef.name;
+        return material;
+    }
+    disposeMaterials() {
+        this.textureCache.forEach((texture => texture.dispose()));
+        this.textureCache.clear();
+        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;
+        for (const primitive of meshDef.primitives) {
+            if (primitive.attributes) {
+                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;
+                }
+            }
+            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;
+    }
+}
+
+function mergeGeometries(geometries, useGroups = false) {
+    const isIndexed = geometries[0].index !== null;
+    const attributesUsed = new Set(Object.keys(geometries[0].attributes));
+    const morphAttributesUsed = new Set(Object.keys(geometries[0].morphAttributes));
+    const attributes = {};
+    const morphAttributes = {};
+    const morphTargetsRelative = geometries[0].morphTargetsRelative;
+    const mergedGeometry = new BufferGeometry;
+    let offset = 0;
+    for (let i = 0; i < geometries.length; ++i) {
+        const geometry = geometries[i];
+        let attributesCount = 0;
+        if (isIndexed !== (geometry.index !== null)) {
+            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;
+        }
+        for (const name in geometry.attributes) {
+            if (!attributesUsed.has(name)) {
+                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]);
+            attributesCount++;
+        }
+        if (attributesCount !== attributesUsed.size) {
+            console.error("THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index " + i + ". Make sure all geometries have the same number of attributes.");
+            return null;
+        }
+        if (morphTargetsRelative !== geometry.morphTargetsRelative) {
+            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;
+        }
+    }
+    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);
+    }
+    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);
+    }
+    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;
+}
+
+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;
+}
+
+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 = 1e3;
+        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 = 1e4;
+        this.frameDelay = 0;
+        this.graphicsObjectLimit = 1e4;
+        this.totalLoadedObjects = 0;
+        this.lastUpdateTime = 0;
+        this.updateInterval = 1e3;
+        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) {}
+    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: object,
+                    size: 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;
+                    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(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;
+            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;
+            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: structure,
+                extras: nodeDef.extras,
+                geometryExtents: geometryExtents,
+                handle: 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: totalNodes
+            });
+            return loadedCount;
+        } catch (error) {
+            this.dispatchEvent("geometryerror", {
+                error: 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(8421504),
+                size: .05,
+                sizeAttenuation: true,
+                alphaTest: .5,
+                transparent: true,
+                vertexColors: false,
+                blending: NormalBlending,
+                depthWrite: false,
+                depthTest: true
+            });
+        } else {
+            return new MeshStandardMaterial({
+                color: 8421504,
+                metalness: 0,
+                roughness: 1,
+                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() {
+        this.structures.forEach((structure => {
+            if (structure) {
+                structure.clear();
+            }
+        }));
+        this.structures = [];
+        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();
+        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();
+        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();
+        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();
+        this.geometryCache.clear();
+        this.materialCache.clear();
+        this.textureCache.clear();
+        this.loadedMaterials.clear();
+        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 = [];
+        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 = 1e5;
+        const INDEX_LIMIT = 1e5;
+        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: 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: 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) {
+                    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 < 1e3) {
+            return;
+        }
+        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;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(attribute.itemSize);
+            gl.vertexAttribPointer(attribute.itemSize, attribute.itemSize, gl.FLOAT, false, 0, 0);
+        }
+        if (geometry.index) {
+            const indexBuffer = this.renderer.properties.get(geometry.index).buffer;
+            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+        }
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+        geometry.vao = vao;
+    }
+    getOriginalObjectForSelect() {
+        const optimizedOriginals = [];
+        for (const obj of this.originalObjectsToSelection) {
+            if (this.hiddenHandles.has(obj.userData.handle)) {
+                continue;
+            }
+            optimizedOriginals.push(obj);
+        }
+        return optimizedOriginals;
+    }
+    isolateObjects(handles) {
+        if (this.hiddenHandles.size !== 0) {
+            this.hiddenHandles.clear();
+            this.syncHiddenObjects();
+        }
+        for (const handle of this.handleToOptimizedObjects.keys()) {
+            if (!handles.has(handle)) {
+                this.hiddenHandles.add(handle);
+            }
+        }
+        this.syncHiddenObjects();
+    }
+    showAllHiddenObjects() {
+        this.hiddenHandles.clear();
+        this.syncHiddenObjects();
+    }
+    hideObjects(handles) {
+        handles.forEach((handle => {
+            this.hiddenHandles.add(handle);
+        }));
+        this.syncHiddenObjects();
+    }
+    showObjects(handles) {
+        handles.forEach((handle => {
+            this.hiddenHandles.delete(handle);
+        }));
+        this.syncHiddenObjects();
+    }
+    syncHiddenObjects() {
+        if (this.oldOptimizeObjects.size !== 0) {
+            for (const obj of this.oldOptimizeObjects) {
+                obj.visible = true;
+            }
+            this.oldOptimizeObjects.clear();
+        }
+        if (this.newOptimizedObjects.size !== 0) {
+            for (const obj of this.newOptimizedObjects) {
+                obj.visible = false;
+                obj.geometry.dispose();
+                obj.parent.remove(obj);
+            }
+            this.newOptimizedObjects.clear();
+        }
+        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)));
+            }
+        }));
+        this.oldOptimizeObjects.forEach((optimizedObject => {
+            optimizedObject.visible = false;
+            const originObjects = this.optimizedOriginalMap.get(optimizedObject);
+            const updateListToOptimize = [];
+            originObjects.forEach((obj => {
+                if (!this.hiddenHandles.has(obj.userData.handle)) {
+                    updateListToOptimize.push(obj);
+                }
+            }));
+            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;
+                }));
+                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);
+                geometries.forEach((geometry => {
+                    geometry.dispose();
+                }));
+            } else if (firstObject instanceof Line) {
+                let totalVertices = 0;
+                updateListToOptimize.map((line => {
+                    totalVertices += line.geometry.attributes.position.count;
+                }));
+                const positions = new Float32Array(totalVertices * 3);
+                let posOffset = 0;
+                const indices = [];
+                let vertexOffset = 0;
+                updateListToOptimize.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, optimizedObject.material);
+                mergedLine.visible = true;
+                optimizedObject.parent.add(mergedLine);
+                this.newOptimizedObjects.add(mergedLine);
+            }
+        }));
+    }
+}
+
+class GLTFCloudDynamicLoader {
+    constructor(viewer) {
+        this.requestId = 0;
+        this.viewer = viewer;
+        this.scene = new Group;
+    }
+    dispose() {
+        if (this.gltfLoader) this.gltfLoader.clear();
+    }
+    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, 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: data,
+                file: model.file,
+                model: model
+            });
+        }));
+        this.gltfLoader.addEventListener("geometryprogress", (data => {
+            const progress = data.loaded / data.total;
+            this.viewer.emitEvent({
+                type: "geometryprogress",
+                data: progress,
+                file: model.file,
+                model: model
+            });
+        }));
+        this.gltfLoader.addEventListener("geometrymemory", (data => {
+            this.viewer.emit({
+                type: "geometryprogress",
+                data: data
+            });
+        }));
+        this.gltfLoader.addEventListener("geometryerror", (data => {
+            this.viewer.emitEvent({
+                type: "geometryerror",
+                data: data,
+                file: model.file,
+                model: 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 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();
+        }
+    }
+}
+
+const loaders = loadersRegistry("threejs");
+
+loaders.registerLoader("gltf-file", (viewer => new GLTFFileLoader(viewer)));
+
+loaders.registerLoader("gltf-cloud", (viewer => new GLTFCloudDynamicLoader(viewer)));
+
+class Viewer extends EventEmitter2 {
     constructor(client) {
         super();
         this._options = new Options(this);
         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;
@@ -2539,6 +4607,7 @@ class Viewer extends EventEmitter2 {
         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;
@@ -2548,9 +4617,12 @@ class Viewer extends EventEmitter2 {
         this.renderer = new WebGLRenderer({
             canvas: canvas,
             antialias: true,
-            preserveDrawingBuffer: true
+            alpha: true,
+            preserveDrawingBuffer: true,
+            powerPreference: "high-performance",
+            logarithmicDepthBuffer: false
         });
-        this.renderer.setPixelRatio(window.devicePixelRatio);
+        this.renderer.setPixelRatio(pixelRatio);
         this.renderer.setSize(width, height);
         this.renderer.toneMapping = LinearToneMapping;
         this.canvas = canvas;
@@ -2604,6 +4676,14 @@ class Viewer extends EventEmitter2 {
     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) return;
@@ -2626,15 +4706,6 @@ class Viewer extends EventEmitter2 {
             deltaTime: deltaTime
         });
     }
-    update(force = false) {
-        this.renderNeeded = true;
-        if (force) this.render(performance.now());
-        this.emitEvent({
-            type: "update",
-            data: force
-        });
-    }
-    syncOptions(options = this.options) {}
     loadReferences(model) {
         return Promise.resolve(this);
     }
@@ -2709,26 +4780,16 @@ class Viewer extends EventEmitter2 {
     }
     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);
@@ -2737,6 +4798,7 @@ class Viewer extends EventEmitter2 {
         });
         return this;
     }
+    syncOptions(options = this.options) {}
     syncOverlay() {
         if (!this.renderer) return;
         this._markup.syncOverlay();
@@ -2991,5 +5053,5 @@ class Viewer extends EventEmitter2 {
     }
 }
 
-export { GLTFLoadingManager, Viewer, commands, components, draggers, loaders };
+export { GLTFLoadingManager, ModelImpl, Viewer, commands, components, draggers, loaders };
 //# sourceMappingURL=viewer-three.module.js.map