@realsee/dnalogel 3.69.6-alpha.4 → 3.69.7-alpha.1

package/libs/DigitalPerformancePlugin/core/Trace.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from 'three';
+export declare class Trace {
+    tracePoints: THREE.Vector3[];
+    curve: THREE.CatmullRomCurve3;
+    constructor();
+    addPoint(point: THREE.Vector3): void;
+    clear(): void;
+    getPoints(): THREE.Vector3[];
+}

package/libs/DigitalPerformancePlugin/core/Trace.js

@@ -0,0 +1,23 @@
+var o = Object.defineProperty;
+var a = (s, t, e) => t in s ? o(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var r = (s, t, e) => (a(s, typeof t != "symbol" ? t + "" : t, e), e);
+import * as i from "three";
+class n {
+  constructor() {
+    r(this, "tracePoints");
+    r(this, "curve");
+    this.tracePoints = [], this.curve = new i.CatmullRomCurve3(this.tracePoints);
+  }
+  addPoint(t) {
+    this.tracePoints.push(t), this.curve = new i.CatmullRomCurve3(this.tracePoints, !1);
+  }
+  clear() {
+    this.tracePoints = [], this.curve = new i.CatmullRomCurve3(this.tracePoints);
+  }
+  getPoints() {
+    return this.tracePoints;
+  }
+}
+export {
+  n as Trace
+};

package/libs/DigitalPerformancePlugin/index.d.ts

@@ -0,0 +1,11 @@
+import type { Five } from '@realsee/five';
+import DigitalPerformancePluginController from './controller';
+export { DigitalHuman } from './core/DigitalHuman';
+export { DigitalPlayground } from './core/DigitalPlayground';
+export { DigitalStateMachine } from './core/DigitalStateMachine';
+export * from './controller';
+export * from './typings';
+export type DigitalPerformancePluginExportInterface = InstanceType<typeof DigitalPerformancePluginController>;
+export type DigitalPerformancePluginParamsInterface = ConstructorParameters<typeof DigitalPerformancePluginController>[1];
+export declare const DigitalPerformancePlugin: (five: Five, params?: DigitalPerformancePluginParamsInterface) => DigitalPerformancePluginController;
+export default DigitalPerformancePlugin;

package/libs/DigitalPerformancePlugin/index.js

@@ -0,0 +1,17 @@
+import t from "./controller/index.js";
+import { DigitalHuman as u } from "./core/DigitalHuman.js";
+import { DigitalPlayground as P } from "./core/DigitalPlayground.js";
+import { DigitalStateMachine as x } from "./core/DigitalStateMachine.js";
+import "three";
+import "./mock.js";
+import "../shared-utils/five/transformPosition.js";
+import "@realsee/five/gltf-loader";
+import "./core/Trace.js";
+const p = (r, o) => new t(r, o);
+export {
+  u as DigitalHuman,
+  p as DigitalPerformancePlugin,
+  P as DigitalPlayground,
+  x as DigitalStateMachine,
+  p as default
+};

package/libs/DigitalPerformancePlugin/mock.d.ts

@@ -0,0 +1,70 @@
+interface MockAction {
+    name: string;
+    animationUrl: string;
+    duration: number;
+    rotation?: any;
+}
+interface MockPoint {
+    point: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    curveIndex?: number;
+    actions: MockAction[];
+}
+interface MockTrack {
+    easing: string;
+    duration: number;
+    path: {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    points: MockPoint[];
+}
+interface MockFiveState {
+    longitude: number;
+    latitude: number;
+    fov: number;
+    offset: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    distance: number;
+    mode: string;
+    workCode: string;
+    panoIndex: number;
+}
+interface Mock {
+    id: number;
+    matrix: number[];
+    modelUrl: string;
+    name: string;
+    animationUrl: string;
+    repeat: string;
+    track: MockTrack;
+    cover_img?: string;
+    fiveState?: MockFiveState;
+}
+export declare function convertMockToPlayer(mockData: Mock, totalDelay?: number, rotationWalkDuration?: number): {
+    name: string;
+    type: "model";
+    model: string;
+    keyframes: {
+        visible: boolean;
+        timeStamp: number;
+        position: number[];
+        quaternion: number[];
+        scale: number[];
+    }[];
+    id?: undefined;
+} | {
+    id: number;
+    name: string;
+    type: "model";
+    model: string;
+    keyframes: any[];
+};
+export {};

package/libs/DigitalPerformancePlugin/mock.js

@@ -0,0 +1,371 @@
+import * as F from "three";
+function nt(s, I = 0, v = 300) {
+  var Y;
+  if (!((Y = s.track) != null && Y.path) || s.track.path.length === 0) {
+    const t = N(s.matrix), n = [
+      {
+        visible: !0,
+        timeStamp: 0 + I,
+        position: t.position,
+        quaternion: t.quaternion,
+        scale: t.scale
+      }
+    ];
+    return {
+      name: s.name || "默认角色",
+      type: "model",
+      model: s.modelUrl,
+      keyframes: n
+    };
+  }
+  function N(t) {
+    const n = [t[12], t[13], t[14]], i = t[0], e = t[4], a = t[8], c = t[1], l = t[5], u = t[9], o = t[2], f = t[6], r = t[10], p = Math.sqrt(i * i + c * c + o * o), x = Math.sqrt(e * e + l * l + f * f), m = Math.sqrt(a * a + u * u + r * r), z = [p, x, m], q = [i / p, e / x, a / m, c / p, l / x, u / m, o / p, f / x, r / m], b = H(q);
+    return { position: n, quaternion: b, scale: z };
+  }
+  function H(t) {
+    const n = t[0] + t[4] + t[8];
+    let i, e = [0, 0, 0, 0];
+    return n > 0 ? (i = Math.sqrt(n + 1) * 2, e[3] = 0.25 * i, e[0] = (t[7] - t[5]) / i, e[1] = (t[2] - t[6]) / i, e[2] = (t[3] - t[1]) / i) : t[0] > t[4] && t[0] > t[8] ? (i = Math.sqrt(1 + t[0] - t[4] - t[8]) * 2, e[3] = (t[7] - t[5]) / i, e[0] = 0.25 * i, e[1] = (t[1] + t[3]) / i, e[2] = (t[2] + t[6]) / i) : t[4] > t[8] ? (i = Math.sqrt(1 + t[4] - t[0] - t[8]) * 2, e[3] = (t[2] - t[6]) / i, e[0] = (t[1] + t[3]) / i, e[1] = 0.25 * i, e[2] = (t[5] + t[7]) / i) : (i = Math.sqrt(1 + t[8] - t[0] - t[4]) * 2, e[3] = (t[3] - t[1]) / i, e[0] = (t[2] + t[6]) / i, e[1] = (t[5] + t[7]) / i, e[2] = 0.25 * i), e;
+  }
+  function L(t, n, i, e = "XYZ") {
+    const a = Math.cos(t / 2), c = Math.cos(n / 2), l = Math.cos(i / 2), u = Math.sin(t / 2), o = Math.sin(n / 2), f = Math.sin(i / 2);
+    let r, p, x, m;
+    switch (e) {
+      case "XYZ":
+        r = u * c * l + a * o * f, p = a * o * l - u * c * f, x = a * c * f + u * o * l, m = a * c * l - u * o * f;
+        break;
+      default:
+        r = u * c * l + a * o * f, p = a * o * l - u * c * f, x = a * c * f + u * o * l, m = a * c * l - u * o * f;
+    }
+    return [r, p, x, m];
+  }
+  function G(t, n) {
+    const i = new F.Vector3(
+      n.x - t.x,
+      n.y - t.y,
+      n.z - t.z
+    ).normalize(), e = new F.Vector3(0, 0, 1), a = new F.Quaternion();
+    return a.setFromUnitVectors(e, i), [a.x, a.y, a.z, a.w];
+  }
+  function R(t) {
+    if (typeof t == "string" && !isNaN(Number(t)))
+      return [0, -(Number(t) * Math.PI) / 180, 0];
+    if (Array.isArray(t) && t.length === 3)
+      return [t[0], -t[1], t[2]];
+  }
+  function j(t, n) {
+    if (!n)
+      return t;
+    const i = L(n[0], n[1], n[2]), [e, a, c, l] = i, [u, o, f, r] = t;
+    return [
+      l * u + e * r + a * f - c * o,
+      l * o - e * f + a * r + c * u,
+      l * f + e * o - a * u + c * r,
+      l * r - e * u - a * o - c * f
+    ];
+  }
+  const h = N(s.matrix);
+  let $ = h.quaternion.slice();
+  const S = s.track.points.find(
+    (t) => Math.abs(t.point.x - h.position[0]) < 1e-3 && Math.abs(t.point.y - h.position[1]) < 1e-3 && Math.abs(t.point.z - h.position[2]) < 1e-3
+  );
+  let P = s.animationUrl, B = !0;
+  const d = [];
+  if (S) {
+    let t = 0;
+    for (const n of S.actions)
+      if (n.duration > 0) {
+        const i = typeof n.animationUrl == "string" && n.animationUrl && n.animationUrl.trim() && n.animationUrl !== "none" && n.animationUrl !== "x_turn";
+        T({
+          visible: !0,
+          timeStamp: t,
+          position: h.position,
+          quaternion: $,
+          scale: h.scale,
+          animation: {
+            url: i ? n.animationUrl : s.animationUrl,
+            repeat: !i
+          }
+        }), t += n.duration * 1e3;
+      }
+    if (!S.actions.some((n) => n.duration > 0)) {
+      const n = S.actions.find(
+        (i) => i.duration > 0 && i.animationUrl !== "none"
+      );
+      n ? (P = n.animationUrl, B = n.duration > 2, console.log(`初始位置与action point重合，使用动作动画: ${P}`)) : console.log("初始位置与action point重合，但没有有效动作，使用默认动画");
+    }
+  } else
+    console.log("初始位置独立，使用默认移动动画");
+  function T(t) {
+    var i, e, a;
+    t.timeStamp += I, t.animation.url === "none" && delete t.animation;
+    const n = d.findIndex((c) => c.timeStamp === t.timeStamp);
+    n !== -1 ? ((i = d[n].animation) == null ? void 0 : i.url) !== ((e = t.animation) == null ? void 0 : e.url) && t.animation && ((a = t.animation) == null ? void 0 : a.url) !== s.animationUrl && (d[n] = t) : d.push(t);
+  }
+  T({
+    visible: !0,
+    timeStamp: 0,
+    position: h.position,
+    quaternion: $,
+    scale: h.scale,
+    animation: {
+      url: P,
+      repeat: B
+    }
+  });
+  let _ = 0;
+  if (S) {
+    let t = 0;
+    for (const n of S.actions)
+      if (n.duration > 0 || n.animationUrl === "x_turn") {
+        if (n.animationUrl === "x_turn") {
+          n.duration = 1;
+          const i = R(n.rotation);
+          i && ($ = j($, i));
+        }
+        t += n.duration * 1e3, _ += n.duration * 1e3, T({
+          visible: !0,
+          timeStamp: t,
+          position: h.position,
+          quaternion: $,
+          scale: h.scale,
+          animation: {
+            url: s.animationUrl,
+            // 恢复默认移动动画
+            repeat: s.repeat === "loop"
+          }
+        });
+      }
+    console.log(`初始action point处理完成，总延迟: ${_}ms`);
+  }
+  function J(t, n) {
+    return Math.sqrt(
+      Math.pow(n.x - t.x, 2) + Math.pow(n.y - t.y, 2) + Math.pow(n.z - t.z, 2)
+    );
+  }
+  let Q = 0;
+  const V = [];
+  for (let t = 0; t < s.track.path.length - 1; t++) {
+    const n = J(s.track.path[t], s.track.path[t + 1]);
+    V.push(n), Q += n;
+  }
+  const E = Q / s.track.duration;
+  console.log(`路径分析:
+    - 总距离: ${Q.toFixed(2)}
+    - 移动时间: ${s.track.duration}s
+    - 移动速度: ${E.toFixed(2)} 单位/秒
+    - 路径段距离: [${V.map((t) => t.toFixed(2)).join(", ")}]`);
+  let U = _, A = 0;
+  const C = /* @__PURE__ */ new Set();
+  for (let t = 0; t < s.track.path.length - 1; t++) {
+    const n = s.track.path[t], i = s.track.path[t + 1], e = V[t], a = A / Q * s.track.duration * 1e3;
+    A += e;
+    const c = A / Q * s.track.duration * 1e3, l = a + U, u = c + U;
+    console.log(
+      `路径段${t}: 距离${e.toFixed(2)}, 基础时间${a.toFixed(0)}-${c.toFixed(0)}ms, 实际时间${l.toFixed(0)}-${u.toFixed(0)}ms`
+    ), T({
+      visible: !0,
+      timeStamp: l,
+      position: [n.x, n.y, n.z],
+      quaternion: $,
+      scale: h.scale,
+      animation: {
+        url: s.animationUrl,
+        // 默认移动动画
+        repeat: s.repeat === "loop"
+      }
+    });
+    for (const o of s.track.points) {
+      if (S && o === S && t === 0) {
+        console.log("跳过初始action point，已在初始关键帧中处理");
+        continue;
+      }
+      const f = `${o.point.x.toFixed(3)}_${o.point.y.toFixed(3)}_${o.point.z.toFixed(3)}`;
+      if (C.has(f)) {
+        console.log(
+          `跳过已处理的点位: [${o.point.x.toFixed(2)}, ${o.point.y.toFixed(2)}, ${o.point.z.toFixed(2)}]`
+        );
+        continue;
+      }
+      if (W(o.point, n, i)) {
+        const r = k(o.point, n, i), p = A - e + e * r, m = p / Q * s.track.duration * 1e3 + U;
+        console.log(
+          `Action点: 位置[${o.point.x.toFixed(2)}, ${o.point.y.toFixed(2)}, ${o.point.z.toFixed(2)}], 距离${p.toFixed(2)}, 到达时间${m.toFixed(0)}ms`
+        );
+        let z = s.animationUrl;
+        const q = o.actions.find(
+          (y) => y.duration > 0 && y.animationUrl !== "none"
+        );
+        q ? (z = q.animationUrl, q.duration > 2, console.log(`到达动作点，使用该点的动画: ${z}`)) : console.log("动作点没有有效动作，使用默认移动动画"), T({
+          visible: !0,
+          timeStamp: m,
+          position: [o.point.x, o.point.y, o.point.z],
+          quaternion: $,
+          scale: h.scale,
+          animation: {
+            url: z,
+            repeat: !1
+          }
+        });
+        let b = m, w = 0;
+        for (const y of o.actions)
+          if (y.duration > 0 || y.animationUrl === "x_turn") {
+            if (y.animationUrl === "x_turn") {
+              y.duration = 1;
+              const Z = R(y.rotation);
+              Z && ($ = j($, Z));
+            }
+            const M = y.animationUrl !== "none" && y.animationUrl !== "x_turn";
+            T({
+              visible: !0,
+              timeStamp: b,
+              position: [o.point.x, o.point.y, o.point.z],
+              quaternion: $,
+              scale: h.scale,
+              animation: {
+                url: M ? y.animationUrl : s.animationUrl,
+                repeat: !M
+              }
+            }), b += y.duration * 1e3, w += y.duration * 1e3, T({
+              visible: !0,
+              timeStamp: b,
+              position: [o.point.x, o.point.y, o.point.z],
+              quaternion: $,
+              scale: h.scale,
+              animation: {
+                url: s.animationUrl,
+                repeat: s.repeat === "loop"
+              }
+            });
+          }
+        U += w, C.add(f), console.log(
+          `点位处理完成，已标记为已处理: [${o.point.x.toFixed(2)}, ${o.point.y.toFixed(2)}, ${o.point.z.toFixed(2)}]`
+        );
+      }
+    }
+    if (t === s.track.path.length - 2) {
+      const o = c + U;
+      T({
+        visible: !0,
+        timeStamp: o,
+        position: [i.x, i.y, i.z],
+        quaternion: $,
+        scale: h.scale,
+        animation: {
+          url: s.animationUrl,
+          repeat: s.repeat === "loop"
+        }
+      });
+    }
+  }
+  function W(t, n, i, e = 0.5) {
+    return D(t, n, i) <= e;
+  }
+  function D(t, n, i) {
+    const e = t.x - n.x, a = t.y - n.y, c = t.z - n.z, l = i.x - n.x, u = i.y - n.y, o = i.z - n.z, f = e * l + a * u + c * o, r = l * l + u * u + o * o;
+    if (r === 0)
+      return Math.sqrt(e * e + a * a + c * c);
+    let p = f / r;
+    p < 0 ? p = 0 : p > 1 && (p = 1);
+    const x = n.x + p * l, m = n.y + p * u, z = n.z + p * o, q = t.x - x, b = t.y - m, w = t.z - z;
+    return Math.sqrt(q * q + b * b + w * w);
+  }
+  function k(t, n, i) {
+    const e = i.x - n.x, a = i.y - n.y, c = i.z - n.z, l = e * e + a * a + c * c;
+    if (l === 0)
+      return 0;
+    const u = t.x - n.x, o = t.y - n.y, f = t.z - n.z, r = u * e + o * a + f * c;
+    return Math.max(0, Math.min(1, r / l));
+  }
+  d.sort((t, n) => t.timeStamp - n.timeStamp);
+  const K = [];
+  for (let t = 0; t < d.length - 1; t++) {
+    const n = d[t], i = d[t + 1];
+    if (Math.abs(n.position[0] - i.position[0]) + Math.abs(n.position[1] - i.position[1]) + Math.abs(n.position[2] - i.position[2]) > 1e-3) {
+      console.log(`找到连续的不同位置关键帧: ${t} -> ${t + 1}`);
+      const a = E * (v / 1e3), c = new F.Vector3(
+        n.position[0],
+        n.position[1],
+        n.position[2]
+      ), l = new F.Vector3(
+        i.position[0] - n.position[0],
+        i.position[1] - n.position[1],
+        i.position[2] - n.position[2]
+      ).normalize(), u = c.clone().add(l.multiplyScalar(a));
+      let o = G(
+        { x: n.position[0], y: n.position[1], z: n.position[2] },
+        { x: i.position[0], y: i.position[1], z: i.position[2] }
+      );
+      const f = {
+        visible: !0,
+        timeStamp: n.timeStamp + v,
+        // 加上旋转走路的时间
+        position: [u.x, u.y, u.z],
+        // 使用计算后的位置
+        quaternion: o,
+        // 使用路径方向的quaternion
+        scale: h.scale
+      };
+      s.animationUrl !== "none" && (f.animation = {
+        url: s.animationUrl,
+        repeat: !0
+      }), K.push(f);
+      for (let r = 0; r < d.length; r++)
+        if (d[r].timeStamp > n.timeStamp + v)
+          if (Math.abs(d[r].position[0] - i.position[0]) < 1e-3 && Math.abs(d[r].position[1] - i.position[1]) < 1e-3 && Math.abs(d[r].position[2] - i.position[2]) < 1e-3)
+            if (r < d.length - 1) {
+              const p = d[r].quaternion, x = d[r + 1].quaternion;
+              if (Math.abs(p[0] - x[0]) + Math.abs(p[1] - x[1]) + Math.abs(p[2] - x[2]) + Math.abs(p[3] - x[3]) < 1e-3)
+                d[r].quaternion = o.slice(), console.log(`关键帧${r}没有旋转，设置为路径方向`);
+              else {
+                const z = new F.Quaternion(), q = new F.Quaternion(
+                  p[0],
+                  p[1],
+                  p[2],
+                  p[3]
+                ), b = new F.Quaternion(
+                  x[0],
+                  x[1],
+                  x[2],
+                  x[3]
+                ), w = q.clone();
+                w.conjugate(), z.copy(b).multiply(w), d[r].quaternion = o.slice();
+                const M = new F.Quaternion(
+                  o[0],
+                  o[1],
+                  o[2],
+                  o[3]
+                ).clone().multiply(z);
+                d[r + 1].quaternion = [M.x, M.y, M.z, M.w], o = [M.x, M.y, M.z, M.w], console.log(`关键帧${r}发生旋转，当前帧设置为路径方向，下一帧设置为路径方向+旋转角度，更新路径方向`), r++;
+              }
+            } else
+              d[r].quaternion = o.slice(), console.log(`最后一个关键帧${r}设置为路径方向`);
+          else
+            break;
+      console.log(`添加旋转动作帧，时间戳: ${n.timeStamp + v}ms`);
+    }
+  }
+  d.push(...K), d.sort((t, n) => t.timeStamp - n.timeStamp);
+  const O = s.track.duration * 1e3, X = O + U, g = d[d.length - 1], tt = d.filter(
+    (t) => t.timeStamp === 0 && Math.abs(t.position[0] - h.position[0]) < 1e-3 && Math.abs(t.position[1] - h.position[1]) < 1e-3 && Math.abs(t.position[2] - h.position[2]) < 1e-3
+  );
+  return console.log(`动画转换完成:
+     - 路径总距离: ${Q.toFixed(2)} 单位
+     - 基础移动时间: ${O}ms (${s.track.duration}s)
+     - 移动速度: ${E.toFixed(2)} 单位/秒
+     - 动作延迟时间: ${U}ms (${(U / 1e3).toFixed(2)}s)
+     - 计算总时间: ${X}ms (${(X / 1e3).toFixed(2)}s)
+     - 实际最后时间戳: ${g == null ? void 0 : g.timeStamp}ms (${((g == null ? void 0 : g.timeStamp) / 1e3).toFixed(2)}s)
+     - 关键帧数量: ${d.length}
+     - 初始位置关键帧数量: ${tt.length}
+     - 速度一致性: ${(((g == null ? void 0 : g.timeStamp) - U) / 1e3 / s.track.duration * 100).toFixed(1)}% (100%为完全一致)`), {
+    id: s.id,
+    name: s.name || "默认角色",
+    type: "model",
+    model: s.modelUrl,
+    keyframes: d
+  };
+}
+export {
+  nt as convertMockToPlayer
+};

package/libs/DigitalPerformancePlugin/typings/index.d.ts

@@ -0,0 +1,79 @@
+import * as THREE from 'three';
+import type { DigitalChapter } from '../core/DigitalStateMachine';
+export type { DigitalScript, DigitalChapter, DigitalModelPlayer, DigitalSubTitlePlayer, DigitalCameraPlayer, DigitalModelKeyframe, DigitalSubTitleKeyframe, DigitalCameraKeyframe, DigitalModelState, DigitalSubTitleState, DigitalCameraState, DigitalModelPlayerItem, DigitalModelPlayerEffect, DigitalEffectKeyframe, DigitalDataState, DigitalDataPlayer, KeyframeType, StateType, } from '../core/DigitalStateMachine';
+export interface DigitalPerformancePluginConfig {
+    autoPlay?: boolean;
+    loop?: boolean;
+    debug?: boolean;
+}
+export interface GlobalProgress {
+    currentTime: number;
+    totalTime: number;
+    percentage: number;
+    currentChapterIndex: number;
+    currentChapterTime: number;
+    currentChapter?: DigitalChapter;
+}
+export interface ChapterTimeInfo {
+    chapterIndex: number;
+    chapterName: string;
+    startTime: number;
+    duration: number;
+    endTime: number;
+    chapter: DigitalChapter;
+}
+export interface ChapterLocation {
+    chapterIndex: number;
+    chapterTime: number;
+    chapter: DigitalChapter;
+}
+export type ProgressListener = (progress: GlobalProgress) => void;
+export interface ProgressBarEvents {
+    'progress-changed': ProgressListener;
+    'chapter-changed': (chapterIndex: number, chapter: DigitalChapter) => void;
+    'seek-started': (targetTime: number) => void;
+    'seek-completed': (actualTime: number) => void;
+    'playback-started': (startTime: number) => void;
+    'playback-completed': () => void;
+}
+export interface ExtendedAnimationConfig {
+    url: string;
+    repeat: boolean;
+    switchDuration?: number;
+    isOver?: boolean;
+}
+export interface DigitalItemKeyframe {
+    visible: boolean;
+    timeStamp: number;
+    position?: number[];
+    quaternion?: number[];
+    scale?: number[];
+}
+export interface DigitalItemState {
+    visible: boolean;
+    translation?: THREE.Vector3;
+    quaternion?: THREE.Quaternion;
+    scale?: THREE.Vector3;
+    keyframeIndex: number;
+    isFinal: boolean;
+}
+export interface DigitalEffectState {
+    visible: boolean;
+    image?: string;
+    intensity?: number;
+    color?: THREE.Color;
+    scale?: THREE.Vector3;
+    keyframeIndex: number;
+    isFinal: boolean;
+}
+export interface TracePoint {
+    position: THREE.Vector3;
+    timestamp: number;
+}
+export interface TraceManager {
+    tracePoints: THREE.Vector3[];
+    maxPoints: number;
+    addPoint(point: THREE.Vector3): void;
+    clear(): void;
+    getPoints(): THREE.Vector3[];
+}

package/libs/DigitalPerformancePlugin/typings/index.js

@@ -0,0 +1 @@
+

package/libs/base/BasePlugin.js

@@ -22,7 +22,7 @@ let A = class {
     /**
      * @realsee/dnalogel 版本号
      */
-    r(this, "VERSION", "3.69.6-alpha.4");
+    r(this, "VERSION", "3.69.7-alpha.1");
     r(this, "NAME");
     r(this, "five");
     r(this, "workUtil");