@inweb/viewer-three 27.2.3 → 27.2.4

package/dist/viewer-three.js

@@ -33644,6 +33644,41 @@ void main() {
     	}
     }
 
+    class PlaneHelper2 extends Line$1 {
+        constructor(size = 1, color = 0xc0c0c0) {
+            const positions = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0, 1, 1, 0];
+            const geometry = new BufferGeometry();
+            geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+            geometry.computeBoundingSphere();
+            super(geometry, new LineBasicMaterial({ color, toneMapped: false }));
+            this.type = "PlaneHelper2";
+            this.size = size;
+            const positions2 = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, 1, 0, -1, -1, 0, 1, -1, 0];
+            const geometry2 = new BufferGeometry();
+            geometry2.setAttribute("position", new Float32BufferAttribute(positions2, 3));
+            geometry2.computeBoundingSphere();
+            this.helper = new Mesh(geometry2, new MeshBasicMaterial({
+                color,
+                opacity: 0.2,
+                transparent: true,
+                depthWrite: false,
+                toneMapped: false,
+                side: DoubleSide,
+            }));
+            this.add(this.helper);
+        }
+        dispose() {
+            this.geometry.dispose();
+            this.material.dispose();
+            this.helper.geometry.dispose();
+            this.helper.material.dispose();
+        }
+        updateMatrixWorld(force) {
+            this.scale.set(0.5 * this.size, 0.5 * this.size, 1);
+            super.updateMatrixWorld(force);
+        }
+    }
+
     const _changeEvent = { type: "change" };
     const _startEvent = { type: "start" };
     const _endEvent = { type: "end" };
@@ -34302,166 +34337,6 @@ void main() {
       }
     }
 
-    class PlaneHelper2 extends Object3D {
-        constructor(size = 1, color = 0xf0f0f0, opacity = 0.15) {
-            super();
-            this.type = "PlaneHelper2";
-            this.size = size;
-            const positions = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0, 1, 1, 0];
-            const geometry = new BufferGeometry();
-            geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
-            geometry.computeBoundingSphere();
-            this.outline = new Line$1(geometry, new LineBasicMaterial({ color, toneMapped: false }));
-            const positions2 = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, 1, 0, -1, -1, 0, 1, -1, 0];
-            const geometry2 = new BufferGeometry();
-            geometry2.setAttribute("position", new Float32BufferAttribute(positions2, 3));
-            geometry2.computeBoundingSphere();
-            this.mesh = new Mesh(geometry2, new MeshBasicMaterial({
-                color,
-                opacity,
-                transparent: true,
-                depthWrite: false,
-                toneMapped: false,
-                side: DoubleSide,
-            }));
-            this.add(this.outline);
-            this.add(this.mesh);
-        }
-        dispose() {
-            this.outline.geometry.dispose();
-            this.outline.material.dispose();
-            this.mesh.geometry.dispose();
-            this.mesh.material.dispose();
-        }
-        updateMatrixWorld(force) {
-            this.scale.set(0.5 * this.size, 0.5 * this.size, 1);
-            super.updateMatrixWorld(force);
-        }
-        getLineMaterial() {
-            return this.outline.material;
-        }
-        getMeshMaterial() {
-            return this.mesh.material;
-        }
-    }
-
-    const DESKTOP_SNAP_DISTANCE = 10;
-    const MOBILE_SNAP_DISTANCE = 50;
-    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 Snapper {
-        constructor(camera, renderer, canvas) {
-            this.camera = camera;
-            this.renderer = renderer;
-            this.canvas = canvas;
-            this.threshold = 0.0001;
-            this.raycaster = new Raycaster();
-            this.detectRadiusInPixels = this.isMobile() ? MOBILE_SNAP_DISTANCE : DESKTOP_SNAP_DISTANCE;
-            this.edgesCache = new WeakMap();
-        }
-        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, recursive = false, clip = true) {
-            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;
-            const coords = new Vector2(x, y);
-            this.raycaster.setFromCamera(coords, this.camera);
-            this.raycaster.params = {
-                Mesh: {},
-                Line: { threshold: this.threshold },
-                Line2: { threshold: this.threshold },
-                LOD: {},
-                Points: { threshold: this.threshold },
-                Sprite: {},
-            };
-            let intersects = this.raycaster.intersectObjects(objects, recursive);
-            if (clip) {
-                const clippingPlanes = this.renderer.clippingPlanes || [];
-                clippingPlanes.forEach((plane) => {
-                    intersects = intersects.filter((intersect) => plane.distanceToPoint(intersect.point) >= 0);
-                });
-            }
-            return intersects;
-        }
-        getDetectRadius(point) {
-            const camera = this.camera;
-            if (camera.isOrthographicCamera) {
-                const fieldHeight = (camera.top - camera.bottom) / camera.zoom;
-                const canvasHeight = this.canvas.height;
-                const worldUnitsPerPixel = fieldHeight / canvasHeight;
-                return this.detectRadiusInPixels * worldUnitsPerPixel;
-            }
-            if (camera.isPerspectiveCamera) {
-                const distance = camera.position.distanceTo(point);
-                const fieldHeight = 2 * Math.tan(MathUtils.degToRad(camera.fov * 0.5)) * distance;
-                const canvasHeight = this.canvas.height;
-                const worldUnitsPerPixel = fieldHeight / canvasHeight;
-                return this.detectRadiusInPixels * worldUnitsPerPixel;
-            }
-            return 0.1;
-        }
-        getSnapPoint(mouse, objects) {
-            const intersections = this.getPointerIntersects(mouse, 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();
-        }
-    }
-
     class OrbitDragger {
         constructor(viewer) {
             this.updateControls = () => {
@@ -34554,18 +34429,12 @@ void main() {
     }
 
     class CuttingPlaneDragger extends OrbitDragger {
-        constructor(viewer) {
+        constructor(viewer, normal) {
             super(viewer);
-            this.helpers = [];
-            this.activeHelper = null;
             this.transformChange = () => {
-                if (!this.activeHelper)
-                    return;
-                const plane = this.activeHelper.plane;
-                plane.normal.copy(new Vector3(0, 0, -1)).applyQuaternion(this.activeHelper.quaternion);
-                plane.constant = -this.activeHelper.position.dot(plane.normal);
+                this.plane.normal.copy(new Vector3(0, 0, -1)).applyQuaternion(this.planeCenter.quaternion);
+                this.plane.constant = -this.planeCenter.position.dot(this.plane.normal);
                 this.viewer.update();
-                this.changed = true;
             };
             this.translateDrag = (event) => {
                 this.orbit.enabled = !event.value;
@@ -34576,83 +34445,45 @@ void main() {
                 this.translate.enabled = !event.value;
             };
             this.updatePlaneSize = () => {
-                const extentsSize = this.viewer.extents.getSize(new Vector3()).length() || 1;
-                this.helpers.forEach((planeHelper) => (planeHelper.size = extentsSize));
+                this.planeHelper.size = this.viewer.extents.getSize(new Vector3()).length() || 1;
                 this.viewer.update();
             };
             this.updateTransformCamera = () => {
                 this.translate.camera = this.viewer.camera;
                 this.rotate.camera = this.viewer.camera;
-                this.snapper.camera = this.viewer.camera;
-            };
-            this.clearHelpers = () => {
-                this.setActiveHelper();
-                this.helpers.forEach((helper) => {
-                    helper.removeFromParent();
-                    helper.dispose();
-                });
-                this.helpers = [];
-                this.viewer.update();
             };
             this.onKeyDown = (event) => {
                 if (event.key === "Shift")
                     this.rotate.setRotationSnap(Math.PI / 4);
-                if (event.key === "Delete" || event.key === "Backspace")
-                    this.deleteActivePlane();
-                if (event.key === "Escape" && (this.translate.dragging || this.rotate.dragging))
-                    this.reset();
             };
             this.onKeyUp = (event) => {
                 if (event.key === "Shift")
                     this.rotate.setRotationSnap(null);
             };
-            this.onPointerDown = (event) => {
-                if (event.button !== 0 || !event.isPrimary)
-                    return;
-                this.snapper.getMousePosition(event, this.downPosition);
-                this.saveState();
-            };
-            this.onPointerUp = (event) => {
-                if (event.button !== 0)
-                    return;
-                const upPosition = this.snapper.getMousePosition(event, new Vector2());
-                if (upPosition.distanceTo(this.downPosition) !== 0)
-                    return;
-                const intersects = this.snapper.getPointerIntersects(upPosition, this.helpers, true, false);
-                if (intersects.length === 0)
-                    return;
-                this.setActiveHelper(intersects[0].object.parent);
-            };
-            this.onPointerCancel = (event) => {
-                this.viewer.canvas.dispatchEvent(new PointerEvent("pointerup", event));
-            };
             this.onDoubleClick = (event) => {
-                if (!this.activeHelper)
-                    return;
-                const mousePosition = this.snapper.getMousePosition(event, new Vector2());
-                const intersects = this.snapper.getPointerIntersects(mousePosition, [this.activeHelper], true, false);
-                if (intersects.length === 0)
-                    return;
-                this.activeHelper.rotateOnAxis(new Vector3(0, 1, 0), Math.PI);
-                this.transformChange();
                 event.stopPropagation();
+                this.planeCenter.rotateOnAxis(new Vector3(0, 1, 0), Math.PI);
+                this.transformChange();
             };
+            const extentsSize = viewer.extents.getSize(new Vector3()).length() || 1;
+            const extentsCenter = viewer.extents.getCenter(new Vector3());
+            const constant = -extentsCenter.dot(normal);
+            this.plane = new Plane(normal, constant);
             if (!viewer.renderer.clippingPlanes)
                 viewer.renderer.clippingPlanes = [];
-            this.clippingPlanes = viewer.renderer.clippingPlanes;
-            this.clippingPlanes.forEach((plane) => this.addHelper(plane));
-            const extentsSize = viewer.extents.getSize(new Vector3()).length() || 1;
-            this.snapper = new Snapper(viewer.camera, viewer.renderer, viewer.canvas);
-            this.snapper.threshold = extentsSize / 10000;
-            this.downPosition = new Vector2();
-            this.position0 = new Vector3();
-            this.quaternion0 = new Quaternion();
+            viewer.renderer.clippingPlanes.push(this.plane);
+            this.planeCenter = new Object3D();
+            this.planeCenter.position.copy(extentsCenter);
+            this.planeCenter.quaternion.setFromUnitVectors(new Vector3(0, 0, -1), normal);
+            this.viewer.helpers.add(this.planeCenter);
+            this.planeHelper = new PlaneHelper2(extentsSize);
+            this.planeCenter.add(this.planeHelper);
             this.translate = new TransformControls(viewer.camera, viewer.canvas);
-            this.translate.setMode("translate");
             this.translate.setSpace("local");
             this.translate.showX = false;
             this.translate.showY = false;
             this.translate.showZ = true;
+            this.translate.attach(this.planeCenter);
             this.translate.addEventListener("change", this.transformChange);
             this.translate.addEventListener("dragging-changed", this.translateDrag);
             this.viewer.helpers.add(this.translate.getHelper());
@@ -34662,18 +34493,14 @@ void main() {
             this.rotate.showX = true;
             this.rotate.showY = true;
             this.rotate.showZ = false;
+            this.rotate.attach(this.planeCenter);
             this.rotate.addEventListener("change", this.transformChange);
             this.rotate.addEventListener("dragging-changed", this.rotateDrag);
             this.viewer.helpers.add(this.rotate.getHelper());
-            this.setActiveHelper(this.helpers[this.helpers.length - 1]);
             this.viewer.addEventListener("explode", this.updatePlaneSize);
             this.viewer.addEventListener("show", this.updatePlaneSize);
             this.viewer.addEventListener("showall", this.updatePlaneSize);
             this.viewer.addEventListener("changecameramode", this.updateTransformCamera);
-            this.viewer.addEventListener("clearslices", this.clearHelpers);
-            this.viewer.canvas.addEventListener("pointerdown", this.onPointerDown, true);
-            this.viewer.canvas.addEventListener("pointerup", this.onPointerUp, true);
-            this.viewer.canvas.addEventListener("pointercancel", this.onPointerCancel, true);
             this.viewer.canvas.addEventListener("dblclick", this.onDoubleClick, true);
             window.addEventListener("keydown", this.onKeyDown);
             window.addEventListener("keyup", this.onKeyUp);
@@ -34684,10 +34511,6 @@ void main() {
             this.viewer.removeEventListener("show", this.updatePlaneSize);
             this.viewer.removeEventListener("showall", this.updatePlaneSize);
             this.viewer.removeEventListener("changecameramode", this.updateTransformCamera);
-            this.viewer.removeEventListener("clearslices", this.clearHelpers);
-            this.viewer.canvas.removeEventListener("pointerdown", this.onPointerDown, true);
-            this.viewer.canvas.removeEventListener("pointerup", this.onPointerUp, true);
-            this.viewer.canvas.removeEventListener("pointercancel", this.onPointerCancel, true);
             this.viewer.canvas.removeEventListener("dblclick", this.onDoubleClick, true);
             window.removeEventListener("keydown", this.onKeyDown);
             window.removeEventListener("keyup", this.onKeyUp);
@@ -34701,108 +34524,28 @@ void main() {
             this.rotate.getHelper().removeFromParent();
             this.rotate.detach();
             this.rotate.dispose();
-            this.helpers.forEach((helper) => {
-                helper.removeFromParent();
-                helper.dispose();
-            });
-            this.helpers = [];
-            this.activeHelper = null;
+            this.planeHelper.removeFromParent();
+            this.planeHelper.dispose();
+            this.planeCenter.removeFromParent();
             super.dispose();
         }
-        addHelper(plane) {
-            const extentsSize = this.viewer.extents.getSize(new Vector3()).length() || 1;
-            const extentsCenter = this.viewer.extents.getCenter(new Vector3());
-            const helper = new PlaneHelper2(extentsSize);
-            helper.plane = plane;
-            helper.position.copy(plane.projectPoint(extentsCenter, new Vector3()));
-            helper.quaternion.setFromUnitVectors(new Vector3(0, 0, -1), plane.normal);
-            this.helpers.push(helper);
-            this.viewer.helpers.add(helper);
-            return helper;
-        }
-        setActiveHelper(helper) {
-            if (helper === this.activeHelper)
-                return;
-            if (this.activeHelper) {
-                this.activeHelper.getLineMaterial().color.setHex(0xf0f0f0);
-                this.activeHelper.getMeshMaterial().opacity = 0.15;
-                this.translate.detach();
-                this.rotate.detach();
-            }
-            this.activeHelper = helper;
-            if (this.activeHelper) {
-                this.activeHelper.getLineMaterial().color.setHex(0xd0d0d0);
-                this.activeHelper.getMeshMaterial().opacity = 0.3;
-                this.translate.attach(this.activeHelper);
-                this.rotate.attach(this.activeHelper);
-            }
-            this.viewer.update();
-        }
-        saveState() {
-            if (!this.activeHelper)
-                return;
-            this.position0.copy(this.activeHelper.position);
-            this.quaternion0.copy(this.activeHelper.quaternion);
-        }
-        reset() {
-            if (!this.activeHelper)
-                return;
-            this.translate.dragging = false;
-            this.rotate.dragging = false;
-            this.orbit.state = STATE.NONE;
-            this.activeHelper.position.copy(this.position0);
-            this.activeHelper.quaternion.copy(this.quaternion0);
-            this.transformChange();
-        }
-        addPlane(normal) {
-            const extentsCenter = this.viewer.extents.getCenter(new Vector3());
-            const constant = -extentsCenter.dot(normal);
-            const plane = new Plane(normal, constant);
-            this.clippingPlanes.push(plane);
-            const helper = this.addHelper(plane);
-            this.setActiveHelper(helper);
-        }
-        addPlaneX() {
-            this.addPlane(new Vector3(-1, 0, 0));
-        }
-        addPlaneY() {
-            this.addPlane(new Vector3(0, -1, 0));
-        }
-        addPlaneZ() {
-            this.addPlane(new Vector3(0, 0, -1));
-        }
-        deleteActivePlane() {
-            if (!this.activeHelper)
-                return;
-            const helper = this.activeHelper;
-            const index = this.clippingPlanes.indexOf(helper.plane);
-            if (index !== -1)
-                this.clippingPlanes.splice(index, 1);
-            this.helpers = this.helpers.filter((x) => x !== helper);
-            helper.removeFromParent();
-            helper.dispose();
-            this.setActiveHelper(this.helpers[this.helpers.length - 1]);
-        }
     }
 
     class CuttingPlaneXAxisDragger extends CuttingPlaneDragger {
         constructor(viewer) {
-            super(viewer);
-            this.addPlaneX();
+            super(viewer, new Vector3(-1, 0, 0));
         }
     }
 
     class CuttingPlaneYAxisDragger extends CuttingPlaneDragger {
         constructor(viewer) {
-            super(viewer);
-            this.addPlaneY();
+            super(viewer, new Vector3(0, -1, 0));
         }
     }
 
     class CuttingPlaneZAxisDragger extends CuttingPlaneDragger {
         constructor(viewer) {
-            super(viewer);
-            this.addPlaneZ();
+            super(viewer, new Vector3(0, 0, -1));
         }
     }
 
@@ -34879,6 +34622,120 @@ void main() {
         }
     }
 
+    const DESKTOP_SNAP_DISTANCE = 10;
+    const MOBILE_SNAP_DISTANCE = 50;
+    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 Snapper {
+        constructor(camera, renderer, canvas) {
+            this.camera = camera;
+            this.renderer = renderer;
+            this.canvas = canvas;
+            this.threshold = 0.0001;
+            this.raycaster = new Raycaster();
+            this.detectRadiusInPixels = this.isMobile() ? MOBILE_SNAP_DISTANCE : DESKTOP_SNAP_DISTANCE;
+            this.edgesCache = new WeakMap();
+        }
+        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;
+            const coords = new Vector2(x, y);
+            this.raycaster.setFromCamera(coords, this.camera);
+            this.raycaster.params = {
+                Mesh: {},
+                Line: { threshold: this.threshold },
+                Line2: { threshold: this.threshold },
+                LOD: {},
+                Points: { threshold: this.threshold },
+                Sprite: {},
+            };
+            let intersects = this.raycaster.intersectObjects(objects, false);
+            (this.renderer.clippingPlanes || []).forEach((plane) => {
+                intersects = intersects.filter((intersect) => plane.distanceToPoint(intersect.point) >= 0);
+            });
+            return intersects;
+        }
+        getDetectRadius(point) {
+            const camera = this.camera;
+            if (camera.isOrthographicCamera) {
+                const fieldHeight = (camera.top - camera.bottom) / camera.zoom;
+                const canvasHeight = this.canvas.height;
+                const worldUnitsPerPixel = fieldHeight / canvasHeight;
+                return this.detectRadiusInPixels * worldUnitsPerPixel;
+            }
+            if (camera.isPerspectiveCamera) {
+                const distance = camera.position.distanceTo(point);
+                const fieldHeight = 2 * Math.tan(MathUtils.degToRad(camera.fov * 0.5)) * distance;
+                const canvasHeight = this.canvas.height;
+                const worldUnitsPerPixel = fieldHeight / canvasHeight;
+                return this.detectRadiusInPixels * worldUnitsPerPixel;
+            }
+            return 0.1;
+        }
+        getSnapPoint(mouse, objects) {
+            const intersections = this.getPointerIntersects(mouse, 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();
+        }
+    }
+
     const _downPoint = new Vector2();
     class MeasureLineDragger extends OrbitDragger {
         constructor(viewer) {
@@ -35290,12 +35147,6 @@ void main() {
             this.movementSpeed = 0.1;
             this.multiplier = 3;
             this.groundFollowingSkippedFrames = 0;
-            this.GROUND_BOX_HALF_SIZE = 20;
-            this.GROUND_BOX_REFRESH_THRESHOLD = 0.3;
-            this._groundObjectBoxes = new Map();
-            this._activeGroundObjects = [];
-            this._groundBox = new Box3();
-            this._groundBoxCenter = new Vector3();
             this.moveWheel = 0;
             this.mouseDragOn = false;
             this._up = new Vector3();
@@ -35362,20 +35213,11 @@ void main() {
                 }
             };
             this.onKeyUp = (event) => {
-                if (this.moveKeys.delete(event.code)) {
-                    if (this.moveKeys.size === 0) {
-                        this._rebuildGroundBox(this.object.position);
-                    }
+                if (this.moveKeys.delete(event.code))
                     this.update();
-                }
             };
             this.camera = camera;
             this.groundObjects = groundObjects;
-            for (const obj of groundObjects) {
-                this._groundObjectBoxes.set(obj, new Box3().setFromObject(obj));
-            }
-            const pos = this.object.position;
-            this._rebuildGroundBox(pos);
             this.raycaster = new Raycaster();
             this.raycaster.near = 0;
             this.raycaster.far = this.EYE_HEIGHT + this.FAILING_DISTANCE;
@@ -35410,29 +35252,10 @@ void main() {
             window.removeEventListener("keyup", this.onKeyUp);
             super.dispose();
         }
-        _rebuildGroundBox(center) {
-            const h = this.GROUND_BOX_HALF_SIZE;
-            this._groundBoxCenter.copy(center);
-            this._groundBox.set(new Vector3(center.x - h, center.y - h * 4, center.z - h), new Vector3(center.x + h, center.y + h * 4, center.z + h));
-            this._activeGroundObjects = this.groundObjects.filter((obj) => {
-                const objectBox = this._groundObjectBoxes.get(obj);
-                return objectBox !== undefined && this._groundBox.intersectsBox(objectBox);
-            });
-        }
-        _needsGroundBoxRebuild(pos) {
-            if (this._activeGroundObjects.length === 0 && this.groundObjects.length > 0)
-                return true;
-            const threshold = this.GROUND_BOX_HALF_SIZE * this.GROUND_BOX_REFRESH_THRESHOLD;
-            return (Math.abs(pos.x - this._groundBoxCenter.x) > threshold || Math.abs(pos.z - this._groundBoxCenter.z) > threshold);
-        }
         updateGroundFollowing() {
-            const pos = this.object.position;
-            if (this._needsGroundBoxRebuild(pos)) {
-                this._rebuildGroundBox(pos);
-            }
             this._up.copy(this.camera.up).negate();
-            this.raycaster.set(pos, this._up);
-            const intersects = this.raycaster.intersectObjects(this._activeGroundObjects, false);
+            this.raycaster.set(this.object.position, this._up);
+            const intersects = this.raycaster.intersectObjects(this.groundObjects, false);
             if (intersects.length > 0) {
                 const groundY = intersects[0].point.y;
                 const targetY = groundY + this.EYE_HEIGHT;
@@ -35984,7 +35807,6 @@ void main() {
     draggers.registerDragger("Orbit", (viewer) => new OrbitDragger(viewer));
     draggers.registerDragger("Zoom", (viewer) => new ZoomDragger(viewer));
     draggers.registerDragger("MeasureLine", (viewer) => new MeasureLineDragger(viewer));
-    draggers.registerDragger("CuttingPlane", (viewer) => new CuttingPlaneDragger(viewer));
     draggers.registerDragger("CuttingPlaneXAxis", (viewer) => new CuttingPlaneXAxisDragger(viewer));
     draggers.registerDragger("CuttingPlaneYAxis", (viewer) => new CuttingPlaneYAxisDragger(viewer));
     draggers.registerDragger("CuttingPlaneZAxis", (viewer) => new CuttingPlaneZAxisDragger(viewer));
@@ -37519,7 +37341,7 @@ void main() {
                 this.getMousePosition(event, this.downPosition);
             };
             this.onPointerUp = (event) => {
-                if (!event.isPrimary || event.button !== 0)
+                if (!event.isPrimary)
                     return;
                 const upPosition = this.getMousePosition(event, new Vector2());
                 if (upPosition.distanceTo(this.downPosition) !== 0)
@@ -38982,81 +38804,6 @@ void main() {
         this.mergedObjectMap = new Map();
         this.mergedGeometryVisibility = new Map();
         this._webglInfoCache = null;
-        this.transformTextureSize = 1024;
-        this.transformTexture = this.createDummyTexture();
-        this.transformData = null;
-        this.identityTransformData = null;
-        this.visibilityMaterials = new Set();
-      }
-      createDummyTexture() {
-        const data = new Float32Array(16);
-        const identity = new Matrix4();
-        identity.toArray(data);
-        const dummyData = new Float32Array(16);
-        identity.toArray(dummyData);
-        const dummyTexture = new DataTexture(dummyData, 4, 1, RGBAFormat, FloatType);
-        dummyTexture.minFilter = NearestFilter;
-        dummyTexture.magFilter = NearestFilter;
-        dummyTexture.needsUpdate = true;
-        return dummyTexture;
-      }
-      initTransformTexture() {
-        if (this.transformTexture) {
-          this.transformTexture.dispose();
-        }
-        const maxInstanceCount = this.maxObjectId + 1;
-        let size = Math.sqrt(maxInstanceCount * 4);
-        size = Math.ceil(size / 4) * 4;
-        size = Math.max(size, 4);
-        this.transformTextureSize = size;
-        const arraySize = size * size * 4;
-        this.transformData = new Float32Array(arraySize);
-        this.identityTransformData = new Float32Array(arraySize);
-        for (let i = 0; i <= this.maxObjectId; i++) {
-          const base = i * 16;
-          if (base + 15 < arraySize) {
-            this.identityTransformData[base + 0] = 1;
-            this.identityTransformData[base + 5] = 1;
-            this.identityTransformData[base + 10] = 1;
-            this.identityTransformData[base + 15] = 1;
-          }
-        }
-        this._resetTransformData(false);
-        this.transformTexture = new DataTexture(this.transformData, size, size, RGBAFormat, FloatType);
-        this.transformTexture.needsUpdate = true;
-        this.transformTexture.generateMipmaps = false;
-        console.log(`Initialized transform texture: ${size}x${size} for ${maxInstanceCount} objects`);
-        this.updateMaterialUniforms();
-        this.visibilityMaterials.forEach((material) => {
-          material.needsUpdate = true;
-        });
-      }
-      _resetTransformData(updateTexture = true) {
-        if (!this.transformData || !this.identityTransformData) return;
-        this.transformData.set(this.identityTransformData);
-        if (updateTexture) {
-          this.updateTransformTexture();
-        }
-      }
-      updateMaterialUniforms() {
-        if (
-          this._lastTransformTexture === this.transformTexture &&
-          this._lastTransformTextureSize === this.transformTextureSize
-        ) {
-          return;
-        }
-        this._lastTransformTexture = this.transformTexture;
-        this._lastTransformTextureSize = this.transformTextureSize;
-        this.visibilityMaterials.forEach((material) => {
-          if (material.userData && material.userData.visibilityUniforms) {
-            material.userData.visibilityUniforms.transformTexture.value = this.transformTexture;
-            material.userData.visibilityUniforms.transformTextureSize.value = this.transformTextureSize;
-          }
-        });
-      }
-      updateTransformTexture() {
-        if (!this.transformTexture) return;
-        this.transformTexture.needsUpdate = true;
       }
       setVisibleEdges(visible) {
         this.visibleEdges = visible;
@@ -39946,82 +39693,36 @@ void main() {
         }
       }
       createVisibilityMaterial(material) {
-        this.visibilityMaterials.add(material);
-        const uniforms = {
-          transformTexture: { value: this.transformTexture },
-          transformTextureSize: { value: this.transformTextureSize },
-        };
-        material.userData.visibilityUniforms = uniforms;
         material.onBeforeCompile = (shader) => {
-          shader.uniforms.transformTexture = uniforms.transformTexture;
-          shader.uniforms.transformTextureSize = uniforms.transformTextureSize;
           shader.vertexShader = shader.vertexShader.replace(
             "#include <common>",
             `
         #include <common>
-        
         attribute float visibility;
-        attribute float objectId;
         varying float vVisibility;
-        uniform highp sampler2D transformTexture;
-        uniform float transformTextureSize;
-
-        mat4 getTransformMatrix(float instanceId) {
-            int size = int(transformTextureSize);
-            int index = int(instanceId) * 4;
-            
-            int x0 = index % size;
-            int y0 = index / size;
-            
-            vec4 row0 = texelFetch(transformTexture, ivec2(x0, y0), 0);
-            vec4 row1 = texelFetch(transformTexture, ivec2(x0 + 1, y0), 0);
-            vec4 row2 = texelFetch(transformTexture, ivec2(x0 + 2, y0), 0);
-            vec4 row3 = texelFetch(transformTexture, ivec2(x0 + 3, y0), 0);
-            
-            return mat4(row0, row1, row2, row3);
-        }
         `
           );
-          shader.vertexShader = shader.vertexShader.replace(
-            "void main() {",
+          shader.fragmentShader = shader.fragmentShader.replace(
+            "#include <common>",
             `
-        void main() {
-            mat4 batchingMatrix = getTransformMatrix(objectId);
-            vVisibility = visibility;
+        #include <common>
+        varying float vVisibility;
         `
           );
-          if (shader.vertexShader.includes("#include <beginnormal_vertex>")) {
-            shader.vertexShader = shader.vertexShader.replace(
-              "#include <beginnormal_vertex>",
-              `
-            vec3 objectNormal = vec3( normal );
-            mat3 bm = mat3( batchingMatrix );
-            objectNormal = bm * objectNormal;
-            `
-            );
-          }
           shader.vertexShader = shader.vertexShader.replace(
-            "#include <begin_vertex>",
+            "void main() {",
             `
-        vec3 transformed = vec3( position );
-        transformed = ( batchingMatrix * vec4( transformed, 1.0 ) ).xyz;
+        void main() {
+          vVisibility = visibility;
         `
           );
-          shader.fragmentShader = shader.fragmentShader
-            .replace(
-              "#include <common>",
-              `
-        #include <common>
-        varying float vVisibility;
-        `
-            )
-            .replace(
-              "void main() {",
-              `
+          shader.fragmentShader = shader.fragmentShader.replace(
+            "void main() {",
+            `
         void main() {
           if (vVisibility < 0.5) discard;
         `
-            );
+          );
         };
         material.needsUpdate = true;
         return material;
@@ -40136,8 +39837,6 @@ void main() {
         this.objectIdToIndex.clear();
         this.maxObjectId = 0;
         this.objectVisibility = new Float32Array();
-        this.meshToNodeMap = null;
-        this.visibilityMaterials.clear();
       }
       setStructureTransform(structureId, matrix) {
         const rootGroup = this.structureRoots.get(structureId);
@@ -40253,15 +39952,12 @@ void main() {
         });
         this.originalObjects.clear();
         this.originalObjectsToSelection.clear();
-        this.objectIdToIndex.clear();
-        this.maxObjectId = 0;
         const structureGroups = new Map();
         this.dispatchEvent("optimizationprogress", {
           phase: "collecting",
           progress: 5,
           message: "Collecting scene objects...",
         });
-        let totalObjectsToMerge = 0;
         this.scene.traverse((object) => {
           if (object.userData.structureId) {
             const structureId = object.userData.structureId;
@@ -40279,32 +39975,17 @@ void main() {
               });
             }
             const group = structureGroups.get(structureId);
-            let added = false;
             if (object instanceof Mesh) {
               this.addToMaterialGroup(object, group.mapMeshes, group.meshes);
-              added = true;
             } else if (object instanceof LineSegments) {
               this.addToMaterialGroup(object, group.mapLineSegments, group.lineSegments);
-              added = true;
             } else if (object instanceof Line$1) {
               this.addToMaterialGroup(object, group.mapLines, group.lines);
-              added = true;
             } else if (object instanceof Points) {
               this.addToMaterialGroup(object, group.mapPoints, group.points);
-              added = true;
-            }
-            if (added) {
-              totalObjectsToMerge++;
             }
           }
         });
-        if (totalObjectsToMerge > 0) {
-          console.log(`Pre-allocating transform texture for ${totalObjectsToMerge} objects`);
-          this.maxObjectId = totalObjectsToMerge;
-          this.initTransformTexture();
-          this.initializeObjectVisibility();
-          this.maxObjectId = 0;
-        }
         let processedGroups = 0;
         const totalGroups = structureGroups.size;
         this.dispatchEvent("optimizationprogress", {
@@ -40349,6 +40030,7 @@ void main() {
             this.originalObjectsToSelection.add(obj);
           }
         });
+        this.initializeObjectVisibility();
         console.log(`Optimization complete. Total objects: ${this.maxObjectId}`);
         this.dispatchEvent("optimizationprogress", {
           phase: "complete",
@@ -40417,7 +40099,6 @@ void main() {
               }
               const visibilityMaterial = this.createVisibilityMaterial(group.material);
               const mergedMesh = new Mesh(mergedGeometry, visibilityMaterial);
-              mergedMesh.frustumCulled = false;
               mergedMesh.userData.isOptimized = true;
               rootGroup.add(mergedMesh);
               this.mergedMesh.add(mergedMesh);
@@ -40534,7 +40215,6 @@ void main() {
           geometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
           const visibilityMaterial = this.createVisibilityMaterial(group.material);
           const mergedLine = new LineSegments(geometry, visibilityMaterial);
-          mergedLine.frustumCulled = false;
           mergedLine.userData.isEdge = isEdge;
           mergedLine.userData.isOptimized = true;
           const mergedObjects = [mergedLine];
@@ -40623,7 +40303,6 @@ void main() {
               mergedGeometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
               const visibilityMaterial = this.createVisibilityMaterial(group.material);
               const mergedLine = new LineSegments(mergedGeometry, visibilityMaterial);
-              mergedLine.frustumCulled = false;
               mergedLine.userData.isEdge = isEdge;
               mergedLine.userData.isOptimized = true;
               if (this.useVAO) {
@@ -40693,27 +40372,7 @@ void main() {
             const mergedObjects = [];
             if (geometries.length > 0) {
               const mergedGeometry = mergeGeometries(geometries, false);
-              const totalVertices = mergedGeometry.attributes.position.count;
-              const objectIds = new Float32Array(totalVertices);
-              let vertexOffset = 0;
-              group.objects.forEach((points) => {
-                const handle = points.userData.handle;
-                if (!this.objectIdToIndex.has(handle)) {
-                  this.objectIdToIndex.set(handle, this.maxObjectId++);
-                }
-                const objectId = this.objectIdToIndex.get(handle);
-                const count = points.geometry.attributes.position.count;
-                for (let i = 0; i < count; i++) {
-                  objectIds[vertexOffset++] = objectId;
-                }
-              });
-              mergedGeometry.setAttribute("objectId", new BufferAttribute(objectIds, 1));
-              const visibilityArray = new Float32Array(totalVertices);
-              visibilityArray.fill(1.0);
-              mergedGeometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
-              const visibilityMaterial = this.createVisibilityMaterial(group.material);
-              const mergedPoints = new Points(mergedGeometry, visibilityMaterial);
-              mergedPoints.frustumCulled = false;
+              const mergedPoints = new Points(mergedGeometry, group.material);
               mergedPoints.userData.isOptimized = true;
               if (this.useVAO) {
                 this.createVAO(mergedPoints);
@@ -40782,33 +40441,13 @@ void main() {
             geometriesWithIndex.push(clonedGeometry);
           });
           const finalGeometry = mergeGeometries(geometriesWithIndex, false);
-          const totalVertices = finalGeometry.attributes.position.count;
-          const objectIds = new Float32Array(totalVertices);
-          let vertexOffset = 0;
-          lineSegmentsArray.forEach((segment) => {
-            const handle = segment.userData.handle;
-            if (!this.objectIdToIndex.has(handle)) {
-              this.objectIdToIndex.set(handle, this.maxObjectId++);
-            }
-            const objectId = this.objectIdToIndex.get(handle);
-            const count = segment.geometry.attributes.position.count;
-            for (let i = 0; i < count; i++) {
-              objectIds[vertexOffset++] = objectId;
-            }
-          });
-          finalGeometry.setAttribute("objectId", new BufferAttribute(objectIds, 1));
-          const visibilityArray = new Float32Array(totalVertices);
-          visibilityArray.fill(1.0);
-          finalGeometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
           const material = new LineBasicMaterial({
             vertexColors: true,
           });
-          const visibilityMaterial = this.createVisibilityMaterial(material);
           if (this.useVAO) {
             this.createVAO(finalGeometry);
           }
-          const mergedLine = new LineSegments(finalGeometry, visibilityMaterial);
-          mergedLine.frustumCulled = false;
+          const mergedLine = new LineSegments(finalGeometry, material);
           mergedLine.userData.structureId = structureId;
           mergedLine.userData.isOptimized = true;
           rootGroup.add(mergedLine);
@@ -40927,50 +40566,18 @@ void main() {
           console.warn("No merged objects to transform");
           return;
         }
-        if (!this.transformData) {
-          console.warn("Transform texture not initialized");
-          return;
+        this.objectTransforms = new Map(objectTransformMap);
+        for (const mesh of this.mergedMesh) {
+          this._applyTransformToMergedObject(mesh);
         }
-        this.objectTransforms = objectTransformMap;
-        this._resetTransformData(false);
-        const transformData = this.transformData;
-        const objectIdToIndex = this.objectIdToIndex;
-        let textureNeedsUpdate = false;
-        if (objectTransformMap instanceof Map) {
-          for (const [object, matrix] of objectTransformMap.entries()) {
-            const userData = object.userData;
-            if (!userData) continue;
-            const handle = userData.handle;
-            if (handle === undefined) continue;
-            const objectId = objectIdToIndex.get(handle);
-            if (objectId !== undefined) {
-              transformData.set(matrix.elements, objectId * 16);
-              textureNeedsUpdate = true;
-            }
-          }
-        } else {
-          const len = objectTransformMap.length;
-          for (let i = 0; i < len; i++) {
-            const pair = objectTransformMap[i];
-            const userData = pair[0].userData;
-            if (!userData) continue;
-            const handle = userData.handle;
-            if (handle === undefined) continue;
-            const objectId = objectIdToIndex.get(handle);
-            if (objectId !== undefined) {
-              transformData.set(pair[1].elements, objectId * 16);
-              textureNeedsUpdate = true;
-            }
-          }
+        for (const line of this.mergedLines) {
+          this._applyTransformToMergedObject(line);
         }
-        if (textureNeedsUpdate) {
-          this.updateTransformTexture();
-          if (
-            this._lastTransformTexture !== this.transformTexture ||
-            this._lastTransformTextureSize !== this.transformTextureSize
-          ) {
-            this.updateMaterialUniforms();
-          }
+        for (const lineSegment of this.mergedLineSegments) {
+          this._applyTransformToMergedObject(lineSegment);
+        }
+        for (const point of this.mergedPoints) {
+          this._applyTransformToMergedObject(point);
         }
       }
       createExplodeTransforms(objects = null, explodeCenter = null, explodeFactor = 1.5) {
@@ -40987,66 +40594,21 @@ void main() {
             ? objects
             : Array.from(objects)
           : Array.from(this.originalObjects);
-        const structureInverseMatrices = new Map();
-        if (!this.meshToNodeMap) {
-          this.meshToNodeMap = new Map();
-          for (const node of this.nodes.values()) {
-            if (node.object) {
-              this.meshToNodeMap.set(node.object, node);
-            }
-          }
-        }
         for (const obj of objectsArray) {
           if (!obj.geometry || !obj.geometry.attributes.position) continue;
-          if (!obj.userData.explodeVector) {
-            let center = null;
-            const node = this.meshToNodeMap.get(obj);
-            if (node && node.geometryExtents) {
-              const box = node.geometryExtents.clone();
-              box.applyMatrix4(obj.matrixWorld);
-              center = new Vector3();
-              box.getCenter(center);
-            }
-            if (!center) {
-              if (!obj.geometry.boundingBox) obj.geometry.computeBoundingBox();
-              const box = obj.geometry.boundingBox.clone();
-              box.applyMatrix4(obj.matrixWorld);
-              center = new Vector3();
-              box.getCenter(center);
-            }
-            const explodeVector = center.sub(explodeCenter);
-            obj.userData.explodeVector = explodeVector;
+          const boundingBox = new Box3().setFromBufferAttribute(obj.geometry.attributes.position);
+          if (obj.matrixWorld) {
+            boundingBox.applyMatrix4(obj.matrixWorld);
           }
-          const explodeVector = obj.userData.explodeVector;
-          const distance = explodeVector.length();
+          if (boundingBox.isEmpty()) continue;
+          const objectCenter = new Vector3();
+          boundingBox.getCenter(objectCenter);
+          const direction = objectCenter.clone().sub(explodeCenter);
+          const distance = direction.length();
           if (distance > 0) {
-            const offset = explodeVector.clone().multiplyScalar(explodeFactor - 1.0);
-            const localOffset = offset.clone();
-            if (obj.userData.structureId) {
-              const structureId = obj.userData.structureId;
-              let inverseMatrix = structureInverseMatrices.get(structureId);
-              if (!inverseMatrix) {
-                const rootGroup = this.structureRoots.get(structureId);
-                if (rootGroup) {
-                  if (!rootGroup.userData.inverseWorldMatrix) {
-                    rootGroup.userData.inverseWorldMatrix = new Matrix4().copy(rootGroup.matrixWorld).invert();
-                  }
-                  inverseMatrix = rootGroup.userData.inverseWorldMatrix;
-                  structureInverseMatrices.set(structureId, inverseMatrix);
-                }
-              }
-              if (inverseMatrix) {
-                const zero = new Vector3(0, 0, 0).applyMatrix4(inverseMatrix);
-                const vec = offset.clone().applyMatrix4(inverseMatrix).sub(zero);
-                localOffset.copy(vec);
-              }
-            }
-            let matrix = obj.userData.explodeMatrix;
-            if (!matrix) {
-              matrix = new Matrix4();
-              obj.userData.explodeMatrix = matrix;
-            }
-            matrix.makeTranslation(localOffset.x, localOffset.y, localOffset.z);
+            direction.normalize();
+            const offset = direction.multiplyScalar(distance * (explodeFactor - 1.0));
+            const matrix = new Matrix4().makeTranslation(offset.x, offset.y, offset.z);
             transformMap.set(obj, matrix);
           }
         }
@@ -41054,11 +40616,116 @@ void main() {
       }
       clearTransforms() {
         this.objectTransforms.clear();
-        this._resetTransformData(true);
+        for (const mesh of this.mergedMesh) {
+          this._restoreOriginalGeometry(mesh);
+        }
+        for (const line of this.mergedLines) {
+          this._restoreOriginalGeometry(line);
+        }
+        for (const lineSegment of this.mergedLineSegments) {
+          this._restoreOriginalGeometry(lineSegment);
+        }
+        for (const point of this.mergedPoints) {
+          this._restoreOriginalGeometry(point);
+        }
       }
       clearHandleTransforms() {
         this.clearTransforms();
       }
+      _applyTransformToMergedObject(mergedObject) {
+        const objectData = this.mergedObjectMap.get(mergedObject.uuid);
+        if (!objectData || !objectData.objectMapping) return;
+        const geometry = mergedObject.geometry;
+        if (!geometry || !geometry.attributes.position) return;
+        const positionAttr = geometry.attributes.position;
+        const positions = positionAttr.array;
+        if (!this.transformedGeometries.has(mergedObject.uuid)) {
+          this.transformedGeometries.set(mergedObject.uuid, new Float32Array(positions));
+        }
+        const originalPositions = this.transformedGeometries.get(mergedObject.uuid);
+        const tempVector = new Vector3();
+        for (const [originalMesh, mappingData] of objectData.objectMapping) {
+          const transform = this.objectTransforms.get(originalMesh);
+          if (!transform) {
+            const startIdx = mappingData.startVertexIndex * 3;
+            const endIdx = (mappingData.startVertexIndex + mappingData.vertexCount) * 3;
+            for (let i = startIdx; i < endIdx; i++) {
+              positions[i] = originalPositions[i];
+            }
+            continue;
+          }
+          const startVertex = mappingData.startVertexIndex;
+          const vertexCount = mappingData.vertexCount;
+          for (let i = 0; i < vertexCount; i++) {
+            const idx = (startVertex + i) * 3;
+            tempVector.set(originalPositions[idx], originalPositions[idx + 1], originalPositions[idx + 2]);
+            tempVector.applyMatrix4(transform);
+            positions[idx] = tempVector.x;
+            positions[idx + 1] = tempVector.y;
+            positions[idx + 2] = tempVector.z;
+          }
+        }
+        if (geometry.attributes.normal) {
+          this._updateNormalsForTransform(geometry, objectData, originalPositions);
+        }
+        positionAttr.needsUpdate = true;
+        geometry.computeBoundingSphere();
+        geometry.computeBoundingBox();
+      }
+      _updateNormalsForTransform(geometry, objectData, originalPositions) {
+        const normalAttr = geometry.attributes.normal;
+        if (!normalAttr) return;
+        const normals = normalAttr.array;
+        const tempVector = new Vector3();
+        const normalMatrix = new Matrix4();
+        const normalsKey = `${geometry.uuid}_normals`;
+        if (!this.transformedGeometries.has(normalsKey)) {
+          this.transformedGeometries.set(normalsKey, new Float32Array(normals));
+        }
+        const originalNormals = this.transformedGeometries.get(normalsKey);
+        for (const [originalMesh, mappingData] of objectData.objectMapping) {
+          const transform = this.objectTransforms.get(originalMesh);
+          if (!transform) {
+            const startIdx = mappingData.startVertexIndex * 3;
+            const endIdx = (mappingData.startVertexIndex + mappingData.vertexCount) * 3;
+            for (let i = startIdx; i < endIdx; i++) {
+              normals[i] = originalNormals[i];
+            }
+            continue;
+          }
+          normalMatrix.copy(transform).invert().transpose();
+          const startVertex = mappingData.startVertexIndex;
+          const vertexCount = mappingData.vertexCount;
+          for (let i = 0; i < vertexCount; i++) {
+            const idx = (startVertex + i) * 3;
+            tempVector.set(originalNormals[idx], originalNormals[idx + 1], originalNormals[idx + 2]);
+            tempVector.applyMatrix4(normalMatrix).normalize();
+            normals[idx] = tempVector.x;
+            normals[idx + 1] = tempVector.y;
+            normals[idx + 2] = tempVector.z;
+          }
+        }
+        normalAttr.needsUpdate = true;
+      }
+      _restoreOriginalGeometry(mergedObject) {
+        const geometry = mergedObject.geometry;
+        if (!geometry || !geometry.attributes.position) return;
+        const originalPositions = this.transformedGeometries.get(mergedObject.uuid);
+        if (originalPositions) {
+          const positions = geometry.attributes.position.array;
+          positions.set(originalPositions);
+          geometry.attributes.position.needsUpdate = true;
+        }
+        const normalsKey = `${geometry.uuid}_normals`;
+        const originalNormals = this.transformedGeometries.get(normalsKey);
+        if (originalNormals && geometry.attributes.normal) {
+          const normals = geometry.attributes.normal.array;
+          normals.set(originalNormals);
+          geometry.attributes.normal.needsUpdate = true;
+        }
+        geometry.computeBoundingSphere();
+        geometry.computeBoundingBox();
+      }
       syncHiddenObjects() {
         if (this.mergedObjectMap.size === 0) {
           console.log("No merged objects to sync");