@tonybfox/threejs-tools 1.0.0

package/dist/measurements/index.cjs

@@ -0,0 +1,1198 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/measurements/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MeasurementTool: () => MeasurementTool,
+  SnapMode: () => SnapMode
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/measurements/src/MeasurementTool.ts
+var THREE = __toESM(require("three"));
+var import_CSS2DRenderer = require("three/examples/jsm/renderers/CSS2DRenderer");
+
+// packages/measurements/src/MeasurementTypes.ts
+var SnapMode = /* @__PURE__ */ ((SnapMode2) => {
+  SnapMode2["VERTEX"] = "vertex";
+  SnapMode2["FACE"] = "face";
+  SnapMode2["EDGE"] = "edge";
+  SnapMode2["DISABLED"] = "disabled";
+  return SnapMode2;
+})(SnapMode || {});
+
+// packages/measurements/src/MeasurementTool.ts
+var MeasurementTool = class extends THREE.EventDispatcher {
+  constructor(scene, camera, options = {}) {
+    super();
+    this.measurements = [];
+    this.raycaster = new THREE.Raycaster();
+    // Interactive mode properties
+    this.isInteractive = false;
+    this.domElement = null;
+    this.controls = null;
+    this.defaultTargets = [];
+    this.activeTargets = [];
+    this.currentMeasurement = null;
+    this.activeInteractionOptions = null;
+    this.pendingMeasurementOptions = null;
+    this.previewLine = null;
+    this.previewLabel = null;
+    this.snapMarker = null;
+    this.originalCursor = "";
+    this.cursorHidden = false;
+    // Configuration defaults
+    this.defaultOptions = {
+      lineColor: 16711680,
+      labelColor: "#ffffff",
+      lineWidth: 2,
+      fontSize: 16,
+      fontFamily: "Arial, sans-serif",
+      snapMode: "vertex" /* VERTEX */,
+      snapEnabled: true,
+      snapDistance: 0.05,
+      targets: [],
+      isDynamic: false
+    };
+    this.previewColor = 65535;
+    this.markerColor = 65280;
+    this.markerSize = 0.08;
+    this.markerVisible = true;
+    // Edit mode properties
+    this.isEditMode = false;
+    this.editingMeasurement = null;
+    this.editingPoint = null;
+    this.startEditSprite = null;
+    this.endEditSprite = null;
+    this.editSpriteMaterial = null;
+    this.isDragging = false;
+    // Private methods
+    this.onMouseClick = (event) => {
+      if (!this.isInteractive) return;
+      const snapResult = this.getSnapResult(event);
+      if (!snapResult) return;
+      if (!this.currentMeasurement) {
+        this.startMeasurement(snapResult);
+      } else {
+        this.completeMeasurement(snapResult);
+      }
+    };
+    this.onMouseMove = (event) => {
+      if (!this.isInteractive) return;
+      const snapResult = this.getSnapResult(event);
+      if (!snapResult) {
+        this.hideSnapMarker();
+        this.showCursor();
+        return;
+      }
+      if (!this.currentMeasurement) {
+        this.updateSnapMarker(snapResult.point, true);
+        this.hideCursor();
+      } else {
+        this.updateSnapMarker(snapResult.point, true);
+        this.hideCursor();
+        this.updatePreview(snapResult.point);
+      }
+    };
+    this.onKeyDown = (event) => {
+      if (!this.isInteractive) return;
+      if (event.key === "Escape") {
+        this.cancelCurrentMeasurement();
+      }
+    };
+    this.onEditMouseDown = (event) => {
+      if (!this.isEditMode || !this.domElement) return;
+      const mouse = new THREE.Vector2();
+      const rect = this.domElement.getBoundingClientRect();
+      mouse.x = (event.clientX - rect.left) / rect.width * 2 - 1;
+      mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+      this.raycaster.setFromCamera(mouse, this.camera);
+      const sprites = [this.startEditSprite, this.endEditSprite].filter(
+        (s) => s !== null
+      );
+      const spriteIntersects = this.raycaster.intersectObjects(sprites);
+      if (spriteIntersects.length > 0) {
+        const sprite = spriteIntersects[0].object;
+        this.editingPoint = sprite.userData.editPoint;
+        this.isDragging = true;
+        this.disableControls();
+        if (this.editingPoint === "start" && this.startEditSprite) {
+          this.startEditSprite.visible = false;
+        } else if (this.editingPoint === "end" && this.endEditSprite) {
+          this.endEditSprite.visible = false;
+        }
+        this.createSnapMarker();
+        if (this.snapMarker) {
+          this.snapMarker.position.copy(sprite.position);
+          this.snapMarker.visible = true;
+        }
+        this.hideCursor();
+      }
+    };
+    this.onEditMouseMove = (event) => {
+      if (!this.isEditMode || !this.isDragging || !this.editingMeasurement) return;
+      const snapResult = this.getSnapResult(event);
+      if (!snapResult) return;
+      if (this.snapMarker) {
+        this.snapMarker.position.copy(snapResult.point);
+        this.snapMarker.visible = this.markerVisible;
+      }
+      if (this.editingPoint === "start") {
+        this.updateMeasurementPreview(
+          snapResult.point,
+          this.editingMeasurement.end.position
+        );
+      } else if (this.editingPoint === "end") {
+        this.updateMeasurementPreview(
+          this.editingMeasurement.start.position,
+          snapResult.point
+        );
+      }
+    };
+    this.onEditMouseUp = (event) => {
+      if (!this.isEditMode || !this.isDragging || !this.editingMeasurement || !this.editingPoint)
+        return;
+      const snapResult = this.getSnapResult(event);
+      if (!snapResult) {
+        this.cancelEdit();
+        return;
+      }
+      const point = this.editingPoint === "start" ? this.editingMeasurement.start : this.editingMeasurement.end;
+      point.position.copy(snapResult.point);
+      const measurementOptions = this.editingMeasurement.options;
+      if (measurementOptions.isDynamic && snapResult.object) {
+        const localPos = snapResult.object.worldToLocal(snapResult.point.clone());
+        point.anchor = {
+          object: snapResult.object,
+          localPosition: localPos
+        };
+      } else {
+        point.anchor = void 0;
+      }
+      const newDistance = this.editingMeasurement.start.position.distanceTo(
+        this.editingMeasurement.end.position
+      );
+      this.editingMeasurement.distance = newDistance;
+      const positions = [
+        this.editingMeasurement.start.position,
+        this.editingMeasurement.end.position
+      ];
+      this.editingMeasurement.line.geometry.setFromPoints(positions);
+      this.editingMeasurement.line.geometry.attributes.position.needsUpdate = true;
+      const midpoint = this.editingMeasurement.start.position.clone().add(this.editingMeasurement.end.position).multiplyScalar(0.5);
+      this.editingMeasurement.label.position.copy(midpoint);
+      this.updateLabelText(this.editingMeasurement.label.element, newDistance);
+      if (this.startEditSprite) {
+        this.startEditSprite.position.copy(this.editingMeasurement.start.position);
+        this.startEditSprite.visible = true;
+      }
+      if (this.endEditSprite) {
+        this.endEditSprite.position.copy(this.editingMeasurement.end.position);
+        this.endEditSprite.visible = true;
+      }
+      this.removeSnapMarker();
+      this.showCursor();
+      this.enableControls();
+      this.dispatchEvent({
+        type: "measurementUpdated",
+        measurement: this.editingMeasurement
+      });
+      this.isDragging = false;
+      this.editingPoint = null;
+    };
+    this.scene = scene;
+    this.camera = camera;
+    const { domElement, controls } = options;
+    if (domElement) {
+      this.domElement = domElement;
+    }
+    if (controls) {
+      this.controls = controls;
+    }
+    this.previewMaterial = new THREE.LineDashedMaterial({
+      color: this.previewColor,
+      linewidth: this.defaultOptions.lineWidth,
+      dashSize: 0.1,
+      gapSize: 0.05
+    });
+    this.markerMaterial = new THREE.SpriteMaterial({
+      map: this.createCrosshairTexture(),
+      color: this.markerColor,
+      transparent: true,
+      opacity: 0.8,
+      sizeAttenuation: false,
+      // Keep constant size regardless of distance
+      depthTest: false
+      // Always render in front of other objects
+    });
+    this.editSpriteMaterial = new THREE.SpriteMaterial({
+      map: this.createDotTexture(),
+      color: 16755200,
+      // Orange color for edit points
+      transparent: true,
+      opacity: 0.9,
+      sizeAttenuation: false,
+      depthTest: false
+    });
+    this.raycaster.params.Line.threshold = 0.01;
+    this.raycaster.params.Points.threshold = 0.01;
+  }
+  /**
+   * Create a crosshair texture for the snap marker sprite
+   */
+  createCrosshairTexture() {
+    const size = 64;
+    const canvas = document.createElement("canvas");
+    canvas.width = size;
+    canvas.height = size;
+    const context = canvas.getContext("2d");
+    const centerX = size / 2;
+    const centerY = size / 2;
+    const lineLength = 20;
+    const gap = 6;
+    context.clearRect(0, 0, size, size);
+    context.strokeStyle = "#ffffff";
+    context.lineWidth = 3;
+    context.lineCap = "round";
+    context.beginPath();
+    context.moveTo(centerX - lineLength, centerY);
+    context.lineTo(centerX - gap, centerY);
+    context.moveTo(centerX + gap, centerY);
+    context.lineTo(centerX + lineLength, centerY);
+    context.moveTo(centerX, centerY - lineLength);
+    context.lineTo(centerX, centerY - gap);
+    context.moveTo(centerX, centerY + gap);
+    context.lineTo(centerX, centerY + lineLength);
+    context.stroke();
+    context.strokeStyle = "#000000";
+    context.lineWidth = 5;
+    context.globalCompositeOperation = "destination-over";
+    context.beginPath();
+    context.moveTo(centerX - lineLength, centerY);
+    context.lineTo(centerX - gap, centerY);
+    context.moveTo(centerX + gap, centerY);
+    context.lineTo(centerX + lineLength, centerY);
+    context.moveTo(centerX, centerY - lineLength);
+    context.lineTo(centerX, centerY - gap);
+    context.moveTo(centerX, centerY + gap);
+    context.lineTo(centerX, centerY + lineLength);
+    context.stroke();
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.needsUpdate = true;
+    return texture;
+  }
+  /**
+   * Create a dot texture for edit point sprites
+   */
+  createDotTexture() {
+    const size = 64;
+    const canvas = document.createElement("canvas");
+    canvas.width = size;
+    canvas.height = size;
+    const context = canvas.getContext("2d");
+    const centerX = size / 2;
+    const centerY = size / 2;
+    const radius = 12;
+    context.clearRect(0, 0, size, size);
+    context.fillStyle = "#ffffff";
+    context.beginPath();
+    context.arc(centerX, centerY, radius, 0, Math.PI * 2);
+    context.fill();
+    context.strokeStyle = "#000000";
+    context.lineWidth = 3;
+    context.beginPath();
+    context.arc(centerX, centerY, radius, 0, Math.PI * 2);
+    context.stroke();
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.needsUpdate = true;
+    return texture;
+  }
+  /**
+   * Create a measurement point that optionally tracks a scene object.
+   */
+  createMeasurementPoint(worldPosition, object, localPosition) {
+    if (!object) {
+      return { position: worldPosition.clone() };
+    }
+    const anchorLocal = localPosition?.clone() ?? object.worldToLocal(worldPosition.clone());
+    const resolvedWorld = object.localToWorld(anchorLocal.clone());
+    return {
+      position: resolvedWorld,
+      anchor: {
+        object,
+        localPosition: anchorLocal
+      }
+    };
+  }
+  /**
+   * Update a measurement point's world position from its anchor (if dynamic)
+   */
+  updateMeasurementPoint(point) {
+    if (!point.anchor) {
+      return false;
+    }
+    const newWorldPosition = point.anchor.localPosition.clone();
+    point.anchor.object.localToWorld(newWorldPosition);
+    if (!point.position.equals(newWorldPosition)) {
+      point.position.copy(newWorldPosition);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Add a measurement between two world positions with optional attachments.
+   *
+   * @param start - Starting world position
+   * @param end - Ending world position
+   * @param options - Optional configuration for the measurement
+   */
+  addMeasurement(start, end, options = {}) {
+    const hasAnchors = Boolean(options.startObject || options.endObject);
+    const resolvedOptions = this.resolveMeasurementOptions(
+      options,
+      options.isDynamic ?? hasAnchors
+    );
+    const startPoint = this.createMeasurementPoint(
+      start,
+      options.startObject,
+      options.startLocalPosition
+    );
+    const endPoint = this.createMeasurementPoint(
+      end,
+      options.endObject,
+      options.endLocalPosition
+    );
+    return this.addMeasurementFromPoints(startPoint, endPoint, resolvedOptions, {
+      id: options.id
+    });
+  }
+  resolveMeasurementOptions(overrides = {}, inferredDynamic) {
+    let targetCandidates;
+    if (overrides.targets && overrides.targets.length > 0) {
+      targetCandidates = overrides.targets;
+    } else if (this.defaultOptions.targets.length > 0) {
+      targetCandidates = this.defaultOptions.targets;
+    } else if (this.defaultTargets.length > 0) {
+      targetCandidates = this.defaultTargets;
+    }
+    const targets = targetCandidates && targetCandidates.length > 0 ? targetCandidates : this.getAllMeshes();
+    const isDynamic = overrides.isDynamic ?? inferredDynamic ?? this.defaultOptions.isDynamic;
+    return {
+      lineColor: overrides.lineColor ?? this.defaultOptions.lineColor,
+      labelColor: overrides.labelColor ?? this.defaultOptions.labelColor,
+      lineWidth: overrides.lineWidth ?? this.defaultOptions.lineWidth,
+      fontSize: overrides.fontSize ?? this.defaultOptions.fontSize,
+      fontFamily: overrides.fontFamily ?? this.defaultOptions.fontFamily,
+      snapMode: overrides.snapMode ?? this.defaultOptions.snapMode,
+      snapEnabled: overrides.snapEnabled ?? this.defaultOptions.snapEnabled,
+      snapDistance: overrides.snapDistance ?? this.defaultOptions.snapDistance,
+      targets,
+      isDynamic
+    };
+  }
+  getActiveMeasurementOptions() {
+    if (this.isEditMode && this.editingMeasurement) {
+      return this.editingMeasurement.options;
+    }
+    return this.activeInteractionOptions;
+  }
+  /**
+   * @deprecated Use addMeasurement(obj1, obj2, { startLocalPos, endLocalPos }) instead
+   * Add a dynamic measurement between two objects
+   */
+  addDynamicMeasurement(startObject, endObject, startLocalPos = new THREE.Vector3(), endLocalPos = new THREE.Vector3()) {
+    const startWorld = startObject.localToWorld(startLocalPos.clone());
+    const endWorld = endObject.localToWorld(endLocalPos.clone());
+    return this.addMeasurement(startWorld, endWorld, {
+      startObject,
+      endObject,
+      startLocalPosition: startLocalPos,
+      endLocalPosition: endLocalPos
+    });
+  }
+  /**
+   * @deprecated Use addMeasurement(staticPos, targetObject, { endLocalPos }) instead
+   * Add a measurement from a static point to a dynamic object
+   */
+  addMeasurementToObject(staticPos, targetObject, objectLocalPos = new THREE.Vector3()) {
+    const endWorld = targetObject.localToWorld(objectLocalPos.clone());
+    return this.addMeasurement(staticPos, endWorld, {
+      endObject: targetObject,
+      endLocalPosition: objectLocalPos
+    });
+  }
+  /**
+   * Core method to add a measurement from two measurement points
+   */
+  addMeasurementFromPoints(start, end, options, context) {
+    const id = context?.id || this.generateId();
+    const distance = start.position.distanceTo(end.position);
+    const geometry = new THREE.BufferGeometry().setFromPoints([
+      start.position,
+      end.position
+    ]);
+    const line = new THREE.Line(
+      geometry,
+      new THREE.LineBasicMaterial({
+        color: options.lineColor,
+        linewidth: options.lineWidth
+      })
+    );
+    const label = this.createLabel(distance, options);
+    const midpoint = start.position.clone().add(end.position).multiplyScalar(0.5);
+    label.position.copy(midpoint);
+    const measurement = {
+      id,
+      start,
+      end,
+      line,
+      label,
+      distance,
+      options: {
+        ...options,
+        targets: [...options.targets]
+      }
+    };
+    this.scene.add(line);
+    this.scene.add(label);
+    this.measurements.push(measurement);
+    this.dispatchEvent({
+      type: "measurementCreated",
+      measurement
+    });
+    return measurement;
+  }
+  /**
+   * Update all dynamic measurements in real-time
+   * Call this in your animation loop to keep dynamic measurements up-to-date
+   */
+  updateDynamicMeasurements() {
+    let updated = false;
+    for (const measurement of this.measurements) {
+      if (!measurement.options.isDynamic) continue;
+      let needsUpdate = false;
+      if (this.updateMeasurementPoint(measurement.start)) {
+        needsUpdate = true;
+      }
+      if (this.updateMeasurementPoint(measurement.end)) {
+        needsUpdate = true;
+      }
+      if (needsUpdate) {
+        const newDistance = measurement.start.position.distanceTo(
+          measurement.end.position
+        );
+        measurement.distance = newDistance;
+        const positions = [measurement.start.position, measurement.end.position];
+        measurement.line.geometry.setFromPoints(positions);
+        measurement.line.geometry.attributes.position.needsUpdate = true;
+        const midpoint = measurement.start.position.clone().add(measurement.end.position).multiplyScalar(0.5);
+        measurement.label.position.copy(midpoint);
+        this.updateLabelText(measurement.label.element, newDistance);
+        updated = true;
+      }
+    }
+    return updated;
+  }
+  /**
+   * Set whether interactive measurements should be dynamic or static
+   */
+  setDynamicMode(enabled) {
+    this.setDefaultMeasurementOptions({ isDynamic: enabled });
+  }
+  /**
+   * Get the current dynamic mode state
+   */
+  getDynamicMode() {
+    return this.defaultOptions.isDynamic;
+  }
+  /**
+   * Enter edit mode for a specific measurement
+   * Shows edit sprites at the measurement endpoints
+   * @param measurementIdOrIndex - The measurement ID or index
+   * @param targets - Optional target objects for snapping during edit
+   */
+  enterEditMode(measurementIdOrIndex, targets) {
+    this.exitEditMode();
+    let measurement;
+    if (typeof measurementIdOrIndex === "string") {
+      measurement = this.measurements.find((m) => m.id === measurementIdOrIndex);
+    } else {
+      measurement = this.measurements[measurementIdOrIndex];
+    }
+    if (!measurement) {
+      console.warn("Measurement not found:", measurementIdOrIndex);
+      return;
+    }
+    if (!this.domElement) {
+      console.warn(
+        "DOM element not set. Call setDomElement() or enableInteraction() first."
+      );
+      return;
+    }
+    this.isEditMode = true;
+    this.editingMeasurement = measurement;
+    const resolvedTargets = targets && targets.length > 0 ? targets : measurement.options.targets.length > 0 ? measurement.options.targets : this.getAllMeshes();
+    this.activeTargets = resolvedTargets;
+    if (targets && targets.length > 0) {
+      measurement.options.targets = [...targets];
+    }
+    this.createEditSprites();
+    this.domElement.addEventListener("mousedown", this.onEditMouseDown);
+    this.domElement.addEventListener("mousemove", this.onEditMouseMove);
+    this.domElement.addEventListener("mouseup", this.onEditMouseUp);
+    this.domElement.style.cursor = "pointer";
+    this.dispatchEvent({
+      type: "editModeEntered",
+      measurement
+    });
+  }
+  /**
+   * Exit edit mode
+   */
+  exitEditMode() {
+    if (!this.isEditMode) return;
+    const measurement = this.editingMeasurement;
+    this.removeEditSprites();
+    if (this.domElement) {
+      this.domElement.removeEventListener("mousedown", this.onEditMouseDown);
+      this.domElement.removeEventListener("mousemove", this.onEditMouseMove);
+      this.domElement.removeEventListener("mouseup", this.onEditMouseUp);
+      this.domElement.style.cursor = this.isInteractive ? "crosshair" : "default";
+    }
+    this.isEditMode = false;
+    this.editingMeasurement = null;
+    this.editingPoint = null;
+    this.isDragging = false;
+    this.activeTargets = [];
+    if (measurement) {
+      this.dispatchEvent({
+        type: "editModeExited",
+        measurement
+      });
+    }
+  }
+  /**
+   * Set the DOM element for interactions (both measurement and edit mode)
+   */
+  setDomElement(domElement) {
+    this.domElement = domElement;
+  }
+  /**
+   * Set the camera controls to disable during edit dragging
+   */
+  setControls(controls) {
+    this.controls = controls;
+  }
+  /**
+   * Set target objects for snapping (used in both interactive mode and edit mode)
+   */
+  setTargetObjects(targets) {
+    this.defaultTargets = targets.length > 0 ? targets : this.getAllMeshes();
+    this.defaultOptions.targets = [...this.defaultTargets];
+  }
+  /**
+   * Update default measurement options used when none are provided explicitly.
+   */
+  setDefaultMeasurementOptions(options) {
+    if (options.lineColor !== void 0) {
+      this.defaultOptions.lineColor = options.lineColor;
+    }
+    if (options.labelColor !== void 0) {
+      this.defaultOptions.labelColor = options.labelColor;
+    }
+    if (options.lineWidth !== void 0) {
+      this.defaultOptions.lineWidth = options.lineWidth;
+    }
+    if (options.fontSize !== void 0) {
+      this.defaultOptions.fontSize = options.fontSize;
+    }
+    if (options.fontFamily !== void 0) {
+      this.defaultOptions.fontFamily = options.fontFamily;
+    }
+    if (options.snapMode !== void 0) {
+      this.defaultOptions.snapMode = options.snapMode;
+    }
+    if (options.snapEnabled !== void 0) {
+      this.defaultOptions.snapEnabled = options.snapEnabled;
+    }
+    if (options.snapDistance !== void 0) {
+      this.defaultOptions.snapDistance = options.snapDistance;
+    }
+    if (options.targets !== void 0) {
+      this.defaultTargets = options.targets;
+      this.defaultOptions.targets = [...options.targets];
+      if (this.activeInteractionOptions) {
+        this.activeInteractionOptions.targets = [...options.targets];
+        this.activeTargets = options.targets;
+      }
+    }
+    if (options.isDynamic !== void 0) {
+      this.defaultOptions.isDynamic = options.isDynamic;
+      if (this.activeInteractionOptions) {
+        this.activeInteractionOptions.isDynamic = options.isDynamic;
+      }
+    }
+    if (this.activeInteractionOptions) {
+      if (options.lineColor !== void 0) {
+        this.activeInteractionOptions.lineColor = options.lineColor;
+      }
+      if (options.labelColor !== void 0) {
+        this.activeInteractionOptions.labelColor = options.labelColor;
+      }
+      if (options.lineWidth !== void 0) {
+        this.activeInteractionOptions.lineWidth = options.lineWidth;
+      }
+      if (options.fontSize !== void 0) {
+        this.activeInteractionOptions.fontSize = options.fontSize;
+      }
+      if (options.fontFamily !== void 0) {
+        this.activeInteractionOptions.fontFamily = options.fontFamily;
+      }
+      if (options.snapMode !== void 0) {
+        this.activeInteractionOptions.snapMode = options.snapMode;
+      }
+      if (options.snapEnabled !== void 0) {
+        this.activeInteractionOptions.snapEnabled = options.snapEnabled;
+      }
+      if (options.snapDistance !== void 0) {
+        this.activeInteractionOptions.snapDistance = options.snapDistance;
+      }
+    }
+  }
+  /**
+   * Disable camera controls (used during edit dragging)
+   */
+  disableControls() {
+    if (this.controls) {
+      this.controls.enabled = false;
+    }
+  }
+  /**
+   * Enable camera controls (used after edit dragging)
+   */
+  enableControls() {
+    if (this.controls) {
+      this.controls.enabled = true;
+    }
+  }
+  /**
+   * Enable interactive measurement mode
+   */
+  enableInteraction(options = {}) {
+    if (this.isInteractive) {
+      this.disableInteraction();
+    }
+    const resolvedOptions = this.resolveMeasurementOptions(options);
+    this.activeInteractionOptions = {
+      ...resolvedOptions,
+      targets: [...resolvedOptions.targets]
+    };
+    this.activeTargets = this.activeInteractionOptions.targets.length > 0 ? this.activeInteractionOptions.targets : this.getAllMeshes();
+    this.isInteractive = true;
+    if (this.domElement) {
+      this.domElement.addEventListener("click", this.onMouseClick);
+      this.domElement.addEventListener("mousemove", this.onMouseMove);
+      this.domElement.addEventListener("keydown", this.onKeyDown);
+      this.domElement.style.cursor = "crosshair";
+    }
+    this.createSnapMarker();
+    this.dispatchEvent({ type: "started" });
+  }
+  /**
+   * Disable interactive measurement mode
+   */
+  disableInteraction() {
+    if (!this.isInteractive || !this.domElement) return;
+    this.exitEditMode();
+    this.domElement.removeEventListener("click", this.onMouseClick);
+    this.domElement.removeEventListener("mousemove", this.onMouseMove);
+    this.domElement.removeEventListener("keydown", this.onKeyDown);
+    this.showCursor();
+    this.domElement.style.cursor = "default";
+    this.cancelCurrentMeasurement();
+    this.removeSnapMarker();
+    this.isInteractive = false;
+    this.activeInteractionOptions = null;
+    this.activeTargets = [];
+    this.dispatchEvent({ type: "ended" });
+  }
+  /**
+   * Remove the last measurement (undo)
+   */
+  undoLast() {
+    if (this.measurements.length === 0) return;
+    const lastMeasurement = this.measurements.pop();
+    this.removeMeasurementFromScene(lastMeasurement);
+    this.dispatchEvent({
+      type: "measurementRemoved",
+      measurement: lastMeasurement
+    });
+  }
+  /**
+   * Remove a specific measurement
+   */
+  removeMeasurement(measurement) {
+    const index = this.measurements.indexOf(measurement);
+    if (index === -1) return;
+    this.measurements.splice(index, 1);
+    this.removeMeasurementFromScene(measurement);
+    this.dispatchEvent({
+      type: "measurementRemoved",
+      measurement
+    });
+  }
+  /**
+   * Clear all measurements
+   */
+  clearAll() {
+    const count = this.measurements.length;
+    this.measurements.forEach((measurement) => {
+      this.removeMeasurementFromScene(measurement);
+    });
+    this.measurements = [];
+    this.dispatchEvent({
+      type: "measurementsCleared",
+      count
+    });
+  }
+  /**
+   * Get all measurements
+   */
+  getMeasurements() {
+    return [...this.measurements];
+  }
+  /**
+   * Convert a MeasurementPoint to serializable data
+   */
+  serializeMeasurementPoint(point) {
+    return {
+      position: point.position.toArray(),
+      anchorObjectId: point.anchor?.object.uuid,
+      anchorLocalPosition: point.anchor ? point.anchor.localPosition.toArray() : void 0
+    };
+  }
+  /**
+   * Serialize measurements to JSON-compatible format
+   * Note: Dynamic measurements will lose their object references and become static when deserialized
+   */
+  serialize() {
+    return this.measurements.map((measurement) => ({
+      id: measurement.id,
+      start: this.serializeMeasurementPoint(measurement.start),
+      end: this.serializeMeasurementPoint(measurement.end),
+      distance: measurement.distance,
+      options: {
+        snapMode: measurement.options.snapMode,
+        snapEnabled: measurement.options.snapEnabled,
+        snapDistance: measurement.options.snapDistance,
+        lineColor: measurement.options.lineColor,
+        labelColor: measurement.options.labelColor,
+        lineWidth: measurement.options.lineWidth,
+        fontSize: measurement.options.fontSize,
+        fontFamily: measurement.options.fontFamily,
+        isDynamic: measurement.options.isDynamic,
+        targetObjectIds: measurement.options.targets.map((obj) => obj.uuid)
+      }
+    }));
+  }
+  /**
+   * Deserialize measurements from JSON data
+   * Note: Dynamic measurements become static since object references are lost
+   */
+  deserialize(data) {
+    this.clearAll();
+    data.forEach((item) => {
+      const start = new THREE.Vector3().fromArray(item.start.position);
+      const end = new THREE.Vector3().fromArray(item.end.position);
+      const startObject = item.start.anchorObjectId ? this.scene.getObjectByProperty(
+        "uuid",
+        item.start.anchorObjectId
+      ) : null;
+      const endObject = item.end.anchorObjectId ? this.scene.getObjectByProperty(
+        "uuid",
+        item.end.anchorObjectId
+      ) : null;
+      const restoredTargets = item.options.targetObjectIds && item.options.targetObjectIds.length > 0 ? item.options.targetObjectIds.map((uuid) => this.scene.getObjectByProperty("uuid", uuid)).filter((obj) => obj !== void 0) : void 0;
+      this.addMeasurement(start, end, {
+        id: item.id,
+        targets: restoredTargets && restoredTargets.length > 0 ? restoredTargets : void 0,
+        snapMode: item.options.snapMode,
+        snapEnabled: item.options.snapEnabled,
+        snapDistance: item.options.snapDistance,
+        lineColor: item.options.lineColor,
+        labelColor: item.options.labelColor,
+        lineWidth: item.options.lineWidth,
+        fontSize: item.options.fontSize,
+        fontFamily: item.options.fontFamily,
+        isDynamic: item.options.isDynamic,
+        startObject: startObject || void 0,
+        startLocalPosition: item.start.anchorLocalPosition ? new THREE.Vector3().fromArray(item.start.anchorLocalPosition) : void 0,
+        endObject: endObject || void 0,
+        endLocalPosition: item.end.anchorLocalPosition ? new THREE.Vector3().fromArray(item.end.anchorLocalPosition) : void 0
+      });
+    });
+  }
+  /**
+   * Dispose of all resources
+   */
+  dispose() {
+    this.exitEditMode();
+    this.disableInteraction();
+    this.clearAll();
+    this.previewMaterial.dispose();
+    if (this.markerMaterial.map) {
+      this.markerMaterial.map.dispose();
+    }
+    this.markerMaterial.dispose();
+    if (this.editSpriteMaterial) {
+      if (this.editSpriteMaterial.map) {
+        this.editSpriteMaterial.map.dispose();
+      }
+      this.editSpriteMaterial.dispose();
+    }
+  }
+  hideCursor() {
+    if (!this.domElement || this.cursorHidden) return;
+    this.originalCursor = this.domElement.style.cursor;
+    this.domElement.style.cursor = "none";
+    this.cursorHidden = true;
+  }
+  showCursor() {
+    if (!this.domElement || !this.cursorHidden) return;
+    this.domElement.style.cursor = this.originalCursor || "crosshair";
+    this.cursorHidden = false;
+  }
+  createSnapMarker() {
+    if (!this.markerVisible) return;
+    if (this.snapMarker) {
+      this.scene.remove(this.snapMarker);
+    }
+    this.snapMarker = new THREE.Sprite(this.markerMaterial);
+    this.snapMarker.scale.setScalar(this.markerSize);
+    this.snapMarker.visible = false;
+    this.snapMarker.renderOrder = 999;
+    this.snapMarker.material.depthTest = false;
+    this.scene.add(this.snapMarker);
+  }
+  updateSnapMarker(point, visible = true) {
+    if (!this.snapMarker || !this.markerVisible) return;
+    this.snapMarker.position.copy(point);
+    this.snapMarker.visible = visible;
+  }
+  hideSnapMarker() {
+    if (this.snapMarker) {
+      this.snapMarker.visible = false;
+    }
+  }
+  removeSnapMarker() {
+    if (this.snapMarker) {
+      this.scene.remove(this.snapMarker);
+      this.snapMarker = null;
+    }
+  }
+  startMeasurement(snapResult) {
+    const id = this.generateId();
+    const point = snapResult.point;
+    const baseOptions = this.activeInteractionOptions ?? this.defaultOptions;
+    const measurementOptions = {
+      ...baseOptions,
+      targets: [...baseOptions.targets]
+    };
+    this.pendingMeasurementOptions = measurementOptions;
+    this.hideSnapMarker();
+    const geometry = new THREE.BufferGeometry().setFromPoints([point, point]);
+    this.previewLine = new THREE.Line(geometry, this.previewMaterial);
+    this.previewLine.computeLineDistances();
+    this.scene.add(this.previewLine);
+    this.previewLabel = this.createLabel(0, measurementOptions);
+    this.previewLabel.position.copy(point);
+    this.scene.add(this.previewLabel);
+    const startPoint = measurementOptions.isDynamic && snapResult.object ? this.createMeasurementPoint(point, snapResult.object) : this.createMeasurementPoint(point);
+    this.currentMeasurement = {
+      id,
+      start: startPoint
+    };
+  }
+  updatePreview(point) {
+    if (!this.currentMeasurement || !this.previewLine || !this.previewLabel)
+      return;
+    const start = this.currentMeasurement.start;
+    const distance = start.position.distanceTo(point);
+    const geometry = new THREE.BufferGeometry().setFromPoints([
+      start.position,
+      point
+    ]);
+    this.previewLine.geometry.dispose();
+    this.previewLine.geometry = geometry;
+    this.previewLine.computeLineDistances();
+    const midpoint = start.position.clone().add(point).multiplyScalar(0.5);
+    this.previewLabel.position.copy(midpoint);
+    this.updateLabelText(this.previewLabel.element, distance);
+    this.dispatchEvent({
+      type: "previewUpdated",
+      start: start.position,
+      current: point,
+      distance
+    });
+  }
+  completeMeasurement(snapResult) {
+    if (!this.currentMeasurement) return;
+    const start = this.currentMeasurement.start;
+    const point = snapResult.point;
+    const options = this.pendingMeasurementOptions ?? this.activeInteractionOptions ?? this.defaultOptions;
+    this.disableInteraction();
+    this.cleanupPreview();
+    const resolvedOptions = {
+      ...options,
+      targets: [...options.targets]
+    };
+    const endPoint = resolvedOptions.isDynamic && snapResult.object ? this.createMeasurementPoint(point, snapResult.object) : this.createMeasurementPoint(point);
+    this.addMeasurementFromPoints(start, endPoint, resolvedOptions);
+    this.currentMeasurement = null;
+    this.pendingMeasurementOptions = null;
+    this.createSnapMarker();
+  }
+  cancelCurrentMeasurement() {
+    this.cleanupPreview();
+    this.currentMeasurement = null;
+    this.pendingMeasurementOptions = null;
+    this.createSnapMarker();
+  }
+  cleanupPreview() {
+    if (this.previewLine) {
+      this.scene.remove(this.previewLine);
+      this.previewLine.geometry.dispose();
+      this.previewLine = null;
+    }
+    if (this.previewLabel) {
+      this.scene.remove(this.previewLabel);
+      if (this.previewLabel.element.parentNode) {
+        this.previewLabel.element.parentNode.removeChild(
+          this.previewLabel.element
+        );
+      }
+      this.previewLabel = null;
+    }
+  }
+  getSnapResult(event) {
+    const mouse = new THREE.Vector2();
+    const rect = this.domElement.getBoundingClientRect();
+    mouse.x = (event.clientX - rect.left) / rect.width * 2 - 1;
+    mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+    const options = this.getActiveMeasurementOptions() ?? this.defaultOptions;
+    const targets = this.activeTargets.length > 0 ? this.activeTargets : options.targets.length > 0 ? options.targets : this.getAllMeshes();
+    this.raycaster.setFromCamera(mouse, this.camera);
+    const intersects = this.raycaster.intersectObjects(targets, true);
+    if (intersects.length === 0) return null;
+    const intersection = intersects[0];
+    let snapPoint = intersection.point.clone();
+    let snapped = false;
+    let snapMode = "disabled" /* DISABLED */;
+    if (options.snapEnabled) {
+      const snapResult = this.performSnapping(intersection, options);
+      snapPoint = snapResult.point;
+      snapped = snapResult.snapped;
+      snapMode = snapResult.snapMode;
+    }
+    return {
+      point: snapPoint,
+      originalPoint: intersection.point,
+      snapped,
+      snapMode,
+      object: intersection.object
+    };
+  }
+  performSnapping(intersection, options) {
+    const originalPoint = intersection.point;
+    let snapPoint = originalPoint.clone();
+    let snapped = false;
+    let snapMode = "disabled" /* DISABLED */;
+    if (options.snapMode === "vertex" /* VERTEX */) {
+      const vertexSnap = this.snapToVertex(intersection, options.snapDistance);
+      if (vertexSnap) {
+        snapPoint = vertexSnap;
+        snapped = true;
+        snapMode = "vertex" /* VERTEX */;
+      }
+    } else if (options.snapMode === "face" /* FACE */) {
+      snapped = true;
+      snapMode = "face" /* FACE */;
+    }
+    return {
+      point: snapPoint,
+      originalPoint,
+      snapped,
+      snapMode,
+      object: intersection.object
+    };
+  }
+  snapToVertex(intersection, snapDistance) {
+    const geometry = intersection.object.geometry;
+    if (!geometry.attributes.position) return null;
+    const positions = geometry.attributes.position;
+    const worldMatrix = intersection.object.matrixWorld;
+    const closestVertex = new THREE.Vector3();
+    let minDistance = Infinity;
+    let found = false;
+    for (let i = 0; i < positions.count; i++) {
+      const vertex = new THREE.Vector3();
+      vertex.fromBufferAttribute(positions, i);
+      vertex.applyMatrix4(worldMatrix);
+      const distance = vertex.distanceTo(intersection.point);
+      if (distance < snapDistance && distance < minDistance) {
+        minDistance = distance;
+        closestVertex.copy(vertex);
+        found = true;
+      }
+    }
+    return found ? closestVertex : null;
+  }
+  createLabel(distance, options) {
+    const labelDiv = document.createElement("div");
+    labelDiv.className = "measurement-label";
+    Object.assign(labelDiv.style, {
+      color: options.labelColor,
+      fontSize: `${options.fontSize}px`,
+      fontFamily: options.fontFamily,
+      fontWeight: "bold",
+      background: "rgba(0, 0, 0, 0.9)",
+      padding: "8px 12px",
+      borderRadius: "8px",
+      border: "2px solid rgba(255, 255, 255, 0.3)",
+      whiteSpace: "nowrap",
+      userSelect: "none",
+      pointerEvents: "auto",
+      // Enable pointer events for double-click
+      boxShadow: "0 2px 8px rgba(0, 0, 0, 0.5)",
+      textShadow: "1px 1px 2px rgba(0, 0, 0, 0.8)",
+      zIndex: "1000",
+      cursor: "pointer"
+    });
+    this.updateLabelText(labelDiv, distance);
+    const css2dObject = new import_CSS2DRenderer.CSS2DObject(labelDiv);
+    labelDiv.addEventListener("dblclick", (event) => {
+      event.stopPropagation();
+      const measurement = this.measurements.find((m) => m.label === css2dObject);
+      if (measurement) {
+        this.enterEditMode(measurement.id);
+      }
+    });
+    return css2dObject;
+  }
+  updateLabelText(element, distance) {
+    const text = `${distance.toFixed(2)}m`;
+    element.textContent = text;
+  }
+  removeMeasurementFromScene(measurement) {
+    this.scene.remove(measurement.line);
+    this.scene.remove(measurement.label);
+    measurement.line.geometry.dispose();
+    if (measurement.line.material instanceof THREE.Material) {
+      measurement.line.material.dispose();
+    }
+    if (measurement.label.element.parentNode) {
+      measurement.label.element.parentNode.removeChild(
+        measurement.label.element
+      );
+    }
+  }
+  getAllMeshes() {
+    const meshes = [];
+    this.scene.traverse((object) => {
+      if (object instanceof THREE.Mesh) {
+        meshes.push(object);
+      }
+    });
+    return meshes;
+  }
+  generateId() {
+    return `measurement_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  // Edit mode helper methods
+  createEditSprites() {
+    if (!this.editingMeasurement || !this.editSpriteMaterial) return;
+    const measurement = this.editingMeasurement;
+    this.startEditSprite = new THREE.Sprite(this.editSpriteMaterial.clone());
+    this.startEditSprite.position.copy(measurement.start.position);
+    this.startEditSprite.scale.set(this.markerSize, this.markerSize, 1);
+    this.startEditSprite.userData.editPoint = "start";
+    this.scene.add(this.startEditSprite);
+    this.endEditSprite = new THREE.Sprite(this.editSpriteMaterial.clone());
+    this.endEditSprite.position.copy(measurement.end.position);
+    this.endEditSprite.scale.set(this.markerSize, this.markerSize, 1);
+    this.endEditSprite.userData.editPoint = "end";
+    this.scene.add(this.endEditSprite);
+  }
+  removeEditSprites() {
+    if (this.startEditSprite) {
+      this.scene.remove(this.startEditSprite);
+      if (this.startEditSprite.material instanceof THREE.Material) {
+        this.startEditSprite.material.dispose();
+      }
+      this.startEditSprite = null;
+    }
+    if (this.endEditSprite) {
+      this.scene.remove(this.endEditSprite);
+      if (this.endEditSprite.material instanceof THREE.Material) {
+        this.endEditSprite.material.dispose();
+      }
+      this.endEditSprite = null;
+    }
+  }
+  cancelEdit() {
+    this.isDragging = false;
+    this.editingPoint = null;
+    this.enableControls();
+    if (this.startEditSprite) {
+      this.startEditSprite.visible = true;
+    }
+    if (this.endEditSprite) {
+      this.endEditSprite.visible = true;
+    }
+    this.removeSnapMarker();
+    this.showCursor();
+  }
+  updateMeasurementPreview(startPos, endPos) {
+    if (!this.editingMeasurement) return;
+    const distance = startPos.distanceTo(endPos);
+    const positions = [startPos, endPos];
+    this.editingMeasurement.line.geometry.setFromPoints(positions);
+    this.editingMeasurement.line.geometry.attributes.position.needsUpdate = true;
+    const midpoint = startPos.clone().add(endPos).multiplyScalar(0.5);
+    this.editingMeasurement.label.position.copy(midpoint);
+    this.updateLabelText(this.editingMeasurement.label.element, distance);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MeasurementTool,
+  SnapMode
+});
+//# sourceMappingURL=index.cjs.map