@collabdt/core 0.0.42 → 0.0.44

package/dist/core/components/viewers/bim/src/FloorplanTool/index.d.ts

@@ -27,8 +27,26 @@ export declare class FloorplanTool extends OBC.Component {
     /** True-north rotation in degrees (clockwise from default screen-up).
      *  Persists across storey switches but resets to 0 on tool dispose. */
     private _northAngle;
+    /** True while the user is drawing the two-point north line. */
     private _pickingNorth;
     private _pickHandler;
+    private _moveHandler;
+    private _keyHandler;
+    /** First clicked point of the north line, in drawing-local space (Y=0).
+     *  Null until the user places the first point. */
+    private _drawStart;
+    /** Cached snap targets — projected-geometry vertices flattened as
+     *  [x0,z0, x1,z1, …] in drawing-local space. Rebuilt each time draw mode
+     *  starts so it reflects the active storey's lines. */
+    private _snapVerts;
+    /** Rubber-band preview line + cursor snap marker, parented to the active
+     *  drawing so they inherit its world transform. */
+    private _previewLine;
+    private _snapMarker;
+    /** Canvas cursor before draw mode swapped in the crosshair — typically the
+     *  floorplan-mode "grab" hand. Restored (not cleared) on exit so panning
+     *  keeps the hand; only leaving floorplan mode reverts to the default. */
+    private _savedPickCursor;
     private projector;
     private renderer;
     private camera;
@@ -74,16 +92,57 @@ export declare class FloorplanTool extends OBC.Component {
      *  camera azimuth immediately if a floorplan is currently active so the
      *  view re-orients. */
     setNorthAngle(degrees: number): void;
-    /** Enter line-pick mode. The next click on the canvas raycasts against
-     *  the active drawing's lines; the hit line's bearing becomes the new
-     *  true-north angle. No-op if no floorplan is active. */
+    /** Enter two-point draw mode. The user clicks two points on the active
+     *  floorplan (each snapped to the nearest projected-geometry vertex); the
+     *  bearing of the segment between them becomes the new true-north angle.
+     *  A rubber-band preview + snap marker track the cursor; Esc cancels.
+     *  No-op if no floorplan is active. */
     startPickNorth(): void;
-    /** Exit line-pick mode without applying any rotation. */
+    /** Exit draw mode without applying any rotation. Tears down the canvas
+     *  listeners and removes the rubber-band preview. */
     cancelPickNorth(): void;
-    /** Click handler installed during line-pick mode. Raycasts against the
-     *  active drawing's `LineSegments` and applies the hit line's bearing
-     *  (clockwise from local north) as the new true-north angle. */
+    /** Click handler for draw mode. First click places the start point; the
+     *  second rotates the view so the drawn segment becomes parallel to the
+     *  screen X-axis (horizontal). Both points lie on the drawing's horizontal
+     *  plane (Y=0), so only the in-plane direction matters. */
     private _onPickClick;
+    /** Camera azimuth (degrees) that rotates the top-down view so the world
+     *  segment a→b lands parallel to the screen X-axis (horizontal).
+     *
+     *  Derivation: with the standard Y-up spherical convention camera-controls
+     *  uses, the camera's screen-right world direction has angle ρ = −θ + C
+     *  (θ = azimuth). We measure ρ₀ and θ₀ from the live camera so C cancels —
+     *  making the result independent of the drawing's orientation and the
+     *  controls' up-space. We then solve ρ(θ) = λ (the segment's world angle),
+     *  giving θ = ρ₀ + θ₀ − λ. Returns null if the controls are unavailable. */
+    private _azimuthToAlignLineToX;
+    /** Mousemove handler for draw mode — keeps the snap marker (and, after the
+     *  first click, the rubber-band line) glued to the cursor's snapped point. */
+    private _onPickMove;
+    /** Convert a canvas mouse event into a point on the drawing plane, in
+     *  drawing-local space (XZ plane, Y=0). Casts a ray from the active camera,
+     *  transforms it into the drawing's local frame, and intersects Y=0. */
+    private _eventToLocalPoint;
+    /** Snap a drawing-local point to the nearest projected-geometry vertex
+     *  within the snap radius; returns the point unchanged if none is close. */
+    private _snap;
+    /** Snap radius in drawing-local units (= world units; the drawing is
+     *  unscaled), derived from a fixed ~12 px tolerance at the current ortho
+     *  zoom so it feels consistent as the user zooms. */
+    private _snapRadiusLocal;
+    /** Flatten every visible projected line vertex into drawing-local [x,z]
+     *  pairs for endpoint snapping. Each vertex is transformed through its
+     *  owning object's world matrix into the drawing's local frame, so it
+     *  works regardless of how layers nest the `LineSegments`. */
+    private _collectSnapVertices;
+    /** Update (creating on first use) the cursor snap marker and, once the
+     *  first point is placed, the rubber-band line from start → cursor. Both
+     *  live in drawing-local space, Y=0. */
+    private _updatePreview;
+    /** Remove + dispose the preview line and snap marker. Uses each object's
+     *  own parent so it stays correct even when called from deactivate(),
+     *  where `_activeId` is already null. */
+    private _clearPreview;
     /** Push `_northAngle` into the camera-controls azimuth so the view
      *  rotates around the active floor's centre. Called on every activate
      *  and whenever the angle changes while a floorplan is active. */

package/dist/core/components/viewers/bim/src/FloorplanTool/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/components/viewers/bim/src/FloorplanTool/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/components/viewers/bim/src/FloorplanTool/index.ts"],"names":[],"mappings":"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"}

package/dist/core/components/viewers/bim/src/FloorplanTool/index.js

@@ -53,8 +53,26 @@ const _FloorplanTool = class _FloorplanTool extends OBC.Component {
     /** True-north rotation in degrees (clockwise from default screen-up).
      *  Persists across storey switches but resets to 0 on tool dispose. */
     this._northAngle = 0;
+    /** True while the user is drawing the two-point north line. */
     this._pickingNorth = false;
     this._pickHandler = null;
+    this._moveHandler = null;
+    this._keyHandler = null;
+    /** First clicked point of the north line, in drawing-local space (Y=0).
+     *  Null until the user places the first point. */
+    this._drawStart = null;
+    /** Cached snap targets — projected-geometry vertices flattened as
+     *  [x0,z0, x1,z1, …] in drawing-local space. Rebuilt each time draw mode
+     *  starts so it reflects the active storey's lines. */
+    this._snapVerts = null;
+    /** Rubber-band preview line + cursor snap marker, parented to the active
+     *  drawing so they inherit its world transform. */
+    this._previewLine = null;
+    this._snapMarker = null;
+    /** Canvas cursor before draw mode swapped in the crosshair — typically the
+     *  floorplan-mode "grab" hand. Restored (not cleared) on exit so panning
+     *  keeps the hand; only leaving floorplan mode reverts to the default. */
+    this._savedPickCursor = null;
     components.add(_FloorplanTool.uuid, this);
     this.projector = new StoreyProjector(components);
     this.renderer = new FloorplanRenderer(components, this.projector);
@@ -222,61 +240,275 @@ const _FloorplanTool = class _FloorplanTool extends OBC.Component {
     this.onNorthAngleChanged.trigger(normalized);
     if (this._activeId) this._applyNorthToCamera();
   }
-  /** Enter line-pick mode. The next click on the canvas raycasts against
-   *  the active drawing's lines; the hit line's bearing becomes the new
-   *  true-north angle. No-op if no floorplan is active. */
+  /** Enter two-point draw mode. The user clicks two points on the active
+   *  floorplan (each snapped to the nearest projected-geometry vertex); the
+   *  bearing of the segment between them becomes the new true-north angle.
+   *  A rubber-band preview + snap marker track the cursor; Esc cancels.
+   *  No-op if no floorplan is active. */
   startPickNorth() {
     if (this._pickingNorth || !this._activeId) return;
+    const entry = this.activeDrawing;
     const world = this.components.get(CurrentWorld).world;
-    if (!(world == null ? void 0 : world.renderer)) return;
+    if (!(entry == null ? void 0 : entry.drawing) || !(world == null ? void 0 : world.renderer)) return;
     const canvas = world.renderer.three.domElement;
+    this._drawStart = null;
+    this._snapVerts = this._collectSnapVertices(entry);
     this._pickHandler = (e) => this._onPickClick(e);
+    this._moveHandler = (e) => this._onPickMove(e);
+    this._keyHandler = (e) => {
+      if (e.key === "Escape") this.cancelPickNorth();
+    };
     canvas.addEventListener("click", this._pickHandler);
+    canvas.addEventListener("mousemove", this._moveHandler);
+    window.addEventListener("keydown", this._keyHandler);
+    this._savedPickCursor = canvas.style.cursor;
     canvas.style.cursor = "crosshair";
     this._pickingNorth = true;
     this.onPickingNorthChanged.trigger(true);
   }
-  /** Exit line-pick mode without applying any rotation. */
+  /** Exit draw mode without applying any rotation. Tears down the canvas
+   *  listeners and removes the rubber-band preview. */
   cancelPickNorth() {
-    var _a, _b;
+    var _a, _b, _c;
     if (!this._pickingNorth) return;
     const world = this.components.get(CurrentWorld).world;
     const canvas = (_b = (_a = world == null ? void 0 : world.renderer) == null ? void 0 : _a.three.domElement) != null ? _b : null;
-    if (canvas && this._pickHandler) {
-      canvas.removeEventListener("click", this._pickHandler);
-      canvas.style.cursor = "";
+    if (canvas) {
+      if (this._pickHandler) canvas.removeEventListener("click", this._pickHandler);
+      if (this._moveHandler) canvas.removeEventListener("mousemove", this._moveHandler);
+      canvas.style.cursor = (_c = this._savedPickCursor) != null ? _c : "grab";
     }
+    this._savedPickCursor = null;
+    if (this._keyHandler) window.removeEventListener("keydown", this._keyHandler);
     this._pickHandler = null;
+    this._moveHandler = null;
+    this._keyHandler = null;
+    this._drawStart = null;
+    this._snapVerts = null;
+    this._clearPreview();
     this._pickingNorth = false;
     this.onPickingNorthChanged.trigger(false);
   }
-  /** Click handler installed during line-pick mode. Raycasts against the
-   *  active drawing's `LineSegments` and applies the hit line's bearing
-   *  (clockwise from local north) as the new true-north angle. */
+  /** Click handler for draw mode. First click places the start point; the
+   *  second rotates the view so the drawn segment becomes parallel to the
+   *  screen X-axis (horizontal). Both points lie on the drawing's horizontal
+   *  plane (Y=0), so only the in-plane direction matters. */
   _onPickClick(event) {
     const entry = this.activeDrawing;
     if (!(entry == null ? void 0 : entry.drawing)) return;
+    const local = this._eventToLocalPoint(event, entry);
+    if (!local) return;
+    const point = this._snap(local);
+    if (!this._drawStart) {
+      this._drawStart = point;
+      this._updatePreview(entry, point);
+      this._requestUpdate();
+      return;
+    }
+    const dx = point.x - this._drawStart.x;
+    const dz = point.z - this._drawStart.z;
+    if (dx * dx + dz * dz < 1e-6) return;
+    const drawing = entry.drawing;
+    drawing.three.updateWorldMatrix(true, false);
+    const aWorld = drawing.three.localToWorld(this._drawStart.clone());
+    const bWorld = drawing.three.localToWorld(point.clone());
+    const azimuthDeg = this._azimuthToAlignLineToX(aWorld, bWorld);
+    if (azimuthDeg !== null) this.setNorthAngle(azimuthDeg);
+    this.cancelPickNorth();
+  }
+  /** Camera azimuth (degrees) that rotates the top-down view so the world
+   *  segment a→b lands parallel to the screen X-axis (horizontal).
+   *
+   *  Derivation: with the standard Y-up spherical convention camera-controls
+   *  uses, the camera's screen-right world direction has angle ρ = −θ + C
+   *  (θ = azimuth). We measure ρ₀ and θ₀ from the live camera so C cancels —
+   *  making the result independent of the drawing's orientation and the
+   *  controls' up-space. We then solve ρ(θ) = λ (the segment's world angle),
+   *  giving θ = ρ₀ + θ₀ − λ. Returns null if the controls are unavailable. */
+  _azimuthToAlignLineToX(aWorld, bWorld) {
+    var _a, _b;
+    const world = this.components.get(CurrentWorld).world;
+    const cam = (_a = world == null ? void 0 : world.camera) == null ? void 0 : _a.three;
+    const controls = (_b = world == null ? void 0 : world.camera) == null ? void 0 : _b.controls;
+    if (!cam || typeof (controls == null ? void 0 : controls.azimuthAngle) !== "number") return null;
+    const lx = bWorld.x - aWorld.x;
+    const lz = bWorld.z - aWorld.z;
+    if (lx * lx + lz * lz < 1e-12) return null;
+    const lambda = Math.atan2(lz, lx);
+    cam.updateMatrixWorld();
+    const e = cam.matrixWorld.elements;
+    const rho0 = Math.atan2(e[2], e[0]);
+    const theta0 = controls.azimuthAngle;
+    return (rho0 + theta0 - lambda) * 180 / Math.PI;
+  }
+  /** Mousemove handler for draw mode — keeps the snap marker (and, after the
+   *  first click, the rubber-band line) glued to the cursor's snapped point. */
+  _onPickMove(event) {
+    const entry = this.activeDrawing;
+    if (!(entry == null ? void 0 : entry.drawing)) return;
+    const local = this._eventToLocalPoint(event, entry);
+    if (!local) return;
+    this._updatePreview(entry, this._snap(local));
+    this._requestUpdate();
+  }
+  /** Convert a canvas mouse event into a point on the drawing plane, in
+   *  drawing-local space (XZ plane, Y=0). Casts a ray from the active camera,
+   *  transforms it into the drawing's local frame, and intersects Y=0. */
+  _eventToLocalPoint(event, entry) {
     const world = this.components.get(CurrentWorld).world;
-    if (!(world == null ? void 0 : world.renderer) || !(world == null ? void 0 : world.camera)) return;
+    if (!(world == null ? void 0 : world.renderer) || !world.camera || !entry.drawing) return null;
     const canvas = world.renderer.three.domElement;
     const rect = canvas.getBoundingClientRect();
     const x = (event.clientX - rect.left) / rect.width * 2 - 1;
     const y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
     const raycaster = new THREE.Raycaster();
-    raycaster.params.Line.threshold = 0.5;
     raycaster.setFromCamera(
       new THREE.Vector2(x, y),
       world.camera.three
     );
-    const hit = entry.drawing.raycast(raycaster.ray, null);
-    if (!(hit == null ? void 0 : hit.line)) {
+    const drawing = entry.drawing;
+    drawing.three.updateWorldMatrix(true, false);
+    const inv = new THREE.Matrix4().copy(drawing.three.matrixWorld).invert();
+    const origin = raycaster.ray.origin.clone().applyMatrix4(inv);
+    const dir = raycaster.ray.direction.clone().transformDirection(inv);
+    if (Math.abs(dir.y) < 1e-9) return null;
+    const t = -origin.y / dir.y;
+    if (!Number.isFinite(t)) return null;
+    return new THREE.Vector3(
+      origin.x + dir.x * t,
+      0,
+      origin.z + dir.z * t
+    );
+  }
+  /** Snap a drawing-local point to the nearest projected-geometry vertex
+   *  within the snap radius; returns the point unchanged if none is close. */
+  _snap(local) {
+    const verts = this._snapVerts;
+    if (!verts) return local;
+    const radius = this._snapRadiusLocal();
+    let best = -1;
+    let bestD2 = radius * radius;
+    for (let i = 0; i < verts.length; i += 2) {
+      const dx = verts[i] - local.x;
+      const dz = verts[i + 1] - local.z;
+      const d2 = dx * dx + dz * dz;
+      if (d2 < bestD2) {
+        bestD2 = d2;
+        best = i;
+      }
+    }
+    if (best < 0) return local;
+    return new THREE.Vector3(verts[best], 0, verts[best + 1]);
+  }
+  /** Snap radius in drawing-local units (= world units; the drawing is
+   *  unscaled), derived from a fixed ~12 px tolerance at the current ortho
+   *  zoom so it feels consistent as the user zooms. */
+  _snapRadiusLocal() {
+    var _a, _b;
+    const SNAP_PX = 12;
+    const FALLBACK = 0.5;
+    const world = this.components.get(CurrentWorld).world;
+    const cam = (_a = world == null ? void 0 : world.camera) == null ? void 0 : _a.three;
+    const canvas = (_b = world == null ? void 0 : world.renderer) == null ? void 0 : _b.three.domElement;
+    if (!(cam == null ? void 0 : cam.isOrthographicCamera) || !canvas) return FALLBACK;
+    const worldWidth = (cam.right - cam.left) / (cam.zoom || 1);
+    const worldPerPixel = worldWidth / Math.max(1, canvas.clientWidth);
+    return worldPerPixel * SNAP_PX || FALLBACK;
+  }
+  /** Flatten every visible projected line vertex into drawing-local [x,z]
+   *  pairs for endpoint snapping. Each vertex is transformed through its
+   *  owning object's world matrix into the drawing's local frame, so it
+   *  works regardless of how layers nest the `LineSegments`. */
+  _collectSnapVertices(entry) {
+    const drawing = entry.drawing;
+    if (!drawing) return null;
+    drawing.three.updateWorldMatrix(true, true);
+    const inv = new THREE.Matrix4().copy(drawing.three.matrixWorld).invert();
+    const v = new THREE.Vector3();
+    const out = [];
+    drawing.three.traverse((child) => {
+      var _a, _b, _c;
+      if (!(child instanceof THREE.LineSegments) || !child.visible) return;
+      if ((_a = child.userData) == null ? void 0 : _a.isDimension) return;
+      const pos = (_c = (_b = child.geometry) == null ? void 0 : _b.attributes) == null ? void 0 : _c.position;
+      if (!pos) return;
+      for (let i = 0; i < pos.count; i++) {
+        v.set(pos.getX(i), pos.getY(i), pos.getZ(i)).applyMatrix4(child.matrixWorld).applyMatrix4(inv);
+        out.push(v.x, v.z);
+      }
+    });
+    return out.length ? new Float32Array(out) : null;
+  }
+  /** Update (creating on first use) the cursor snap marker and, once the
+   *  first point is placed, the rubber-band line from start → cursor. Both
+   *  live in drawing-local space, Y=0. */
+  _updatePreview(entry, current) {
+    const drawing = entry.drawing;
+    if (!drawing) return;
+    const COLOR = 2450411;
+    if (!this._snapMarker) {
+      const geom = new THREE.BufferGeometry();
+      geom.setAttribute(
+        "position",
+        new THREE.Float32BufferAttribute(
+          new Float32Array([-1, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 1]),
+          3
+        )
+      );
+      this._snapMarker = new THREE.LineSegments(
+        geom,
+        new THREE.LineBasicMaterial({ color: COLOR })
+      );
+      this._snapMarker.renderOrder = 999;
+      drawing.three.add(this._snapMarker);
+    }
+    const arm = this._snapRadiusLocal();
+    this._snapMarker.scale.setScalar(arm);
+    this._snapMarker.position.set(current.x, 0, current.z);
+    this._snapMarker.visible = true;
+    if (!this._drawStart) {
+      if (this._previewLine) this._previewLine.visible = false;
       return;
     }
-    const dx = hit.line.end.x - hit.line.start.x;
-    const dz = hit.line.end.z - hit.line.start.z;
-    const bearingDeg = Math.atan2(dx, -dz) * 180 / Math.PI;
-    this.setNorthAngle(bearingDeg);
-    this.cancelPickNorth();
+    if (!this._previewLine) {
+      const geom = new THREE.BufferGeometry();
+      geom.setAttribute(
+        "position",
+        new THREE.Float32BufferAttribute(new Float32Array(6), 3)
+      );
+      this._previewLine = new THREE.Line(
+        geom,
+        new THREE.LineBasicMaterial({ color: COLOR })
+      );
+      this._previewLine.renderOrder = 999;
+      drawing.three.add(this._previewLine);
+    }
+    const pos = this._previewLine.geometry.attributes.position;
+    pos.setXYZ(0, this._drawStart.x, 0, this._drawStart.z);
+    pos.setXYZ(1, current.x, 0, current.z);
+    pos.needsUpdate = true;
+    this._previewLine.visible = true;
+  }
+  /** Remove + dispose the preview line and snap marker. Uses each object's
+   *  own parent so it stays correct even when called from deactivate(),
+   *  where `_activeId` is already null. */
+  _clearPreview() {
+    var _a, _b;
+    if (this._previewLine) {
+      (_a = this._previewLine.parent) == null ? void 0 : _a.remove(this._previewLine);
+      this._previewLine.geometry.dispose();
+      const m = this._previewLine.material;
+      if (!Array.isArray(m)) m.dispose();
+      this._previewLine = null;
+    }
+    if (this._snapMarker) {
+      (_b = this._snapMarker.parent) == null ? void 0 : _b.remove(this._snapMarker);
+      this._snapMarker.geometry.dispose();
+      const m = this._snapMarker.material;
+      if (!Array.isArray(m)) m.dispose();
+      this._snapMarker = null;
+    }
+    this._requestUpdate();
   }
   /** Push `_northAngle` into the camera-controls azimuth so the view
    *  rotates around the active floor's centre. Called on every activate