@realsee/dnalogel 3.69.12 → 3.69.13-alpha-1

package/libs/shared-utils/Object3DHelper/utils/dashGuide.js

@@ -0,0 +1,123 @@
+var N = Object.defineProperty;
+var C = Object.getOwnPropertySymbols;
+var Q = Object.prototype.hasOwnProperty, X = Object.prototype.propertyIsEnumerable;
+var b = Math.pow, L = (n, t, e) => t in n ? N(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, f = (n, t) => {
+  for (var e in t || (t = {}))
+    Q.call(t, e) && L(n, e, t[e]);
+  if (C)
+    for (var e of C(t))
+      X.call(t, e) && L(n, e, t[e]);
+  return n;
+};
+var P = (n, t, e) => (L(n, typeof t != "symbol" ? t + "" : t, e), e);
+import * as u from "three";
+function E(n, t, e) {
+  const l = (t == null ? void 0 : t.clientWidth) || 1280, s = (t == null ? void 0 : t.clientHeight) || 720, c = e.clone().project(n), i = (c.x + 1) * 0.5 * l, r = (1 - (c.y + 1) * 0.5) * s;
+  return new u.Vector2(i, r);
+}
+function A(n, t, e, l) {
+  const s = l.clone().normalize(), c = 1, i = e.clone().sub(s.clone().multiplyScalar(c)), r = e.clone().add(s.clone().multiplyScalar(c)), h = E(n, t, i), o = E(n, t, r), d = h.distanceTo(o);
+  return d < 1e-3 ? void 0 : 2 * c / d;
+}
+function j(n, t) {
+  let e = 10, l = 10;
+  const s = n.isPerspectiveCamera, c = n.isOrthographicCamera;
+  if (s) {
+    const a = n, m = a.position.distanceTo(t), g = a.fov * Math.PI / 180;
+    l = 2 * Math.tan(g / 2) * m, e = l * a.aspect;
+  } else if (c) {
+    const a = n;
+    e = Math.abs(a.right - a.left), l = Math.abs(a.top - a.bottom);
+  }
+  const i = Math.sqrt(e * e + l * l), r = i * 0.8, h = Math.min(e, l) * 0.25, o = i * 1.2;
+  return Math.max(h, Math.min(r, o));
+}
+function I(n, t, e, l, s) {
+  var g, x, p, y;
+  const c = (t == null ? void 0 : t.clientWidth) || 1280, i = (t == null ? void 0 : t.clientHeight) || 720, h = Math.sqrt(c * c + i * i) * ((g = s == null ? void 0 : s.lengthFactorPx) != null ? g : 1.5), o = (x = s == null ? void 0 : s.dashPx) != null ? x : 3, d = (p = s == null ? void 0 : s.gapPx) != null ? p : 2, a = A(n, t, e, l);
+  return a ? { length: h * a, dashPx: o, gapPx: d } : { length: j(n, e) * ((y = s == null ? void 0 : s.lengthFactorPx) != null ? y : 1.5), dashPx: o, gapPx: d };
+}
+function q(n, t, e, l, s, c, i, r) {
+  var z, W, v, B, F;
+  const h = l.clone().normalize(), o = s, d = [];
+  let a = -o, m = 0;
+  const g = Math.sqrt(b((t == null ? void 0 : t.clientWidth) || 1280, 2) + b((t == null ? void 0 : t.clientHeight) || 720, 2)), x = (z = A(n, t, e, l)) != null ? z : s / (g * 1.5), p = Math.max(1e-6, c * x), y = Math.max(0, i * x), w = p + y, R = 2 * o, U = w > 0 ? Math.ceil(R / w) : 0, V = Math.max(
+    8,
+    Math.min(
+      (W = r == null ? void 0 : r.segmentsCap) != null ? W : 2048,
+      Math.floor(U * ((v = r == null ? void 0 : r.expectedSegmentsSafety) != null ? v : 1.5) + ((B = r == null ? void 0 : r.expectedSegmentsMargin) != null ? B : 16))
+    )
+  );
+  for (; a < o && m < V; ) {
+    const k = e.clone().add(h.clone().multiplyScalar(a)), J = A(n, t, k, l) || x, G = (F = r == null ? void 0 : r.wppClampFactor) != null ? F : 2, T = Math.max(x / G, Math.min(x * G, J)), H = c * T, K = i * T, O = Math.max(a, -o), D = Math.min(a + H, o);
+    if (D > O) {
+      const M = e.clone().add(h.clone().multiplyScalar(O)), S = e.clone().add(h.clone().multiplyScalar(D));
+      d.push(M.x, M.y, M.z, S.x, S.y, S.z);
+    }
+    a += H + K, m++;
+  }
+  return new Float32Array(d);
+}
+class Z {
+  constructor(t, e, l) {
+    P(this, "camera");
+    P(this, "container");
+    P(this, "defaults");
+    this.camera = t, this.container = e, this.defaults = f({}, l || {});
+  }
+  /** 创建虚线（LineSegments + LineBasicMaterial），控制器负责添加到场景 */
+  create(t, e, l) {
+    var m, g;
+    const s = f(f({}, this.defaults), l || {}), { length: c, dashPx: i, gapPx: r } = I(this.camera, this.container, t, e, s), h = q(this.camera, this.container, t, e, c, i, r, s), o = new u.BufferGeometry();
+    o.setAttribute("position", new u.BufferAttribute(h, 3));
+    const d = new u.LineBasicMaterial({
+      color: (m = s.color) != null ? m : 16777215,
+      depthTest: !1,
+      depthWrite: !1,
+      transparent: !0
+      // 双面线段在 three 中不存在，依赖于 depthTest 关闭与 renderOrder 提升
+    }), a = new u.LineSegments(o, d);
+    return a.renderOrder = (g = s.renderOrder) != null ? g : 1e3, a;
+  }
+  /** 更新已创建的虚线，使其保持像素恒定 */
+  update(t, e, l, s) {
+    const c = f(f({}, this.defaults), s || {}), { length: i, dashPx: r, gapPx: h } = I(this.camera, this.container, e, l, c), o = q(this.camera, this.container, e, l, i, r, h, c), d = t.geometry, a = d.getAttribute("position");
+    a && a.itemSize === 3 && a.array.length === o.length ? (a.array.set(o), a.needsUpdate = !0) : d.setAttribute("position", new u.BufferAttribute(o, 3));
+  }
+  /** 创建无限长直线（Line + LineBasicMaterial），穿过整个平面 */
+  createSolidLine(t, e, l) {
+    const s = f({ color: 16777215, renderOrder: 1e3 }, l || {}), c = e.clone().normalize(), i = this.computeInfiniteLineLength(t), r = t.clone().add(c.clone().multiplyScalar(-i)), h = t.clone().add(c.clone().multiplyScalar(i)), o = new Float32Array([r.x, r.y, r.z, h.x, h.y, h.z]), d = new u.BufferGeometry();
+    d.setAttribute("position", new u.BufferAttribute(o, 3));
+    const a = new u.LineBasicMaterial({
+      color: s.color,
+      depthTest: !1,
+      depthWrite: !1,
+      transparent: !0
+    }), m = new u.Line(d, a);
+    return m.renderOrder = s.renderOrder, m;
+  }
+  /** 更新已创建的直线，使其始终穿过整个平面 */
+  updateSolidLine(t, e, l, s) {
+    const c = l.clone().normalize(), i = this.computeInfiniteLineLength(e), r = e.clone().add(c.clone().multiplyScalar(-i)), h = e.clone().add(c.clone().multiplyScalar(i)), o = new Float32Array([r.x, r.y, r.z, h.x, h.y, h.z]), d = t.geometry, a = d.getAttribute("position");
+    a && a.itemSize === 3 && a.array.length === o.length ? (a.array.set(o), a.needsUpdate = !0) : d.setAttribute("position", new u.BufferAttribute(o, 3)), (s == null ? void 0 : s.color) !== void 0 && t.material.color.setHex(s.color);
+  }
+  /** 计算"无限"直线的长度，确保穿过整个可视区域 */
+  computeInfiniteLineLength(t) {
+    return j(this.camera, t) * 10;
+  }
+  /** 释放虚线的几何与材质 */
+  dispose(t) {
+    if (!t)
+      return;
+    t.geometry.dispose();
+    const e = t.material;
+    Array.isArray(e) ? e.forEach((l) => l.dispose()) : e.dispose();
+  }
+  /** 更新默认配置 */
+  updateDefaults(t) {
+    this.defaults = f(f({}, this.defaults), t);
+  }
+}
+export {
+  Z as DashGuideLine
+};

package/libs/shared-utils/logger.js

@@ -1,6 +1,6 @@
 function A() {
   console.debug(
-    "%c %c@realsee/dnalogel %cv3.69.12",
+    "%c %c@realsee/dnalogel %cv3.69.13-alpha-1",
     [
       "background: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAkAAAAMCAMAAACHgmeRAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAABLFBMVEUAAAAapPoap/oaqvkbrfkbr/gZnfwZoPsaqfnD4v/E4/8Ylv0clPm93/+/4P/B4f8Yj/683/8Wif+33P8Uhv+x2f8ShP+s1v8Pgf+n0/8Nf/+h0f8Lff8Lff8Nf/9dl/+czv8KfP8KfP+Lxf+Uyv+Xy/+Hwv+Jw/+Mxf+Oxv+RyP8aovsapfoap/oZmfwZm/wZnvsYnPsYkf4YlP0NePsDYfgYcfi43f+63v8Xiv8Xjf4EWfwCV/sWZ/qz2v+02/8Vh/8WiP8EUf8CTf4WXv2u1/+v2P8Thf8Thv8ETf8CR/8VV/+o1f+q1f8Qgv8Rg/8DSv8BRf8UVP+j0v+k0v8OgP8Pgf8DR/8DQv9Nhf+dzv+fz/+Kv/+Vyv+Xy/+azf+Oxv+Qx/+SyP////8MUhLdAAAAK3RSTlMACEWQ2bd98uQECPXxqO7c+Pb49vj2+Pb49vj23Oul8fMHA+TwerXXjEIG2P+bHgAAAAFiS0dEY1y+LaoAAAB+SURBVAjXY2BgZGJmYWVgYGBgY9fW0eVg4ORi4NbTNzDk4eXjZxAwMjYxNTO3EGQQsrSytrG1sxdmEHFwdHJ2cXUTZRBz9/D08vbxFWeQ8PMPCAwKDpFkkAoNC4+IjIqWZpCRlZOPiY2LV2BQVGJQTkhMUlEFWaOmrqGpxQAAyg0S9Dq+VPYAAAAASUVORK5CYII=')",
       "background-repeat: no-repeat",

package/libs/shared-utils/math/quaternionUtils.d.ts

@@ -0,0 +1,333 @@
+import * as THREE from 'three';
+/**
+ * 四元数相关的工具函数
+ */
+/**
+ * 计算从原始四元数到目标四元数的差值四元数
+ * @param originQuaternion 原始四元数
+ * @param targetQuaternion 目标四元数
+ * @returns 差值四元数，满足 originQuaternion * result = targetQuaternion
+ *
+ * @example
+ * ```typescript
+ * const q1 = new THREE.Quaternion(0, 0, 0, 1) // 初始旋转
+ * const q2 = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 4) // 绕Y轴旋转45度
+ * const qDiff = calculateQuaternionDifference(q1, q2)
+ *
+ * // 验证：q1 * qDiff 应该等于 q2
+ * const result = q1.clone().multiply(qDiff)
+ * console.log('验证结果:', result.equals(q2)) // 应该为 true
+ * ```
+ */
+export declare function calculateQuaternionDifference(originQuaternion: THREE.Quaternion, targetQuaternion: THREE.Quaternion): THREE.Quaternion;
+/**
+ * 将四元数差值应用到对象上
+ * @param object3D 要旋转的对象
+ * @param quaternionDiff 差值四元数
+ * @param rotateCenter 旋转中心点（可选，如果不提供则以对象中心旋转）
+ *
+ * @example
+ * ```typescript
+ * const mesh = new THREE.Mesh(geometry, material)
+ * const qDiff = calculateQuaternionDifference(currentQuat, targetQuat)
+ * applyQuaternionDifference(mesh, qDiff, new THREE.Vector3(0, 0, 0))
+ * ```
+ */
+export declare function applyQuaternionDifference(object3D: THREE.Object3D, quaternionDiff: THREE.Quaternion, rotateCenter?: THREE.Vector3): void;
+/**
+ * 从原始四元数旋转到目标四元数的完整操作
+ * @param object3D 要旋转的对象
+ * @param targetQuaternion 目标四元数
+ * @param rotateCenter 旋转中心点（可选）
+ * @returns 应用的差值四元数
+ *
+ * @example
+ * ```typescript
+ * const mesh = new THREE.Mesh(geometry, material)
+ * const targetQuat = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 2)
+ * const appliedDiff = rotateToQuaternion(mesh, targetQuat)
+ * ```
+ */
+export declare function rotateToQuaternion(object3D: THREE.Object3D, targetQuaternion: THREE.Quaternion, rotateCenter?: THREE.Vector3): THREE.Quaternion;
+/**
+ * 验证四元数计算是否正确
+ * @param originQuaternion 原始四元数
+ * @param targetQuaternion 目标四元数
+ * @param quaternionDiff 计算得到的差值四元数
+ * @param tolerance 容差值（默认为 1e-6）
+ * @returns 验证是否通过
+ */
+export declare function verifyQuaternionDifference(originQuaternion: THREE.Quaternion, targetQuaternion: THREE.Quaternion, quaternionDiff: THREE.Quaternion, tolerance?: number): boolean;
+/**
+ * 获取四元数之间的角度差（弧度）
+ * @param q1 第一个四元数
+ * @param q2 第二个四元数
+ * @returns 角度差（弧度）
+ */
+export declare function getQuaternionAngleDifference(q1: THREE.Quaternion, q2: THREE.Quaternion): number;
+/**
+ * 从四元数和原始向量反推目标向量
+ * @param quaternion 通过setFromUnitVectors(p1, p2)创建的四元数
+ * @param p1 原始向量（已知）
+ * @returns 目标向量p2
+ *
+ * @description
+ * 当四元数是通过 setFromUnitVectors(p1, p2) 创建时，
+ * 可以使用此函数从已知的四元数和p1向量反推出p2向量
+ *
+ * @example
+ * ```typescript
+ * // 已知两个向量
+ * const p1 = new THREE.Vector3(1, 0, 0).normalize()
+ * const p2 = new THREE.Vector3(0, 1, 0).normalize()
+ *
+ * // 创建四元数
+ * const quaternion = new THREE.Quaternion().setFromUnitVectors(p1, p2)
+ *
+ * // 反推p2（已知quaternion和p1）
+ * const reconstructedP2 = reverseVectorFromQuaternion(quaternion, p1)
+ *
+ * // 验证结果
+ * console.log('原始p2:', p2)
+ * console.log('反推p2:', reconstructedP2)
+ * console.log('是否相等:', p2.distanceTo(reconstructedP2) < 0.0001)
+ * ```
+ */
+export declare function reverseVectorFromQuaternion(quaternion: THREE.Quaternion, p1: THREE.Vector3): THREE.Vector3;
+/**
+ * 验证向量反推的准确性
+ * @param originalP1 原始向量p1
+ * @param originalP2 原始向量p2
+ * @param reconstructedP2 反推得到的p2
+ * @param tolerance 容差值（默认为 1e-6）
+ * @returns 验证是否通过
+ *
+ * @example
+ * ```typescript
+ * const p1 = new THREE.Vector3(1, 0, 0).normalize()
+ * const p2 = new THREE.Vector3(0, 1, 0).normalize()
+ * const quaternion = new THREE.Quaternion().setFromUnitVectors(p1, p2)
+ * const reconstructedP2 = reverseVectorFromQuaternion(quaternion, p1)
+ *
+ * const isValid = verifyVectorReconstruction(p1, p2, reconstructedP2)
+ * console.log('反推验证结果:', isValid)
+ * ```
+ */
+export declare function verifyVectorReconstruction(originalP1: THREE.Vector3, originalP2: THREE.Vector3, reconstructedP2: THREE.Vector3, tolerance?: number): boolean;
+/**
+ * 修改四元数的转动角度并反推计算新的目标向量
+ * @param quaternion 原始四元数（从startVector到currentVector的转动）
+ * @param startVector 起始向量
+ * @param newAngleRadians 新的转动角度（弧度）
+ * @returns 新的目标向量
+ *
+ * @description
+ * 这个函数用于修改一个四元数的转动角度，同时保持转动轴不变，
+ * 然后计算应用新四元数后startVector会转动到的新位置
+ *
+ * @example
+ * ```typescript
+ * // 已知从startVector到currentVector的转动四元数
+ * const startVector = new THREE.Vector3(1, 0, 0).normalize()
+ * const currentVector = new THREE.Vector3(0, 1, 0).normalize()
+ * const quaternion = new THREE.Quaternion().setFromUnitVectors(startVector, currentVector)
+ *
+ * // 修改转动角度为60度（原来可能是90度）
+ * const newAngle = Math.PI / 3 // 60度
+ * const newCurrentVector = modifyQuaternionAngleAndReversVector(quaternion, startVector, newAngle)
+ *
+ * console.log('新的目标向量:', newCurrentVector)
+ * ```
+ */
+export declare function modifyQuaternionAngleAndReversVector(quaternion: THREE.Quaternion, startVector: THREE.Vector3, newAngleRadians: number): THREE.Vector3;
+/**
+ * 从四元数中提取转动轴
+ * @param quaternion 四元数
+ * @returns 归一化的转动轴向量
+ *
+ * @description
+ * 根据四元数的数学定义：q = [cos(θ/2), sin(θ/2) * axis]
+ * 其中 axis 是转动轴的单位向量，θ 是转动角度
+ */
+export declare function extractAxisFromQuaternion(quaternion: THREE.Quaternion): THREE.Vector3;
+/**
+ * 从四元数中提取转动角度
+ * @param quaternion 四元数
+ * @returns 转动角度（弧度）
+ *
+ * @description
+ * 根据四元数的数学定义：q = [cos(θ/2), sin(θ/2) * axis]
+ * 角度 θ = 2 * acos(|w|)
+ */
+export declare function extractAngleFromQuaternion(quaternion: THREE.Quaternion): number;
+/**
+ * 修改四元数的转动角度（保持轴不变）
+ * @param quaternion 原始四元数
+ * @param newAngleRadians 新的转动角度（弧度）
+ * @returns 新的四元数
+ *
+ * @example
+ * ```typescript
+ * const originalQuat = new THREE.Quaternion().setFromAxisAngle(
+ *   new THREE.Vector3(0, 1, 0),
+ *   Math.PI / 2 // 90度
+ * )
+ *
+ * // 修改为60度，保持转动轴不变
+ * const newQuat = modifyQuaternionAngle(originalQuat, Math.PI / 3)
+ * ```
+ */
+export declare function modifyQuaternionAngle(quaternion: THREE.Quaternion, newAngleRadians: number): THREE.Quaternion;
+/**
+ * 获取四元数的详细信息（轴和角度）
+ * @param quaternion 四元数
+ * @returns 包含轴向量和角度的对象
+ *
+ * @example
+ * ```typescript
+ * const quat = new THREE.Quaternion().setFromAxisAngle(
+ *   new THREE.Vector3(0, 1, 0),
+ *   Math.PI / 4
+ * )
+ *
+ * const info = getQuaternionInfo(quat)
+ * console.log('转动轴:', info.axis)
+ * console.log('转动角度（度）:', info.angleDegrees)
+ * console.log('转动角度（弧度）:', info.angleRadians)
+ * ```
+ */
+export declare function getQuaternionInfo(quaternion: THREE.Quaternion): {
+    axis: THREE.Vector3;
+    angleRadians: number;
+    angleDegrees: number;
+};
+/**
+ * 获取向量在指定轴方向旋转为0的向量
+ * @param startVec 起始向量
+ * @param axis 轴向量
+ * @returns 移除了在axis方向旋转分量的向量
+ *
+ * @description
+ * 这个函数通过向量投影的方法，移除startVec在axis轴方向上的旋转分量，
+ * 返回垂直于axis的投影向量。数学原理：
+ * 1. 计算startVec在axis上的投影：projection = axis * (startVec · axis)
+ * 2. 从startVec中减去投影得到垂直分量：perpendicular = startVec - projection
+ * 3. 垂直分量就是在axis方向旋转为0的向量
+ *
+ * @example
+ * ```typescript
+ * // 示例：将一个倾斜的向量投影到垂直于Y轴的平面上
+ * const startVec = new THREE.Vector3(1, 1, 1).normalize()
+ * const axis = new THREE.Vector3(0, 1, 0) // Y轴
+ *
+ * const result = getVectorWithZeroRotationOnAxis(startVec, axis)
+ * console.log('原始向量:', startVec)
+ * console.log('轴向量:', axis)
+ * console.log('移除Y轴旋转后的向量:', result)
+ *
+ * // 验证结果向量与轴垂直
+ * const dotProduct = result.dot(axis)
+ * console.log('垂直验证(应该接近0):', dotProduct)
+ * ```
+ */
+export declare function getVectorWithZeroRotationOnAxis(startVec: THREE.Vector3, axis: THREE.Vector3): THREE.Vector3;
+/**
+ * 验证向量是否与指定轴垂直
+ * @param vector 要验证的向量
+ * @param axis 轴向量
+ * @param tolerance 容差值（默认为 1e-6）
+ * @returns 是否垂直
+ *
+ * @example
+ * ```typescript
+ * const startVec = new THREE.Vector3(1, 1, 1)
+ * const axis = new THREE.Vector3(0, 1, 0)
+ * const result = getVectorWithZeroRotationOnAxis(startVec, axis)
+ *
+ * const isVertical = isVectorPerpendicularToAxis(result, axis)
+ * console.log('是否垂直:', isVertical) // 应该为 true
+ * ```
+ */
+export declare function isVectorPerpendicularToAxis(vector: THREE.Vector3, axis: THREE.Vector3, tolerance?: number): boolean;
+/**
+ * 获取四元数在某个轴向量的旋转角度
+ * @param quaternion 四元数
+ * @param axis 指定的轴向量
+ * @returns 旋转角度（弧度）
+ *
+ * @description
+ * 这个函数计算四元数在指定轴方向上的旋转分量。
+ * 通过将四元数分解为轴角表示，然后计算该轴在指定轴上的投影角度。
+ *
+ * 数学原理：
+ * 1. 从四元数中提取转动轴和角度
+ * 2. 计算转动轴与指定轴的夹角
+ * 3. 根据投影关系计算在指定轴上的旋转角度
+ *
+ * @example
+ * ```typescript
+ * // 创建一个绕Y轴旋转45度的四元数
+ * const quat = new THREE.Quaternion().setFromAxisAngle(
+ *   new THREE.Vector3(0, 1, 0),
+ *   Math.PI / 4 // 45度
+ * )
+ *
+ * // 获取在Y轴上的旋转角度
+ * const yAxisAngle = getQuaternionAngleOnAxis(quat, new THREE.Vector3(0, 1, 0))
+ * console.log('Y轴旋转角度（弧度）:', yAxisAngle)
+ * console.log('Y轴旋转角度（度）:', (yAxisAngle * 180) / Math.PI)
+ *
+ * // 获取在X轴上的旋转角度（应该接近0）
+ * const xAxisAngle = getQuaternionAngleOnAxis(quat, new THREE.Vector3(1, 0, 0))
+ * console.log('X轴旋转角度（度）:', (xAxisAngle * 180) / Math.PI)
+ *
+ * // 获取在Z轴上的旋转角度（应该接近0）
+ * const zAxisAngle = getQuaternionAngleOnAxis(quat, new THREE.Vector3(0, 0, 1))
+ * console.log('Z轴旋转角度（度）:', (zAxisAngle * 180) / Math.PI)
+ * ```
+ */
+export declare function getQuaternionAngleOnAxis(quaternion: THREE.Quaternion, axis: THREE.Vector3): number;
+/**
+ * 获取四元数在某个轴向量的旋转角度（度）
+ * @param quaternion 四元数
+ * @param axis 指定的轴向量
+ * @returns 旋转角度（度）
+ *
+ * @example
+ * ```typescript
+ * const quat = new THREE.Quaternion().setFromAxisAngle(
+ *   new THREE.Vector3(0, 1, 0),
+ *   Math.PI / 4
+ * )
+ *
+ * const yAxisAngleDegrees = getQuaternionAngleOnAxisDegrees(quat, new THREE.Vector3(0, 1, 0))
+ * console.log('Y轴旋转角度（度）:', yAxisAngleDegrees) // 应该接近45度
+ * ```
+ */
+export declare function getQuaternionAngleOnAxisDegrees(quaternion: THREE.Quaternion, axis: THREE.Vector3): number;
+/**
+ * 获取四元数在多个轴上的旋转角度
+ * @param quaternion 四元数
+ * @param axes 轴向量数组
+ * @returns 包含各轴旋转角度的对象
+ *
+ * @example
+ * ```typescript
+ * const quat = new THREE.Quaternion().setFromAxisAngle(
+ *   new THREE.Vector3(0, 1, 0),
+ *   Math.PI / 4
+ * )
+ *
+ * const axes = [
+ *   new THREE.Vector3(1, 0, 0), // X轴
+ *   new THREE.Vector3(0, 1, 0), // Y轴
+ *   new THREE.Vector3(0, 0, 1)  // Z轴
+ * ]
+ *
+ * const angles = getQuaternionAnglesOnAxes(quat, axes)
+ * console.log('X轴角度:', angles[0], '度')
+ * console.log('Y轴角度:', angles[1], '度')
+ * console.log('Z轴角度:', angles[2], '度')
+ * ```
+ */
+export declare function getQuaternionAnglesOnAxes(quaternion: THREE.Quaternion, axes: THREE.Vector3[]): number[];

package/libs/shared-utils/threex/domevents/index.js

@@ -1,6 +1,6 @@
-import * as d from "three";
+import * as b from "three";
 function n(t, e) {
-  this._camera = t || null, this._domElement = e || document, this._raycaster = new d.Raycaster(), this._selected = null, this._boundObjs = {};
+  this._camera = t || null, this._domElement = e || document, this._raycaster = new b.Raycaster(), this._selected = null, this._boundObjs = {};
   var o = this;
   this._$onClick = function() {
     o._onClick.apply(o, arguments);
@@ -89,38 +89,70 @@ n.prototype.unbind = function(t, e, o, i) {
       break;
     }
   }
-  var h = this._boundObjs[e].indexOf(t);
-  this._boundObjs[e].splice(h, 1);
+  var _ = this._boundObjs[e].indexOf(t);
+  this._boundObjs[e].splice(_, 1);
 };
 n.prototype.removeEventListener = n.prototype.unbind;
 n.prototype._bound = function(t, e) {
   var o = this._objectCtxGet(e);
   return o ? !!o[t + "Handlers"] : !1;
 };
+n.prototype._isObjectVisible = function(t) {
+  for (var e = t; e; ) {
+    if (e.visible === !1)
+      return !1;
+    e = e.parent;
+  }
+  return !0;
+};
+n.prototype._filterVisibleObjects = function(t) {
+  var e = this;
+  return t.filter(function(o) {
+    return e._isObjectVisible(o);
+  });
+};
 n.prototype._onMove = function(t, e, o, i) {
   var s = this._boundObjs[t];
   if (!(s === void 0 || s.length === 0)) {
-    var r = new d.Vector2();
-    r.set(e, o), this._raycaster.setFromCamera(r, this._camera);
-    var a = this._raycaster.intersectObjects(s), u = this._selected;
-    if (a.length > 0) {
-      var h, c, l, p = a[0], _ = p.object;
-      this._selected = _, l = this._bound("mousemove", _), u != _ && (h = this._bound("mouseover", _), c = u && this._bound("mouseout", u));
-    } else
-      c = u && this._bound("mouseout", u), this._selected = null;
-    l && this._notify("mousemove", _, i, p), h && this._notify("mouseover", _, i, p), c && this._notify("mouseout", u, i, p);
+    var r = this._filterVisibleObjects(s);
+    if (r.length !== 0) {
+      var a = new b.Vector2();
+      a.set(e, o), this._raycaster.setFromCamera(a, this._camera);
+      var u = this._raycaster.intersectObjects(r), _ = this;
+      u = u.filter(function(f) {
+        return _._isObjectVisible(f.object);
+      }), u.sort(function(f, m) {
+        var y = f.object.renderOrder || 0, E = m.object.renderOrder || 0;
+        return y !== E ? E - y : f.distance - m.distance;
+      });
+      var h = this._selected;
+      if (u.length > 0) {
+        var v, d, p, c = u[0], l = c.object;
+        this._selected = l, p = this._bound("mousemove", l), h != l && (v = this._bound("mouseover", l), d = h && this._bound("mouseout", h));
+      } else
+        d = h && this._bound("mouseout", h), this._selected = null;
+      p && this._notify("mousemove", l, i, c), v && this._notify("mouseover", l, i, c), d && this._notify("mouseout", h, i, c);
+    }
   }
 };
 n.prototype._onEvent = function(t, e, o, i) {
   var s = this._boundObjs[t];
   if (!(s === void 0 || s.length === 0)) {
-    var r = new d.Vector2();
-    r.set(e, o), this._raycaster.setFromCamera(r, this._camera);
-    var a = this._raycaster.intersectObjects(s, !0);
-    if (a.length !== 0) {
-      for (var u = a[0], h = u.object, c = this._objectCtxGet(h), l = h.parent; typeof c == "undefined" && l; )
-        c = this._objectCtxGet(l), l = l.parent;
-      c && this._notify(t, h, i, u);
+    var r = this._filterVisibleObjects(s);
+    if (r.length !== 0) {
+      var a = new b.Vector2();
+      a.set(e, o), this._raycaster.setFromCamera(a, this._camera);
+      var u = this._raycaster.intersectObjects(r, !0), _ = this;
+      if (u = u.filter(function(c) {
+        return _._isObjectVisible(c.object);
+      }), u.sort(function(c, l) {
+        var f = c.object.renderOrder || 0, m = l.object.renderOrder || 0;
+        return f !== m ? m - f : c.distance - l.distance;
+      }), u.length !== 0) {
+        for (var h = u[0], v = h.object, d = this._objectCtxGet(v), p = v.parent; typeof d == "undefined" && p; )
+          d = this._objectCtxGet(p), p = p.parent;
+        d && this._notify(t, v, i, h);
+      }
     }
   }
 };
@@ -131,16 +163,16 @@ n.prototype._notify = function(t, e, o, i) {
     return;
   }
   for (var r = s[t + "Handlers"], a = 0; a < r.length; a++) {
-    var u = r[a], h = !0;
+    var u = r[a], _ = !0;
     u.callback({
       type: t,
       target: e,
       origDomEvent: o,
       intersect: i,
       stopPropagation: function() {
-        h = !1;
+        _ = !1;
       }
-    }), h && u.useCapture === !1 && e.parent && this._notify(t, e.parent, o, i);
+    }), _ && u.useCapture === !1 && e.parent && this._notify(t, e.parent, o, i);
   }
 };
 n.prototype._onMouseDown = function(t) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@realsee/dnalogel",
-  "version": "3.69.12",
+  "version": "3.69.13-alpha-1",
   "main": "./dist/index.js",
   "module": "./libs/index.js",
   "types": "./libs/index.d.ts",
@@ -46,7 +46,7 @@
   },
   "devDependencies": {
     "@babel/core": "^7.22.9",
-    "@realsee/five": "6.5.0-alpha.15",
+    "@realsee/five": "6.5.2",
     "@sveltejs/vite-plugin-svelte": "^2.4.2",
     "@tsconfig/svelte": "^4.0.1",
     "@tweenjs/tween.js": "^23.1.1",