@inweb/viewer-three 26.9.6 → 26.9.8

package/dist/viewer-three.js

@@ -3509,11 +3509,11 @@
     		if ( this.isEmpty() ) {
     			return false;
     		}
-    		this.getCenter( _center );
-    		_extents.subVectors( this.max, _center );
-    		_v0$2.subVectors( triangle.a, _center );
-    		_v1$7.subVectors( triangle.b, _center );
-    		_v2$4.subVectors( triangle.c, _center );
+    		this.getCenter( _center$1 );
+    		_extents.subVectors( this.max, _center$1 );
+    		_v0$2.subVectors( triangle.a, _center$1 );
+    		_v1$7.subVectors( triangle.b, _center$1 );
+    		_v2$4.subVectors( triangle.c, _center$1 );
     		_f0.subVectors( _v1$7, _v0$2 );
     		_f1.subVectors( _v2$4, _v1$7 );
     		_f2.subVectors( _v0$2, _v2$4 );
@@ -3610,7 +3610,7 @@
     const _f0 =  new Vector3();
     const _f1 =  new Vector3();
     const _f2 =  new Vector3();
-    const _center =  new Vector3();
+    const _center$1 =  new Vector3();
     const _extents =  new Vector3();
     const _triangleNormal =  new Vector3();
     const _testAxis =  new Vector3();
@@ -8899,7 +8899,7 @@
     const _skinWeight =  new Vector4();
     const _vector3 =  new Vector3();
     const _matrix4 =  new Matrix4();
-    const _vertex =  new Vector3();
+    const _vertex$1 =  new Vector3();
     const _sphere$5 =  new Sphere();
     const _inverseMatrix$2 =  new Matrix4();
     const _ray$2 =  new Ray();
@@ -8922,8 +8922,8 @@
     		this.boundingBox.makeEmpty();
     		const positionAttribute = geometry.getAttribute( 'position' );
     		for ( let i = 0; i < positionAttribute.count; i ++ ) {
-    			this.getVertexPosition( i, _vertex );
-    			this.boundingBox.expandByPoint( _vertex );
+    			this.getVertexPosition( i, _vertex$1 );
+    			this.boundingBox.expandByPoint( _vertex$1 );
     		}
     	}
     	computeBoundingSphere() {
@@ -8934,8 +8934,8 @@
     		this.boundingSphere.makeEmpty();
     		const positionAttribute = geometry.getAttribute( 'position' );
     		for ( let i = 0; i < positionAttribute.count; i ++ ) {
-    			this.getVertexPosition( i, _vertex );
-    			this.boundingSphere.expandByPoint( _vertex );
+    			this.getVertexPosition( i, _vertex$1 );
+    			this.boundingSphere.expandByPoint( _vertex$1 );
     		}
     	}
     	copy( source, recursive ) {
@@ -10588,8 +10588,8 @@
     		object: object
     	};
     }
-    const _start$1 =  new Vector3();
-    const _end$1 =  new Vector3();
+    const _start$2 =  new Vector3();
+    const _end$2 =  new Vector3();
     class LineSegments extends Line$1 {
     	constructor( geometry, material ) {
     		super( geometry, material );
@@ -10602,10 +10602,10 @@
     			const positionAttribute = geometry.attributes.position;
     			const lineDistances = [];
     			for ( let i = 0, l = positionAttribute.count; i < l; i += 2 ) {
-    				_start$1.fromBufferAttribute( positionAttribute, i );
-    				_end$1.fromBufferAttribute( positionAttribute, i + 1 );
+    				_start$2.fromBufferAttribute( positionAttribute, i );
+    				_end$2.fromBufferAttribute( positionAttribute, i + 1 );
     				lineDistances[ i ] = ( i === 0 ) ? 0 : lineDistances[ i - 1 ];
-    				lineDistances[ i + 1 ] = lineDistances[ i ] + _start$1.distanceTo( _end$1 );
+    				lineDistances[ i + 1 ] = lineDistances[ i ] + _start$2.distanceTo( _end$2 );
     			}
     			geometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );
     		} else {
@@ -33831,6 +33831,8 @@ void main() {
     }
 
     const PRECISION = 0.01;
+    const DESKTOP_SNAP_DISTANCE = 10;
+    const MOBILE_SNAP_DISTANCE = 50;
     class MeasureLineDragger extends OrbitDragger {
         constructor(viewer) {
             super(viewer);
@@ -33845,7 +33847,10 @@ void main() {
             this.onPointerMove = (event) => {
                 if (this.orbit.enabled && this.orbit.state !== -1)
                     return;
-                this.line.endPoint = this.snapper.getSnapPoint(event);
+                const snapPoint = this.snapper.getSnapPoint(event);
+                if (snapPoint && this.line.endPoint && snapPoint.equals(this.line.endPoint))
+                    return;
+                this.line.endPoint = snapPoint;
                 this.line.render();
                 if (this.line.startPoint)
                     this.changed = true;
@@ -33874,14 +33879,14 @@ void main() {
                 this.overlay.render();
             };
             this.updateSnapper = () => {
-                this.snapper.update(this.viewer.scene);
+                this.snapper.update(this.viewer);
             };
             this.overlay = new MeasureOverlay(viewer.camera, viewer.canvas);
             this.overlay.attach();
             this.line = new MeasureLine(this.overlay);
             this.overlay.addLine(this.line);
             this.snapper = new MeasureSnapper(viewer.camera, viewer.canvas);
-            this.snapper.update(viewer.scene);
+            this.updateSnapper();
             this.viewer.canvas.addEventListener("pointerdown", this.onPointerDown);
             this.viewer.canvas.addEventListener("pointermove", this.onPointerMove);
             this.viewer.canvas.addEventListener("pointerup", this.onPointerUp);
@@ -33904,20 +33909,39 @@ void main() {
             this.viewer.removeEventListener("isolate", this.updateSnapper);
             this.viewer.removeEventListener("show", this.updateSnapper);
             this.viewer.removeEventListener("showall", this.updateSnapper);
+            this.snapper.dispose();
             this.overlay.detach();
             this.overlay.dispose();
             super.dispose();
         }
     }
+    const _vertex = new Vector3();
+    const _start$1 = new Vector3();
+    const _end$1 = new Vector3();
+    const _line = new Line3();
+    const _center = new Vector3();
+    const _projection = new Vector3();
     class MeasureSnapper {
         constructor(camera, canvas) {
-            this.objects = [];
             this.camera = camera;
             this.canvas = canvas;
+            this.objects = [];
             this.raycaster = new Raycaster();
+            this.detectRadiusInPixels = this.isMobile() ? MOBILE_SNAP_DISTANCE : DESKTOP_SNAP_DISTANCE;
+            this.edgesCache = new WeakMap();
         }
-        getSnapPoint(event) {
-            const mouse = new Vector2(event.clientX, event.clientY);
+        dispose() {
+            this.objects = [];
+        }
+        isMobile() {
+            if (typeof navigator === "undefined")
+                return false;
+            return /Android|webOS|iPhone|iPad|iPod|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(navigator.userAgent);
+        }
+        getMousePosition(event, target) {
+            return target.set(event.clientX, event.clientY);
+        }
+        getPointerIntersects(mouse, objects) {
             const rect = this.canvas.getBoundingClientRect();
             const x = ((mouse.x - rect.left) / rect.width) * 2 - 1;
             const y = (-(mouse.y - rect.top) / rect.height) * 2 + 1;
@@ -33925,20 +33949,86 @@ void main() {
             this.raycaster.setFromCamera(coords, this.camera);
             this.raycaster.params = {
                 Mesh: {},
-                Line: { threshold: 0.25 },
-                Line2: { threshold: 0.25 },
+                Line: { threshold: 0.05 },
+                Line2: { threshold: 0.05 },
                 LOD: {},
-                Points: { threshold: 0.1 },
+                Points: { threshold: 0.01 },
                 Sprite: {},
             };
-            const intersects = this.raycaster.intersectObjects(this.objects, false);
-            if (intersects.length === 0)
-                return undefined;
-            return intersects[0].point;
+            return this.raycaster.intersectObjects(objects, false);
         }
-        update(scene) {
-            this.objects = [];
-            scene.traverseVisible((child) => this.objects.push(child));
+        getDetectRadius(point) {
+            const camera = this.camera;
+            if (camera.isOrthographicCamera) {
+                const worldHeight = camera.top - camera.bottom;
+                const canvasHeight = this.canvas.height;
+                const worldUnitsPerPixel = worldHeight / canvasHeight;
+                return this.detectRadiusInPixels * worldUnitsPerPixel;
+            }
+            if (camera.isPerspectiveCamera) {
+                const distance = camera.position.distanceTo(point);
+                const worldHeight = 2 * Math.tan(MathUtils.degToRad(camera.fov * 0.5)) * distance;
+                const canvasHeight = this.canvas.height;
+                const worldUnitsPerPixel = worldHeight / canvasHeight;
+                return this.detectRadiusInPixels * worldUnitsPerPixel;
+            }
+            return 0.1;
+        }
+        getSnapPoint(event) {
+            const mouse = this.getMousePosition(event, new Vector2());
+            const intersections = this.getPointerIntersects(mouse, this.objects);
+            if (intersections.length === 0)
+                return undefined;
+            const object = intersections[0].object;
+            const intersectionPoint = intersections[0].point;
+            const localPoint = object.worldToLocal(intersectionPoint.clone());
+            let snapPoint;
+            let snapDistance = this.getDetectRadius(intersectionPoint);
+            const geometry = object.geometry;
+            const positions = geometry.attributes.position.array;
+            for (let i = 0; i < positions.length; i += 3) {
+                _vertex.set(positions[i], positions[i + 1], positions[i + 2]);
+                const distance = _vertex.distanceTo(localPoint);
+                if (distance < snapDistance) {
+                    snapDistance = distance;
+                    snapPoint = _vertex.clone();
+                }
+            }
+            if (snapPoint)
+                return object.localToWorld(snapPoint);
+            let edges = this.edgesCache.get(geometry);
+            if (!edges) {
+                edges = new EdgesGeometry(geometry);
+                this.edgesCache.set(geometry, edges);
+            }
+            const edgePositions = edges.attributes.position.array;
+            for (let i = 0; i < edgePositions.length; i += 6) {
+                _start$1.set(edgePositions[i], edgePositions[i + 1], edgePositions[i + 2]);
+                _end$1.set(edgePositions[i + 3], edgePositions[i + 4], edgePositions[i + 5]);
+                _line.set(_start$1, _end$1);
+                _line.getCenter(_center);
+                const centerDistance = _center.distanceTo(localPoint);
+                if (centerDistance < snapDistance) {
+                    snapDistance = centerDistance;
+                    snapPoint = _center.clone();
+                    continue;
+                }
+                _line.closestPointToPoint(localPoint, true, _projection);
+                const lineDistance = _projection.distanceTo(localPoint);
+                if (lineDistance < snapDistance) {
+                    snapDistance = lineDistance;
+                    snapPoint = _projection.clone();
+                }
+            }
+            if (snapPoint)
+                return object.localToWorld(snapPoint);
+            return intersectionPoint.clone();
+        }
+        update(viewer) {
+            this.objects.length = 0;
+            viewer.models.forEach((model) => {
+                model.getVisibleObjects().forEach((object) => this.objects.push(object));
+            });
         }
     }
     class MeasureOverlay {
@@ -33960,6 +34050,8 @@ void main() {
             this.container.style.outline = "none";
             this.container.style.pointerEvents = "none";
             this.container.style.overflow = "hidden";
+            if (!this.canvas.parentElement)
+                return;
             this.canvas.parentElement.appendChild(this.container);
         }
         dispose() {
@@ -33990,7 +34082,7 @@ void main() {
     const _middlePoint = new Vector3();
     class MeasureLine {
         constructor(overlay) {
-            this.id = Date.now();
+            this.id = MathUtils.generateUUID();
             this.unit = "";
             this.scale = 1.0;
             this.size = 10.0;
@@ -34014,6 +34106,10 @@ void main() {
             this.elementEndPoint.remove();
             this.elementLine.remove();
             this.elementLabel.remove();
+            this.elementStartPoint = undefined;
+            this.elementEndPoint = undefined;
+            this.elementLine = undefined;
+            this.elementLabel = undefined;
         }
         render() {
             const projector = this.overlay.projector;
@@ -34670,7 +34766,7 @@ void main() {
         if (camera.isPerspectiveCamera) {
             const offset = new Vector3(0, 0, 1)
                 .applyQuaternion(camera.quaternion)
-                .multiplyScalar(boxSize / Math.tan(MathUtils.DEG2RAD * camera.fov * 0.5));
+                .multiplyScalar(boxSize / Math.tan(MathUtils.degToRad(camera.fov * 0.5)));
             camera.position.copy(offset).add(boxCenter);
             camera.updateMatrixWorld();
         }
@@ -34756,6 +34852,7 @@ void main() {
     }
 
     function resetView(viewer) {
+        const reset = viewer.getComponent("ResetComponent");
         viewer.executeCommand("setActiveDragger");
         viewer.executeCommand("clearSlices");
         viewer.executeCommand("clearOverlay");
@@ -34764,7 +34861,7 @@ void main() {
         viewer.executeCommand("showAll");
         viewer.executeCommand("explode", 0);
         viewer.executeCommand("zoomToExtents", true);
-        viewer.executeCommand("k3DViewSW");
+        reset.resetCameraPosition();
         viewer.emit({ type: "resetview" });
     }
 
@@ -35970,12 +36067,12 @@ void main() {
             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 = {
+            this.raycaster.params = {
                 Mesh: {},
-                Line: { threshold: 0.25 },
-                Line2: { threshold: 0.25 },
+                Line: { threshold: 0.05 },
+                Line2: { threshold: 0.05 },
                 LOD: {},
-                Points: { threshold: 0.1 },
+                Points: { threshold: 0.01 },
                 Sprite: {},
             };
             return this.raycaster.intersectObjects(objects, false);
@@ -36141,6 +36238,31 @@ void main() {
         }
     }
 
+    class ResetComponent {
+        constructor(viewer) {
+            this.savedCameraPosition = null;
+            this.onDatabaseChunk = () => {
+                this.savedCameraPosition = {
+                    position: this.viewer.camera.position.clone(),
+                    up: this.viewer.camera.up.clone(),
+                    direction: this.viewer.camera.getWorldDirection(new Vector3()),
+                };
+            };
+            this.viewer = viewer;
+            this.viewer.addEventListener("databasechunk", this.onDatabaseChunk);
+        }
+        dispose() {
+            this.viewer.removeEventListener("databasechunk", this.onDatabaseChunk);
+        }
+        resetCameraPosition() {
+            if (this.savedCameraPosition) {
+                this.viewer.camera.position.copy(this.savedCameraPosition.position);
+                this.viewer.camera.up.copy(this.savedCameraPosition.up);
+                this.viewer.camera.lookAt(this.savedCameraPosition.position.clone().add(this.savedCameraPosition.direction));
+            }
+        }
+    }
+
     const components = componentsRegistry("threejs");
     components.registerComponent("ExtentsComponent", (viewer) => new ExtentsComponent(viewer));
     components.registerComponent("CameraComponent", (viewer) => new CameraComponent(viewer));
@@ -36151,6 +36273,7 @@ void main() {
     components.registerComponent("HighlighterComponent", (viewer) => new HighlighterComponent(viewer));
     components.registerComponent("SelectionComponent", (viewer) => new SelectionComponent(viewer));
     components.registerComponent("WCSHelperComponent", (viewer) => new WCSHelperComponent(viewer));
+    components.registerComponent("ResetComponent", (viewer) => new ResetComponent(viewer));
 
     function mergeGeometries( geometries, useGroups = false ) {
     	const isIndexed = geometries[ 0 ].index !== null;
@@ -39507,6 +39630,12 @@ void main() {
         this.maxConcurrentChunks = 8;
         this.activeChunkLoads = 0;
         this.chunkQueue = [];
+        this.objectIdToIndex = new Map();
+        this.maxObjectId = 0;
+        this.objectVisibility = new Float32Array();
+        this.maxConcurrentChunks = 6;
+        this.mergedObjectMap = new Map();
+        this.mergedGeometryVisibility = new Map();
       }
       setVisibleEdges(visible) {
         this.visibleEdges = visible;
@@ -40213,6 +40342,50 @@ void main() {
         this.originalObjects.clear();
         this.originalObjectsToSelection.clear();
       }
+      initializeObjectVisibility() {
+        if (this.maxObjectId > 0) {
+          this.objectVisibility = new Float32Array(this.maxObjectId);
+          for (let i = 0; i < this.maxObjectId; i++) {
+            this.objectVisibility[i] = 1.0;
+          }
+          console.log(`Initialized object visibility array: ${this.maxObjectId} objects`);
+        }
+      }
+      createVisibilityMaterial(material) {
+        material.onBeforeCompile = (shader) => {
+          shader.vertexShader = shader.vertexShader.replace(
+            "#include <common>",
+            `
+        #include <common>
+        attribute float visibility;
+        varying float vVisibility;
+        `
+          );
+          shader.fragmentShader = shader.fragmentShader.replace(
+            "#include <common>",
+            `
+        #include <common>
+        varying float vVisibility;
+        `
+          );
+          shader.vertexShader = shader.vertexShader.replace(
+            "void main() {",
+            `
+        void main() {
+          vVisibility = visibility;
+        `
+          );
+          shader.fragmentShader = shader.fragmentShader.replace(
+            "void main() {",
+            `
+        void main() {
+          if (vVisibility < 0.5) discard;
+        `
+          );
+        };
+        material.needsUpdate = true;
+        return material;
+      }
       clear() {
         this.chunkQueue = [];
         this.structures.forEach((structure) => {
@@ -40318,6 +40491,9 @@ void main() {
         this.loadedGeometrySize = 0;
         this.abortController = new AbortController();
         this.updateMemoryIndicator();
+        this.objectIdToIndex.clear();
+        this.maxObjectId = 0;
+        this.objectVisibility = new Float32Array();
       }
       setStructureTransform(structureId, matrix) {
         const rootGroup = this.structureRoots.get(structureId);
@@ -40467,18 +40643,43 @@ void main() {
             this.originalObjectsToSelection.add(obj);
           }
         });
+        this.initializeObjectVisibility();
+        console.log(`Optimization complete. Total objects: ${this.maxObjectId}`);
         this.dispatchEvent("update");
       }
       mergeMeshGroups(materialGroups, rootGroup) {
         for (const group of materialGroups) {
+          if (!group.material) {
+            console.warn("Skipping mesh group with null material");
+            continue;
+          }
           try {
             const geometries = [];
             const handles = new Set();
             const optimizedObjects = [];
+            const objectMapping = new Map();
+            let currentVertexOffset = 0;
             for (const mesh of group.objects) {
               const geometry = mesh.geometry.clone();
               mesh.updateWorldMatrix(true, false);
               geometry.applyMatrix4(mesh.matrixWorld);
+              const handle = mesh.userData.handle;
+              if (!this.objectIdToIndex.has(handle)) {
+                this.objectIdToIndex.set(handle, this.maxObjectId++);
+              }
+              const objectId = this.objectIdToIndex.get(handle);
+              const vertexCount = geometry.attributes.position.count;
+              const objectIds = new Float32Array(vertexCount);
+              for (let i = 0; i < vertexCount; i++) {
+                objectIds[i] = objectId;
+              }
+              geometry.setAttribute("objectId", new BufferAttribute(objectIds, 1));
+              objectMapping.set(mesh, {
+                geometry,
+                startVertexIndex: currentVertexOffset,
+                vertexCount: geometry.attributes.position.count,
+              });
+              currentVertexOffset += geometry.attributes.position.count;
               geometries.push(geometry);
               optimizedObjects.push(mesh);
               handles.add(mesh.userData.handle);
@@ -40486,13 +40687,26 @@ void main() {
             const mergedObjects = [];
             if (geometries.length > 0) {
               const mergedGeometry = mergeGeometries(geometries);
+              const totalVertices = mergedGeometry.attributes.position.count;
+              const visibilityArray = new Float32Array(totalVertices);
+              for (let i = 0; i < totalVertices; i++) {
+                visibilityArray[i] = 1.0;
+              }
+              mergedGeometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
               if (this.useVAO) {
                 this.createVAO(mergedGeometry);
               }
-              const mergedMesh = new Mesh(mergedGeometry, group.material);
+              const visibilityMaterial = this.createVisibilityMaterial(group.material);
+              const mergedMesh = new Mesh(mergedGeometry, visibilityMaterial);
               rootGroup.add(mergedMesh);
               this.mergedMesh.add(mergedMesh);
               this.optimizedOriginalMap.set(mergedMesh, optimizedObjects);
+              this.mergedObjectMap.set(mergedMesh.uuid, {
+                objectMapping,
+                visibilityArray,
+                totalVertices,
+              });
+              this.mergedGeometryVisibility.set(mergedMesh, visibilityArray);
               mergedObjects.push(mergedMesh);
               geometries.forEach((geometry) => {
                 geometry.dispose();
@@ -40518,8 +40732,14 @@ void main() {
       mergeLineGroups(materialGroups, rootGroup) {
         for (const group of materialGroups) {
           if (group.objects.length === 0) continue;
+          if (!group.material) {
+            console.warn("Skipping line group with null material");
+            continue;
+          }
           const handles = new Set();
           let totalVertices = 0;
+          const objectMapping = new Map();
+          let currentVertexOffset = 0;
           group.objects.map((line) => {
             handles.add(line.userData.handle);
             totalVertices += line.geometry.attributes.position.count;
@@ -40532,6 +40752,15 @@ void main() {
             const geometry = line.geometry;
             const positionAttr = geometry.attributes.position;
             const vertexCount = positionAttr.count;
+            const handle = line.userData.handle;
+            if (!this.objectIdToIndex.has(handle)) {
+              this.objectIdToIndex.set(handle, this.maxObjectId++);
+            }
+            objectMapping.set(line, {
+              startVertexIndex: currentVertexOffset,
+              vertexCount,
+            });
+            currentVertexOffset += vertexCount;
             line.updateWorldMatrix(true, false);
             const matrix = line.matrixWorld;
             const vector = new Vector3();
@@ -40552,7 +40781,24 @@ void main() {
           geometry.setIndex(indices);
           geometry.computeBoundingSphere();
           geometry.computeBoundingBox();
-          const mergedLine = new LineSegments(geometry, group.material);
+          const objectIds = new Float32Array(totalVertices);
+          let vertexIndex = 0;
+          group.objects.forEach((line) => {
+            const vertexCount = line.geometry.attributes.position.count;
+            const handle = line.userData.handle;
+            const objectId = this.objectIdToIndex.get(handle);
+            for (let i = 0; i < vertexCount; i++) {
+              objectIds[vertexIndex++] = objectId;
+            }
+          });
+          geometry.setAttribute("objectId", new BufferAttribute(objectIds, 1));
+          const visibilityArray = new Float32Array(totalVertices);
+          for (let i = 0; i < totalVertices; i++) {
+            visibilityArray[i] = 1.0;
+          }
+          geometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
+          const visibilityMaterial = this.createVisibilityMaterial(group.material);
+          const mergedLine = new LineSegments(geometry, visibilityMaterial);
           const mergedObjects = [mergedLine];
           if (this.useVAO) {
             this.createVAO(mergedLine);
@@ -40560,6 +40806,12 @@ void main() {
           rootGroup.add(mergedLine);
           this.mergedLines.add(mergedLine);
           this.optimizedOriginalMap.set(mergedLine, group.objects);
+          this.mergedObjectMap.set(mergedLine.uuid, {
+            objectMapping,
+            visibilityArray,
+            totalVertices,
+          });
+          this.mergedGeometryVisibility.set(mergedLine, visibilityArray);
           handles.forEach((handle) => {
             if (this.handleToOptimizedObjects.has(handle)) {
               const existingObjects = this.handleToOptimizedObjects.get(handle);
@@ -40573,14 +40825,37 @@ void main() {
       }
       mergeLineSegmentGroups(materialGroups, rootGroup) {
         for (const group of materialGroups) {
+          if (!group.material) {
+            console.warn("Skipping line segment group with null material");
+            continue;
+          }
           try {
             const geometries = [];
             const optimizedObjects = [];
             const handles = new Set();
+            const objectMapping = new Map();
+            let currentVertexOffset = 0;
             for (const line of group.objects) {
               const geometry = line.geometry.clone();
               line.updateWorldMatrix(true, false);
               geometry.applyMatrix4(line.matrixWorld);
+              const handle = line.userData.handle;
+              if (!this.objectIdToIndex.has(handle)) {
+                this.objectIdToIndex.set(handle, this.maxObjectId++);
+              }
+              const objectId = this.objectIdToIndex.get(handle);
+              const vertexCount = geometry.attributes.position.count;
+              const objectIds = new Float32Array(vertexCount);
+              for (let i = 0; i < vertexCount; i++) {
+                objectIds[i] = objectId;
+              }
+              geometry.setAttribute("objectId", new BufferAttribute(objectIds, 1));
+              objectMapping.set(line, {
+                geometry,
+                startVertexIndex: currentVertexOffset,
+                vertexCount: geometry.attributes.position.count,
+              });
+              currentVertexOffset += geometry.attributes.position.count;
               geometries.push(geometry);
               optimizedObjects.push(line);
               handles.add(line.userData.handle);
@@ -40588,13 +40863,26 @@ void main() {
             const mergedObjects = [];
             if (geometries.length > 0) {
               const mergedGeometry = mergeGeometries(geometries, false);
-              const mergedLine = new LineSegments(mergedGeometry, group.material);
+              const totalVertices = mergedGeometry.attributes.position.count;
+              const visibilityArray = new Float32Array(totalVertices);
+              for (let i = 0; i < totalVertices; i++) {
+                visibilityArray[i] = 1.0;
+              }
+              mergedGeometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
+              const visibilityMaterial = this.createVisibilityMaterial(group.material);
+              const mergedLine = new LineSegments(mergedGeometry, visibilityMaterial);
               if (this.useVAO) {
                 this.createVAO(mergedLine);
               }
               rootGroup.add(mergedLine);
               this.mergedLineSegments.add(mergedLine);
               this.optimizedOriginalMap.set(mergedLine, optimizedObjects);
+              this.mergedObjectMap.set(mergedLine.uuid, {
+                objectMapping,
+                visibilityArray,
+                totalVertices,
+              });
+              this.mergedGeometryVisibility.set(mergedLine, visibilityArray);
               mergedObjects.push(mergedLine);
               geometries.forEach((geometry) => {
                 geometry.dispose();
@@ -40619,6 +40907,10 @@ void main() {
       }
       mergePointsGroups(materialGroups, rootGroup) {
         for (const group of materialGroups) {
+          if (!group.material) {
+            console.warn("Skipping points group with null material");
+            continue;
+          }
           try {
             const geometries = [];
             const optimizedObjects = [];
@@ -40801,97 +41093,51 @@ void main() {
         });
         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);
+      _updateVisibilityAttribute(mergedObject) {
+        if (
+          mergedObject.geometry &&
+          mergedObject.geometry.attributes.visibility &&
+          mergedObject.geometry.attributes.objectId
+        ) {
+          const visibilityArray = mergedObject.geometry.attributes.visibility.array;
+          const objectIdArray = mergedObject.geometry.attributes.objectId.array;
+          for (let i = 0; i < visibilityArray.length; i++) {
+            const objectId = objectIdArray[i];
+            if (objectId < this.objectVisibility.length) {
+              visibilityArray[i] = this.objectVisibility[objectId];
+            }
           }
-          this.newOptimizedObjects.clear();
+          mergedObject.geometry.attributes.visibility.needsUpdate = true;
         }
-        if (this.hiddenHandles.size === 0) {
+      }
+      syncHiddenObjects() {
+        if (this.mergedObjectMap.size === 0) {
+          console.log("No merged objects to sync");
           return;
         }
-        this.hiddenHandles.forEach((handle) => {
-          const objects = this.handleToOptimizedObjects.get(handle);
-          if (objects) {
-            objects.forEach((x) => this.oldOptimizeObjects.add(x));
+        if (this.objectVisibility.length > 0) {
+          for (let i = 0; i < this.objectVisibility.length; i++) {
+            this.objectVisibility[i] = 1.0;
           }
-        });
-        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);
+          this.hiddenHandles.forEach((handle) => {
+            const index = this.objectIdToIndex.get(handle);
+            if (index !== undefined && index < this.objectVisibility.length) {
+              this.objectVisibility[index] = 0.0;
             }
           });
-          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$1) {
-            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);
-          }
-        });
+        }
+        for (const mesh of this.mergedMesh) {
+          this._updateVisibilityAttribute(mesh);
+        }
+        for (const line of this.mergedLines) {
+          this._updateVisibilityAttribute(line);
+        }
+        for (const lineSegment of this.mergedLineSegments) {
+          this._updateVisibilityAttribute(lineSegment);
+        }
+        for (const point of this.mergedPoints) {
+          this._updateVisibilityAttribute(point);
+        }
       }
       getStructureGeometryExtent(structureId) {
         const extent = new Box3();