@realsee/dnalogel 3.81.22 → 3.81.24

package/libs/MeasurePluginV2/PointOverlay.js

@@ -1,5 +1,5 @@
-import * as m from "three";
-const l = {
+import * as L from "three";
+const p = {
   /** M1-2 X 轴颜色 */
   axisXColor: "#EC4A4E",
   /** M1-2 Y 轴颜色 */
@@ -24,115 +24,137 @@ const l = {
   planeSideRadiusScale: 1.2,
   /** M2 轴对齐判定：表面法线与最近世界轴的夹角小于该值即视为墙 / 地 / 顶 */
   axisSnapAngle: 15
-}, f = [new m.Vector3(1, 0, 0), new m.Vector3(0, 1, 0), new m.Vector3(0, 0, 1)], v = [l.axisXColor, l.axisYColor, l.axisZColor];
-function y(n, e) {
-  const t = n.clone().project(e.camera), o = (t.x + 1) / 2 * e.renderSize.x, i = (t.y + 1) / 2 * e.renderSize.y;
+}, C = [new L.Vector3(1, 0, 0), new L.Vector3(0, 1, 0), new L.Vector3(0, 0, 1)], D = [p.axisXColor, p.axisYColor, p.axisZColor];
+function f(o, n) {
+  const e = o.clone().project(n.camera), t = (e.x + 1) / 2 * n.renderSize.x, i = (e.y + 1) / 2 * n.renderSize.y;
   return {
-    x: (o - e.readLeft) * e.pixelRadio,
+    x: (t - n.readLeft) * n.pixelRadio,
     // 读出来的像素做过 Y 翻转（canvas 与渲染目标 Y 轴相反），所以要从读取区域的底边往回收
-    y: (e.readTop + e.readPixelsHeight - i) * e.pixelRadio
+    y: (n.readTop + n.readPixelsHeight - i) * n.pixelRadio
   };
 }
-function R(n) {
-  const e = n.face;
-  if (!(e != null && e.normal))
+function N(o) {
+  const n = o.face;
+  if (!(n != null && n.normal))
     return null;
-  const t = e.normal.clone();
-  return t.lengthSq() < 1e-12 ? null : t.normalize();
+  const e = n.normal.clone();
+  return e.lengthSq() < 1e-12 ? null : e.normalize();
 }
-function T(n) {
-  const e = n.clone().normalize();
-  let t = 0, o = 0;
-  f.forEach((x, d) => {
-    const u = Math.abs(e.dot(x));
-    u > o && (o = u, t = d);
+function O(o) {
+  const n = o.clone().normalize();
+  let e = 0, t = 0;
+  C.forEach((h, r) => {
+    const c = Math.abs(n.dot(h));
+    c > t && (t = c, e = r);
   });
-  const i = Math.cos(m.MathUtils.degToRad(l.axisSnapAngle));
-  if (o < i)
-    return { normal: e, alignedAxisIndex: -1 };
-  const c = f[t], r = e.dot(c) >= 0 ? 1 : -1;
-  return { normal: c.clone().multiplyScalar(r), alignedAxisIndex: t };
+  const i = Math.cos(L.MathUtils.degToRad(p.axisSnapAngle));
+  if (t < i)
+    return { normal: n, alignedAxisIndex: -1 };
+  const x = C[e], s = n.dot(x) >= 0 ? 1 : -1;
+  return { normal: x.clone().multiplyScalar(s), alignedAxisIndex: e };
 }
-function M(n) {
-  const e = T(n), t = e.normal, o = t.clone().multiplyScalar(t.dot(f[1]));
-  let i = f[1].clone().sub(o);
-  i.lengthSq() < 1e-8 && (i = f[2].clone().sub(t.clone().multiplyScalar(t.dot(f[2])))), i.normalize();
-  const c = new m.Vector3().crossVectors(i, t).normalize();
-  return { normal: t, xAxis: c, yAxis: i, alignedAxisIndex: e.alignedAxisIndex };
+function W(o) {
+  const n = O(o), e = n.normal, t = e.clone().multiplyScalar(e.dot(C[1]));
+  let i = C[1].clone().sub(t);
+  i.lengthSq() < 1e-8 && (i = C[2].clone().sub(e.clone().multiplyScalar(e.dot(C[2])))), i.normalize();
+  const x = new L.Vector3().crossVectors(i, e).normalize();
+  return { normal: e, xAxis: x, yAxis: i, alignedAxisIndex: n.alignedAxisIndex };
 }
-function W(n, e) {
-  return Math.max(1e-4, e.position.distanceTo(n) * 0.01);
+function E(o, n) {
+  return Math.max(1e-4, n.position.distanceTo(o) * 0.01);
 }
-function L(n, e) {
-  const t = y(n.point, n.viewport), o = y(n.point.clone().addScaledVector(e, n.probeLength), n.viewport);
-  return { x: o.x - t.x, y: o.y - t.y };
+function I(o, n) {
+  const e = f(o.point, o.viewport), t = f(o.point.clone().addScaledVector(n, o.probeLength), o.viewport);
+  return { x: t.x - e.x, y: t.y - e.y };
 }
-function A(n, e, t) {
-  const o = L(n, e), i = Math.hypot(o.x, o.y);
-  if (!Number.isFinite(i) || i < 1e-6)
+const M = 0.8, V = 3;
+function F(o, n, e) {
+  const { point: t, viewport: i } = o, x = f(t, i), s = (b) => {
+    const a = f(t.clone().addScaledVector(n, b), i);
+    return Math.hypot(a.x - x.x, a.y - x.y);
+  }, h = i.camera.matrixWorldInverse, r = -t.clone().applyMatrix4(h).z;
+  if (!(r > 0))
     return 0;
-  const c = y(n.point, n.viewport);
-  let r = t / i * n.probeLength;
-  for (let x = 0; x < 2; x += 1) {
-    const d = y(n.point.clone().addScaledVector(e, r), n.viewport), u = Math.hypot(d.x - c.x, d.y - c.y);
-    if (!Number.isFinite(u) || u < 1e-6)
-      break;
-    r *= t / u;
+  const c = -t.clone().add(n).applyMatrix4(h).z - r;
+  let m = 1 / 0;
+  c < -1e-9 ? m = r * M / -c : c > 1e-9 && (m = r * V / c);
+  let d = m;
+  if (!Number.isFinite(d))
+    for (d = o.probeLength; s(d) < e && d < r * V; )
+      d *= 2;
+  if (!(s(d) > e))
+    return Number.isFinite(s(d)) ? d : 0;
+  let A = 0;
+  for (let b = 0; b < 24; b += 1) {
+    const a = (A + d) / 2;
+    s(a) < e ? A = a : d = a;
   }
-  return r;
+  return (A + d) / 2;
 }
-function E(n, e) {
-  const { context: t, viewport: o, point: i } = n, r = Math.min(o.canvasWidth, o.canvasHeight) / 2 * l.planeSideRadiusScale / 2, x = A(n, e.xAxis, r), d = A(n, e.yAxis, r);
-  if (!(x > 0) || !(d > 0))
+function w([o, n, e, t]) {
+  const i = (s, h, r) => (h.x - s.x) * (r.y - s.y) - (h.y - s.y) * (r.x - s.x), x = (s, h, r, c) => i(r, c, s) * i(r, c, h) < 0 && i(s, h, r) * i(s, h, c) < 0;
+  return x(o, n, e, t) || x(n, e, t, o);
+}
+function _(o, n) {
+  var R;
+  const { context: e, viewport: t, point: i } = o, s = Math.min(t.canvasWidth, t.canvasHeight) / 2 * p.planeSideRadiusScale / 2, h = n.xAxis.clone().negate(), r = n.yAxis.clone().negate(), c = F(o, n.xAxis, s), m = F(o, h, s), d = F(o, n.yAxis, s), A = F(o, r, s);
+  if (!(c > 0) || !(m > 0) || !(d > 0) || !(A > 0))
     return;
-  const u = [
-    i.clone().addScaledVector(e.xAxis, x).addScaledVector(e.yAxis, d),
-    i.clone().addScaledVector(e.xAxis, -x).addScaledVector(e.yAxis, d),
-    i.clone().addScaledVector(e.xAxis, -x).addScaledVector(e.yAxis, -d),
-    i.clone().addScaledVector(e.xAxis, x).addScaledVector(e.yAxis, -d)
-  ].map((p) => y(p, o));
-  u.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y)) || (t.save(), t.beginPath(), u.forEach((p, b) => {
-    b === 0 ? t.moveTo(p.x, p.y) : t.lineTo(p.x, p.y);
-  }), t.closePath(), t.strokeStyle = l.planeBorderColor, t.globalAlpha = l.planeBorderOpacity, t.lineWidth = l.planeBorderWidth, t.stroke(), t.restore());
+  const b = t.camera.matrixWorldInverse, a = (u) => -u.clone().applyMatrix4(b).z, l = a(i), y = l * (1 - M), S = (u) => {
+    const v = a(u);
+    if (v >= y)
+      return u;
+    const T = (l - y) / (l - v);
+    return i.clone().lerp(u, T);
+  }, g = [
+    i.clone().addScaledVector(n.xAxis, c).addScaledVector(n.yAxis, d),
+    i.clone().addScaledVector(n.xAxis, -m).addScaledVector(n.yAxis, d),
+    i.clone().addScaledVector(n.xAxis, -m).addScaledVector(n.yAxis, -A),
+    i.clone().addScaledVector(n.xAxis, c).addScaledVector(n.yAxis, -A)
+  ].map((u) => f(S(u), t));
+  g.some((u) => !Number.isFinite(u.x) || !Number.isFinite(u.y)) || w(g) || (e.save(), e.beginPath(), g.forEach((u, v) => {
+    v === 0 ? e.moveTo(u.x, u.y) : e.lineTo(u.x, u.y);
+  }), e.closePath(), e.strokeStyle = p.planeBorderColor, e.globalAlpha = p.planeBorderOpacity, e.lineWidth = p.planeBorderWidth * ((R = t.lineScale) != null ? R : 1), e.stroke(), e.restore());
 }
-function O(n, e) {
-  const { context: t, viewport: o, point: i } = n, c = Math.min(o.canvasWidth, o.canvasHeight) / 2, r = c * l.axisLengthRadiusScale, x = c * l.axisTipDotRadiusScale, d = y(i, o);
-  if (!Number.isFinite(d.x) || !Number.isFinite(d.y))
+function P(o, n) {
+  const { context: e, viewport: t, point: i } = o, x = Math.min(t.canvasWidth, t.canvasHeight) / 2, s = x * p.axisLengthRadiusScale, h = x * p.axisTipDotRadiusScale, r = f(i, t);
+  if (!Number.isFinite(r.x) || !Number.isFinite(r.y))
     return;
-  const u = (a) => {
-    const s = L(n, a), h = Math.hypot(s.x, s.y);
-    return !Number.isFinite(h) || h < 1e-3 ? null : { x: s.x / h, y: s.y / h };
-  }, p = (a) => A(n, a, r), b = (a, s, h) => {
-    [a.x, a.y, s.x, s.y].every((S) => Number.isFinite(S)) && (t.strokeStyle = h, t.globalAlpha = l.axisOpacity, t.lineWidth = l.axisLineWidth, t.beginPath(), t.moveTo(a.x, a.y), t.lineTo(s.x, s.y), t.stroke());
-  }, F = (a, s) => {
-    if (!u(a))
+  const c = (a) => {
+    const l = I(o, a), y = Math.hypot(l.x, l.y);
+    return !Number.isFinite(y) || y < 1e-3 ? null : { x: l.x / y, y: l.y / y };
+  }, m = (a) => F(o, a, s), d = (a, l, y) => {
+    var S;
+    [a.x, a.y, l.x, l.y].every((g) => Number.isFinite(g)) && (e.strokeStyle = y, e.globalAlpha = p.axisOpacity, e.lineWidth = p.axisLineWidth * ((S = t.lineScale) != null ? S : 1), e.beginPath(), e.moveTo(a.x, a.y), e.lineTo(l.x, l.y), e.stroke());
+  }, A = (a, l) => {
+    if (!c(a))
       return;
-    const h = a.clone().negate(), S = A(n, a, r), g = A(n, h, r);
+    const y = a.clone().negate(), S = F(o, a, s), g = F(o, y, s);
     if (!(S > 0) || !(g > 0))
       return;
-    const C = y(i.clone().addScaledVector(h, g), o), N = y(i.clone().addScaledVector(a, S), o);
-    b(C, N, s);
-  }, V = (a, s, h) => {
-    if (!u(a))
+    const R = f(i.clone().addScaledVector(y, g), t), u = f(i.clone().addScaledVector(a, S), t);
+    d(R, u, l);
+  }, b = (a, l, y) => {
+    if (!c(a))
       return;
-    const S = p(a);
+    const S = m(a);
     if (!(S > 0))
       return;
-    const g = y(i.clone().addScaledVector(a, S), o);
-    b(d, g, s), h && (!Number.isFinite(g.x) || !Number.isFinite(g.y) || (t.fillStyle = s, t.globalAlpha = l.axisOpacity, t.beginPath(), t.arc(g.x, g.y, x, 0, Math.PI * 2), t.fill()));
+    const g = f(i.clone().addScaledVector(a, S), t);
+    d(r, g, l), y && (!Number.isFinite(g.x) || !Number.isFinite(g.y) || (e.fillStyle = l, e.globalAlpha = p.axisOpacity, e.beginPath(), e.arc(g.x, g.y, h, 0, Math.PI * 2), e.fill()));
   };
-  t.save(), t.lineCap = "round", e ? (F(e.xAxis, l.axisXColor), F(e.yAxis, l.axisYColor), V(e.normal, l.axisZColor, !0)) : f.forEach((a, s) => F(a, v[s])), t.restore();
+  e.save(), e.lineCap = "round", n ? (A(n.xAxis, p.axisXColor), A(n.yAxis, p.axisYColor), b(n.normal, p.axisZColor, !0)) : C.forEach((a, l) => A(a, D[l])), e.restore();
 }
-function w(n, e, t) {
-  const o = t.point;
-  if (!o || !Number.isFinite(o.x) || !Number.isFinite(o.y) || !Number.isFinite(o.z))
+function X(o, n, e) {
+  const t = e.point;
+  if (!t || !Number.isFinite(t.x) || !Number.isFinite(t.y) || !Number.isFinite(t.z))
     return;
-  const i = { context: n, viewport: e, point: o, probeLength: W(o, e.camera) }, c = R(t), r = c ? M(c) : null;
-  r && E(i, r), O(i, r);
+  const i = { context: o, viewport: n, point: t, probeLength: E(t, n.camera) }, x = N(e), s = x ? W(x) : null;
+  s && _(i, s), P(i, s);
 }
 export {
-  l as OVERLAY_STYLE,
-  M as buildPlaneFrame,
-  w as drawMeasureOverlay,
-  R as getWorldNormal
+  p as OVERLAY_STYLE,
+  W as buildPlaneFrame,
+  X as drawMeasureOverlay,
+  N as getWorldNormal
 };

package/libs/MeasurePluginV2/closeupView.d.ts

@@ -0,0 +1,69 @@
+import * as THREE from 'three';
+/**
+ * 放大镜近景视角的取向计算。
+ *
+ * 目标（与 MP 的观感一致）：放大镜不是主视图的简单放大。落点所在表面没有正对相机时，
+ * 视角会朝表面法线偏一点，让斜面 / 侧面在放大镜里以更接近正面的角度呈现；
+ * 同时要保证它始终是「主视图那台相机绕落点转了一点」——不换机位、不翻滚、偏转角有上限。
+ *
+ * 这里只做纯数学，相机怎么临时改、怎么还原由调用方负责。
+ */
+/** 近景相机到落点的距离（米） */
+export declare const CLOSEUP_DISTANCE = 0.6;
+/** 朝表面转正的比例：把「主视线到正对表面」的夹角消掉这么多 */
+export declare const CLOSEUP_NORMAL_BLEND = 0.5;
+/** 近景视角相对主视图的最大偏转角（弧度）。超过就封顶，避免侧视时像换了个机位 */
+export declare const CLOSEUP_MAX_DEVIATION: number;
+/** 判定法线朝向时的滞回区间（点积）：视线接近贴着表面时沿用上一帧朝向，避免来回翻 */
+export declare const CLOSEUP_FLIP_EPSILON = 0.05;
+/** 跨帧状态：目前只用于法线朝向的滞回 */
+export interface CloseupViewState {
+    /** 本帧的视线方向（单位向量） */
+    direction: THREE.Vector3;
+    /** 本帧的落点 */
+    point: THREE.Vector3;
+    /** 本帧法线的朝向：1 = 与传入的法线同向，-1 = 反向，null = 没有法线 */
+    normalSign: 1 | -1 | null;
+}
+export interface CloseupViewOptions {
+    /** 落点（世界坐标） */
+    point: THREE.Vector3;
+    /** 落点所在表面的法线（世界坐标，方向不限）；拿不到时传 null，只推近不偏转 */
+    normal: THREE.Vector3 | null;
+    /** 主相机位置 */
+    cameraPosition: THREE.Vector3;
+    /** 主相机世界四元数；近景姿态由它绕落点做最小旋转得到，因此不会翻滚 */
+    cameraQuaternion: THREE.Quaternion;
+    /** 近景距离，默认 CLOSEUP_DISTANCE；主相机比这更近时保持原距离。translate=false 时忽略 */
+    distance?: number;
+    /**
+     * 是否把相机沿最终视线移动到落点附近。
+     * true = 旧行为（推到 0.6m）；false = 只旋转、不平移，放大镜与主视图共用同一机位，
+     * 不会产生视差，也不会让全景球心偏移导致画面扭曲。
+     */
+    translate?: boolean;
+    /** 朝法线偏转的比例，默认 CLOSEUP_NORMAL_BLEND */
+    blend?: number;
+    /** 最大偏转角（弧度），默认 CLOSEUP_MAX_DEVIATION */
+    maxDeviation?: number;
+    /** 上一帧的状态，只用于法线朝向的滞回；第一帧传 null */
+    previous?: CloseupViewState | null;
+}
+export interface CloseupView {
+    /** 近景相机位置 */
+    position: THREE.Vector3;
+    /** 近景相机视线方向（单位向量） */
+    direction: THREE.Vector3;
+    /** 近景相机世界四元数（视线方向与 direction 一致，roll 由主相机继承） */
+    quaternion: THREE.Quaternion;
+    /** 供下一次调用使用的状态 */
+    state: CloseupViewState;
+}
+/**
+ * 计算近景相机的位姿：
+ * 1. translate=true 时相机落在「落点后方 distance 处、朝向落点」这条线上，落点因此仍在画面正中；
+ *    translate=false 时保持原机位，只改变朝向（放大镜与主视图共用视点，不产生视差）；
+ * 2. 姿态 = 主相机姿态先把视线校正到落点，再朝「正对表面」的方向转一小段（有上限）；
+ * 3. 因为是绕相机的旋转，画面不会翻滚，观感就是「同一台相机微微转了个角度」。
+ */
+export declare function resolveCloseupView(options: CloseupViewOptions): CloseupView | null;

package/libs/MeasurePluginV2/closeupView.js

@@ -0,0 +1,52 @@
+import * as c from "three";
+const z = 0.6, I = 0.5, _ = Math.PI / 6, A = 0.05;
+function Q(n) {
+  var F, b, S, h, D;
+  const { point: e, cameraPosition: t, cameraQuaternion: i } = n;
+  if (!f(e) || !f(t) || !U(i))
+    return null;
+  const s = e.clone().sub(t), a = s.length();
+  if (!Number.isFinite(a) || a < 1e-4)
+    return null;
+  const o = s.clone().divideScalar(a), x = new c.Vector3(0, 0, -1).applyQuaternion(i).normalize(), N = new c.Quaternion().setFromUnitVectors(x, o).multiply(i);
+  N.normalize();
+  const m = (F = n.previous) != null ? F : null;
+  let u = null, r = o.clone();
+  const l = n.normal;
+  if (l && f(l) && l.lengthSq() > 1e-12) {
+    const E = l.clone().normalize();
+    u = C(E, s, (b = m == null ? void 0 : m.normalSign) != null ? b : null);
+    const P = E.clone().multiplyScalar(-u), M = o.angleTo(P), w = p((S = n.blend) != null ? S : I, 0, 1), y = p((h = n.maxDeviation) != null ? h : _, 0, Math.PI), V = Math.min(M * w, y);
+    if (V > 1e-6 && M > 1e-6) {
+      const g = new c.Vector3().crossVectors(o, P);
+      g.lengthSq() > 1e-12 && (r = o.clone().applyAxisAngle(g.normalize(), V));
+    }
+  }
+  const d = new c.Quaternion().setFromUnitVectors(o, r).multiply(N);
+  d.normalize();
+  const L = n.translate !== !1, O = Math.min((D = n.distance) != null ? D : z, a);
+  return {
+    // 只旋转时保持原机位：全景 / 模型都按主视图的同一视点采样，不引入视差
+    position: L ? e.clone().addScaledVector(r, -O) : t.clone(),
+    direction: r,
+    quaternion: d,
+    state: { direction: r.clone(), point: e.clone(), normalSign: u }
+  };
+}
+function C(n, e, t) {
+  const i = n.dot(e);
+  return Math.abs(i) < A && t !== null ? t : i > 0 ? -1 : 1;
+}
+function p(n, e, t) {
+  return Math.min(t, Math.max(e, n));
+}
+function f(n) {
+  return Number.isFinite(n.x) && Number.isFinite(n.y) && Number.isFinite(n.z);
+}
+function U(n) {
+  return Number.isFinite(n.x) && Number.isFinite(n.y) && Number.isFinite(n.z) && Number.isFinite(n.w);
+}
+export {
+  _ as CLOSEUP_MAX_DEVIATION,
+  Q as resolveCloseupView
+};

package/libs/MeasurePluginV2/normalMeasure.d.ts

@@ -0,0 +1,116 @@
+import * as THREE from 'three';
+/**
+ * 双击快速测量：从落点沿所在平面的法线发一条射线，取第一个打到的模型表面作为终点。
+ * 典型场景是双击墙面直接得到墙到对面墙的垂直距离。
+ */
+/** 射线起点离开表面的距离（米），避免射线一出发就打中落点所在的面 */
+export declare const NORMAL_RAY_START_OFFSET = 0.01;
+/** 终点离起点太近（米）视为无效，例如打中了落点旁边的小凸起 */
+export declare const NORMAL_RAY_MIN_DISTANCE = 0.02;
+/** 射线最远距离（米），超过视为没打到 */
+export declare const NORMAL_RAY_MAX_DISTANCE = 100;
+/** 双击判定：两次抬起的最大间隔（毫秒） */
+export declare const DOUBLE_CLICK_INTERVAL = 350;
+/** 双击判定：两次抬起的最大屏幕距离（像素） */
+export declare const DOUBLE_CLICK_MAX_MOVE = 6;
+export interface RaycastHit {
+    point: THREE.Vector3;
+    distance: number;
+    /** 命中面；THREE.Intersection 的 face.normal 已经是世界坐标系法线 */
+    face?: {
+        normal?: THREE.Vector3 | null;
+    } | null;
+}
+/** 法线快速测量的命中结果 */
+export interface NormalMeasureHit {
+    /** 终点 */
+    point: THREE.Vector3;
+    /** 终点所在表面的世界坐标系法线；拿不到时为 null */
+    normal: THREE.Vector3 | null;
+}
+/** 对模型做射线检测，返回按距离排序的命中结果 */
+export type ModelRaycast = (raycaster: THREE.Raycaster) => RaycastHit[];
+/**
+ * 沿法线求快速测量的命中点。
+ * @param point - 起点（双击的落点）
+ * @param normal - 起点所在平面的法线（世界坐标，朝向表面外侧，即朝向相机这一侧）
+ * @returns 命中点及其表面法线；法线无效或没打到模型时返回 null
+ */
+export declare function findNormalMeasureHit(point: THREE.Vector3, normal: THREE.Vector3, raycast: ModelRaycast): NormalMeasureHit | null;
+/** 只要终点时用这个 */
+export declare function findNormalMeasureEnd(point: THREE.Vector3, normal: THREE.Vector3, raycast: ModelRaycast): THREE.Vector3 | null;
+/**
+ * 识别「第二下点在刚打下的点上」的双击。
+ * 只记录上一次抬起的时间和屏幕位置；时间和位置都足够近才算双击，命中后清空，三连击不会触发两次。
+ */
+export declare class DoubleClickDetector {
+    private readonly interval;
+    private readonly maxMove;
+    private last;
+    constructor(interval?: number, maxMove?: number);
+    /** 每次单击抬起时调用；返回 true 表示与上一次构成双击 */
+    hit(x: number, y: number, time: number): boolean;
+    reset(): void;
+}
+/** 双击时第二下离起点的最大屏幕距离（像素）。起点可能被吸附偏离光标几像素，所以比双击判定宽一些 */
+export declare const START_POINT_HIT_RADIUS = 16;
+interface QuickMeasureCamera {
+    position: THREE.Vector3;
+}
+export interface QuickNormalMeasureOptions {
+    /** 当前相机；朝向判断和屏幕投影都用它 */
+    getCamera: () => THREE.Camera & QuickMeasureCamera;
+    /** five 画布，用来把世界坐标换算成屏幕坐标 */
+    getElement: () => HTMLElement | null | undefined;
+    /** 对模型做射线检测 */
+    raycast: ModelRaycast;
+    /** 正在测量的点；不在测量中返回 null */
+    getMeasuringPoints: () => THREE.Vector3[] | null;
+    /**
+     * 打到对面：用起点和终点生成测量。
+     * 返回 true 表示测量会话继续（控制器以终点作为下一段的起点），此时命中面的法线会留作下一段的起始法线。
+     */
+    finish: (start: THREE.Vector3, end: THREE.Vector3) => boolean | void;
+    /** 没打到：撤掉起点，回到未打点状态 */
+    cancelStart: () => void;
+}
+/** 由 PointSelector 的 wantsSelect 事件驱动，返回 false 表示取消这次选点 */
+type WantsSelectHandler = (intersection?: {
+    point?: THREE.Vector3;
+    face?: {
+        normal?: THREE.Vector3 | null;
+    } | null;
+} | null) => boolean | void;
+/**
+ * 双击快速测量（只处理鼠标，触屏不触发）。
+ *
+ * 规则与 MP 一致：
+ * - 第一下单击照常打下起点 A，不延迟；第二下在双击时间内又点在 A 上，就从 A 沿法线测到对面，直接完成这条测量；
+ * - A 已经打下一段时间后，再双击 A 也会快速测量：落在 A 上的单击不会再打一个重合的点；
+ * - 已经开始连线（两个点及以上）时双击按普通单击处理；法线没打到模型时撤掉 A，不生成测量；
+ * - 快速测量完成后不退出选点：控制器以命中点为新一段的起点（finish 返回 true），继续选择下一个点位。
+ */
+export declare class QuickNormalMeasure {
+    private readonly options;
+    private readonly detector;
+    private lastMouseUp;
+    /** 起点 A 所在平面的法线，在打下 A 的那次选点里记下 */
+    private startNormal;
+    private attached;
+    constructor(options: QuickNormalMeasureOptions);
+    attach(pointSelector: {
+        on: (name: 'wantsSelect', callback: WantsSelectHandler) => unknown;
+    }): void;
+    detach(pointSelector: {
+        off: (name: 'wantsSelect', callback: WantsSelectHandler) => unknown;
+    }): void;
+    reset(): void;
+    private onMouseUp;
+    private onWantsSelect;
+    /** 只认刚刚发生的鼠标抬起，用完即清，避免触屏选点误用上一次鼠标的位置 */
+    private consumeMouseUp;
+    private isOnStartPoint;
+    /** 面法线可能朝向表面内侧；射线要往相机这一侧（空的一侧）发 */
+    private orientTowardCamera;
+}
+export {};

package/libs/MeasurePluginV2/normalMeasure.js

@@ -0,0 +1,110 @@
+var f = Object.defineProperty;
+var m = (n, t, e) => t in n ? f(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var a = (n, t, e) => (m(n, typeof t != "symbol" ? t + "" : t, e), e);
+import * as d from "three";
+const p = 0.01, M = 0.02, h = 100, N = 350, S = 6;
+function _(n, t, e) {
+  var l;
+  if (![n.x, n.y, n.z, t.x, t.y, t.z].every(Number.isFinite) || t.lengthSq() < 1e-12)
+    return null;
+  const s = t.clone().normalize(), r = n.clone().addScaledVector(s, p), i = new d.Raycaster(r, s, 0, h);
+  for (const o of e(i)) {
+    if (!(o != null && o.point) || !Number.isFinite(o.distance))
+      continue;
+    if (o.distance > h)
+      break;
+    const c = o.point.clone();
+    if (c.distanceTo(n) < M)
+      continue;
+    const u = (l = o.face) == null ? void 0 : l.normal;
+    return {
+      point: c,
+      normal: u && u.lengthSq() > 1e-12 ? u.clone().normalize() : null
+    };
+  }
+  return null;
+}
+class g {
+  constructor(t = N, e = S) {
+    a(this, "last", null);
+    this.interval = t, this.maxMove = e;
+  }
+  /** 每次单击抬起时调用；返回 true 表示与上一次构成双击 */
+  hit(t, e, s) {
+    const r = this.last;
+    return r && s - r.time <= this.interval && Math.hypot(t - r.x, e - r.y) <= this.maxMove ? (this.last = null, !0) : (this.last = { time: s, x: t, y: e }, !1);
+  }
+  reset() {
+    this.last = null;
+  }
+}
+const C = 16, E = 100;
+class A {
+  constructor(t) {
+    a(this, "detector", new g());
+    a(this, "lastMouseUp", null);
+    /** 起点 A 所在平面的法线，在打下 A 的那次选点里记下 */
+    a(this, "startNormal", null);
+    a(this, "attached", !1);
+    a(this, "onMouseUp", (t) => {
+      t.button === 0 && (this.lastMouseUp = { x: t.clientX, y: t.clientY, time: performance.now() });
+    });
+    a(this, "onWantsSelect", (t) => {
+      const e = this.options.getMeasuringPoints();
+      if (!e)
+        return;
+      const s = this.consumeMouseUp(), r = s ? this.detector.hit(s.x, s.y, s.time) : !1;
+      if (e.length === 0) {
+        this.startNormal = T(t);
+        return;
+      }
+      if (e.length !== 1 || !s)
+        return;
+      const i = e[0];
+      if (!this.isOnStartPoint(i, s))
+        return;
+      if (!r)
+        return !1;
+      const l = this.startNormal ? this.orientTowardCamera(this.startNormal, i) : null, o = l ? _(i, l, this.options.raycast) : null;
+      return this.startNormal = null, o ? (this.options.finish(i, o.point) === !0 && o.normal && (this.startNormal = this.orientTowardCamera(o.normal, o.point)), !1) : (this.options.cancelStart(), !1);
+    });
+    this.options = t;
+  }
+  attach(t) {
+    this.attached || (this.attached = !0, document.addEventListener("mouseup", this.onMouseUp, !0), t.on("wantsSelect", this.onWantsSelect));
+  }
+  detach(t) {
+    this.attached && (this.attached = !1, document.removeEventListener("mouseup", this.onMouseUp, !0), t.off("wantsSelect", this.onWantsSelect), this.reset());
+  }
+  reset() {
+    this.detector.reset(), this.lastMouseUp = null, this.startNormal = null;
+  }
+  /** 只认刚刚发生的鼠标抬起，用完即清，避免触屏选点误用上一次鼠标的位置 */
+  consumeMouseUp() {
+    const t = this.lastMouseUp;
+    return this.lastMouseUp = null, !t || performance.now() - t.time > E ? null : t;
+  }
+  isOnStartPoint(t, e) {
+    const s = this.options.getElement();
+    if (!s)
+      return !1;
+    const r = s.getBoundingClientRect(), i = t.clone().project(this.options.getCamera());
+    if (!Number.isFinite(i.x) || !Number.isFinite(i.y) || i.z > 1)
+      return !1;
+    const l = r.left + (i.x + 1) / 2 * r.width, o = r.top + (1 - i.y) / 2 * r.height;
+    return Math.hypot(l - e.x, o - e.y) <= C;
+  }
+  /** 面法线可能朝向表面内侧；射线要往相机这一侧（空的一侧）发 */
+  orientTowardCamera(t, e) {
+    const s = this.options.getCamera().position.clone().sub(e);
+    return t.dot(s) < 0 ? t.clone().negate() : t.clone();
+  }
+}
+function T(n) {
+  var e;
+  const t = (e = n == null ? void 0 : n.face) == null ? void 0 : e.normal;
+  return !t || t.lengthSq() < 1e-12 ? null : t.clone().normalize();
+}
+export {
+  A as QuickNormalMeasure
+};