@realsee/dnalogel 3.69.1 → 3.69.3-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): {
+    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,273 @@
+function H(s, P = 0) {
+  var C;
+  if (!((C = s.track) != null && C.path) || s.track.path.length === 0) {
+    const n = w(s.matrix), t = [
+      {
+        visible: !0,
+        timeStamp: 0 + P,
+        position: n.position,
+        quaternion: n.quaternion,
+        scale: n.scale
+      }
+    ];
+    return {
+      name: s.name || "默认角色",
+      type: "model",
+      model: s.modelUrl,
+      keyframes: t
+    };
+  }
+  function w(n) {
+    const t = [n[12], n[13], n[14]], i = n[0], o = n[4], a = n[8], r = n[1], l = n[5], c = n[9], e = n[2], u = n[6], p = n[10], d = Math.sqrt(i * i + r * r + e * e), h = Math.sqrt(o * o + l * l + u * u), U = Math.sqrt(a * a + c * c + p * p), F = [d, h, U], z = [i / d, o / h, a / U, r / d, l / h, c / U, e / d, u / h, p / U], g = V(z);
+    return { position: t, quaternion: g, scale: F };
+  }
+  function V(n) {
+    const t = n[0] + n[4] + n[8];
+    let i, o = [0, 0, 0, 0];
+    return t > 0 ? (i = Math.sqrt(t + 1) * 2, o[3] = 0.25 * i, o[0] = (n[7] - n[5]) / i, o[1] = (n[2] - n[6]) / i, o[2] = (n[3] - n[1]) / i) : n[0] > n[4] && n[0] > n[8] ? (i = Math.sqrt(1 + n[0] - n[4] - n[8]) * 2, o[3] = (n[7] - n[5]) / i, o[0] = 0.25 * i, o[1] = (n[1] + n[3]) / i, o[2] = (n[2] + n[6]) / i) : n[4] > n[8] ? (i = Math.sqrt(1 + n[4] - n[0] - n[8]) * 2, o[3] = (n[2] - n[6]) / i, o[0] = (n[1] + n[3]) / i, o[1] = 0.25 * i, o[2] = (n[5] + n[7]) / i) : (i = Math.sqrt(1 + n[8] - n[0] - n[4]) * 2, o[3] = (n[3] - n[1]) / i, o[0] = (n[2] + n[6]) / i, o[1] = (n[5] + n[7]) / i, o[2] = 0.25 * i), o;
+  }
+  function X(n, t, i, o = "XYZ") {
+    const a = Math.cos(n / 2), r = Math.cos(t / 2), l = Math.cos(i / 2), c = Math.sin(n / 2), e = Math.sin(t / 2), u = Math.sin(i / 2);
+    let p, d, h, U;
+    switch (o) {
+      case "XYZ":
+        p = c * r * l + a * e * u, d = a * e * l - c * r * u, h = a * r * u + c * e * l, U = a * r * l - c * e * u;
+        break;
+      default:
+        p = c * r * l + a * e * u, d = a * e * l - c * r * u, h = a * r * u + c * e * l, U = a * r * l - c * e * u;
+    }
+    return [p, d, h, U];
+  }
+  function _(n) {
+    if (typeof n == "string" && !isNaN(Number(n)))
+      return [0, -(Number(n) * Math.PI) / 180, 0];
+    if (Array.isArray(n) && n.length === 3)
+      return [n[0], -n[1], n[2]];
+  }
+  function Q(n, t) {
+    if (!t)
+      return n;
+    const i = X(t[0], t[1], t[2]), [o, a, r, l] = i, [c, e, u, p] = n;
+    return [
+      l * c + o * p + a * u - r * e,
+      l * e - o * u + a * p + r * c,
+      l * u + o * e - a * c + r * p,
+      l * p - o * c - a * e - r * u
+    ];
+  }
+  const f = w(s.matrix);
+  let M = f.quaternion.slice();
+  const y = s.track.points.find(
+    (n) => Math.abs(n.point.x - f.position[0]) < 1e-3 && Math.abs(n.point.y - f.position[1]) < 1e-3 && Math.abs(n.point.z - f.position[2]) < 1e-3
+  );
+  let N = s.animationUrl;
+  const $ = [];
+  if (y) {
+    let n = 0;
+    for (const t of y.actions)
+      if (t.duration > 0) {
+        const i = typeof t.animationUrl == "string" && t.animationUrl && t.animationUrl.trim() && t.animationUrl !== "none" && t.animationUrl !== "x_turn";
+        T({
+          visible: !0,
+          timeStamp: n,
+          position: f.position,
+          quaternion: M,
+          scale: f.scale,
+          animation: {
+            url: i ? t.animationUrl : s.animationUrl,
+            repeat: !i
+          }
+        }), n += t.duration * 1e3;
+      }
+    if (!y.actions.some((t) => t.duration > 0)) {
+      const t = y.actions.find((i) => i.duration > 0 && i.animationUrl !== "none");
+      t ? (N = t.animationUrl, t.duration > 2, console.log(`初始位置与action point重合，使用动作动画: ${N}`)) : console.log("初始位置与action point重合，但没有有效动作，使用默认动画");
+    }
+  } else
+    console.log("初始位置独立，使用默认移动动画");
+  function T(n) {
+    var i, o, a;
+    n.timeStamp += P, n.animation.url === "none" && delete n.animation;
+    const t = $.findIndex((r) => r.timeStamp === n.timeStamp);
+    t !== -1 ? ((i = $[t].animation) == null ? void 0 : i.url) !== ((o = n.animation) == null ? void 0 : o.url) && n.animation && ((a = n.animation) == null ? void 0 : a.url) !== s.animationUrl && ($[t] = n) : $.push(n);
+  }
+  let A = 0;
+  if (y) {
+    let n = 0;
+    for (const t of y.actions)
+      if (t.duration > 0 || t.animationUrl === "x_turn") {
+        if (t.animationUrl === "x_turn") {
+          t.duration = 3;
+          const i = _(t.rotation);
+          i && (M = Q(M, i));
+        }
+        n += t.duration * 1e3, A += t.duration * 1e3, T({
+          visible: !0,
+          timeStamp: n,
+          position: f.position,
+          quaternion: M,
+          scale: f.scale,
+          animation: {
+            url: s.animationUrl,
+            // 恢复默认移动动画
+            repeat: s.repeat === "loop"
+          }
+        });
+      }
+    console.log(`初始action point处理完成，总延迟: ${A}ms`);
+  }
+  function Y(n, t) {
+    return Math.sqrt(Math.pow(t.x - n.x, 2) + Math.pow(t.y - n.y, 2) + Math.pow(t.z - n.z, 2));
+  }
+  let b = 0;
+  const v = [];
+  for (let n = 0; n < s.track.path.length - 1; n++) {
+    const t = Y(s.track.path[n], s.track.path[n + 1]);
+    v.push(t), b += t;
+  }
+  const E = b / s.track.duration;
+  console.log(`路径分析:
+      - 总距离: ${b.toFixed(2)}
+      - 移动时间: ${s.track.duration}s
+      - 移动速度: ${E.toFixed(2)} 单位/秒
+      - 路径段距离: [${v.map((n) => n.toFixed(2)).join(", ")}]`);
+  let m = A, S = 0;
+  for (let n = 0; n < s.track.path.length - 1; n++) {
+    const t = s.track.path[n], i = s.track.path[n + 1], o = v[n], a = S / b * s.track.duration * 1e3;
+    S += o;
+    const r = S / b * s.track.duration * 1e3, l = a + m, c = r + m;
+    console.log(
+      `路径段${n}: 距离${o.toFixed(2)}, 基础时间${a.toFixed(0)}-${r.toFixed(
+        0
+      )}ms, 实际时间${l.toFixed(0)}-${c.toFixed(0)}ms`
+    ), T({
+      visible: !0,
+      timeStamp: l,
+      position: [t.x, t.y, t.z],
+      quaternion: M,
+      scale: f.scale,
+      animation: {
+        url: s.animationUrl,
+        // 默认移动动画
+        repeat: s.repeat === "loop"
+      }
+    });
+    for (const e of s.track.points) {
+      if (y && e === y && n === 0) {
+        console.log("跳过初始action point，已在初始关键帧中处理");
+        continue;
+      }
+      if (Z(e.point, t, i)) {
+        const u = L(e.point, t, i), p = S - o + o * u, h = p / b * s.track.duration * 1e3 + m;
+        console.log(
+          `Action点: 位置[${e.point.x.toFixed(2)}, ${e.point.y.toFixed(2)}, ${e.point.z.toFixed(
+            2
+          )}], 距离${p.toFixed(2)}, 到达时间${h.toFixed(0)}ms`
+        );
+        let U = s.animationUrl;
+        const F = e.actions.find((x) => x.duration > 0 && x.animationUrl !== "none");
+        F ? (U = F.animationUrl, F.duration > 2, console.log(`到达动作点，使用该点的动画: ${U}`)) : console.log("动作点没有有效动作，使用默认移动动画"), T({
+          visible: !0,
+          timeStamp: h,
+          position: [e.point.x, e.point.y, e.point.z],
+          quaternion: M,
+          scale: f.scale,
+          animation: {
+            url: U,
+            repeat: !1
+          }
+        });
+        let z = h, g = 0;
+        for (const x of e.actions)
+          if (x.duration > 0 || x.animationUrl === "x_turn") {
+            if (x.animationUrl === "x_turn") {
+              x.duration = 3;
+              const R = _(x.rotation);
+              R && (M = Q(M, R));
+            }
+            const O = x.animationUrl !== "none" && x.animationUrl !== "x_turn";
+            T({
+              visible: !0,
+              timeStamp: z,
+              position: [e.point.x, e.point.y, e.point.z],
+              quaternion: M,
+              scale: f.scale,
+              animation: {
+                url: O ? x.animationUrl : s.animationUrl,
+                repeat: !O
+              }
+            }), z += x.duration * 1e3, g += x.duration * 1e3, T({
+              visible: !0,
+              timeStamp: z,
+              position: [e.point.x, e.point.y, e.point.z],
+              quaternion: M,
+              scale: f.scale,
+              animation: {
+                url: s.animationUrl,
+                repeat: s.repeat === "loop"
+              }
+            });
+          }
+        m += g;
+      }
+    }
+    if (n === s.track.path.length - 2) {
+      const e = r + m;
+      T({
+        visible: !0,
+        timeStamp: e,
+        position: [i.x, i.y, i.z],
+        quaternion: M,
+        scale: f.scale,
+        animation: {
+          url: s.animationUrl,
+          repeat: s.repeat === "loop"
+        }
+      });
+    }
+  }
+  function Z(n, t, i, o = 0.5) {
+    return j(n, t, i) <= o;
+  }
+  function j(n, t, i) {
+    const o = n.x - t.x, a = n.y - t.y, r = n.z - t.z, l = i.x - t.x, c = i.y - t.y, e = i.z - t.z, u = o * l + a * c + r * e, p = l * l + c * c + e * e;
+    if (p === 0)
+      return Math.sqrt(o * o + a * a + r * r);
+    let d = u / p;
+    d < 0 ? d = 0 : d > 1 && (d = 1);
+    const h = t.x + d * l, U = t.y + d * c, F = t.z + d * e, z = n.x - h, g = n.y - U, x = n.z - F;
+    return Math.sqrt(z * z + g * g + x * x);
+  }
+  function L(n, t, i) {
+    const o = i.x - t.x, a = i.y - t.y, r = i.z - t.z, l = o * o + a * a + r * r;
+    if (l === 0)
+      return 0;
+    const c = n.x - t.x, e = n.y - t.y, u = n.z - t.z, p = c * o + e * a + u * r;
+    return Math.max(0, Math.min(1, p / l));
+  }
+  $.sort((n, t) => n.timeStamp - t.timeStamp);
+  const I = s.track.duration * 1e3, B = I + m, q = $[$.length - 1], G = $.filter(
+    (n) => n.timeStamp === 0 && Math.abs(n.position[0] - f.position[0]) < 1e-3 && Math.abs(n.position[1] - f.position[1]) < 1e-3 && Math.abs(n.position[2] - f.position[2]) < 1e-3
+  );
+  return console.log(`动画转换完成:
+       - 路径总距离: ${b.toFixed(2)} 单位
+       - 基础移动时间: ${I}ms (${s.track.duration}s)
+       - 移动速度: ${E.toFixed(2)} 单位/秒
+       - 动作延迟时间: ${m}ms (${(m / 1e3).toFixed(2)}s)
+       - 计算总时间: ${B}ms (${(B / 1e3).toFixed(2)}s)
+       - 实际最后时间戳: ${q == null ? void 0 : q.timeStamp}ms (${((q == null ? void 0 : q.timeStamp) / 1e3).toFixed(2)}s)
+       - 关键帧数量: ${$.length}
+       - 初始位置关键帧数量: ${G.length}
+       - 速度一致性: ${(((q == null ? void 0 : q.timeStamp) - m) / 1e3 / s.track.duration * 100).toFixed(
+    1
+  )}% (100%为完全一致)`), {
+    id: s.id,
+    name: s.name || "默认角色",
+    type: "model",
+    model: s.modelUrl,
+    keyframes: $
+  };
+}
+export {
+  H 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/GuideLinePlugin/Controller.d.ts

@@ -49,7 +49,6 @@ export default class Controller extends BasePluginWithData.Controller<PluginStat
     }): void;
     /** 添加一个 GuideLineItem */
     addGuideLineItem(data?: PluginType.GuideLineItem): GuideLineItem;
-    private processItemUrls;
     /** 获取 Plugin 内的 GuideLineItem */
     getGuideLineItemByID(id: string | number): GuideLineItem;
     /** 移除一个 GuideLineItem */