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

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

@@ -0,0 +1,41 @@
+import * as THREE from 'three';
+import type { GLTFObject } from '@realsee/five/gltf-loader';
+import { DigitalStateMachine } from './DigitalStateMachine';
+import type { DigitalModelKeyframe, DigitalModelPlayerItem, DigitalModelPlayerEffect } from './DigitalStateMachine';
+export declare class DigitalHuman {
+    model: GLTFObject;
+    keyframesManager: DigitalStateMachine;
+    keyframes: DigitalModelKeyframe[];
+    items: DigitalModelPlayerItem[];
+    effects: DigitalModelPlayerEffect[];
+    digitalPlayground: any;
+    private mixer;
+    private action;
+    state: {
+        currentTime: number;
+        currentAnimation: THREE.AnimationClip | null;
+        playing: boolean;
+    };
+    animationFrameId: number | null;
+    private itemMatrixMap;
+    private trace;
+    curveLine: THREE.Line;
+    effectsGroup: THREE.Group;
+    effectObjects: Map<string, THREE.Mesh>;
+    container: THREE.Group;
+    constructor(model: GLTFObject, digitalPlayground: any);
+    playAnimation(animation: THREE.AnimationClip, repeat: boolean, switchDuration: number): void;
+    pauseAnimation(): void;
+    stopAnimation(): void;
+    continueAnimation(): void;
+    attachItem(): void;
+    init(): void;
+    reset(): void;
+    play(option?: {
+        keyframes: DigitalModelKeyframe[];
+        items: DigitalModelPlayerItem[];
+        effects: DigitalModelPlayerEffect[];
+    }): Promise<boolean>;
+    traceUpDate(): void;
+    clearTrace(): void;
+}

package/libs/DigitalPerformancePlugin/core/DigitalHuman.js

@@ -0,0 +1,174 @@
+var P = Object.defineProperty;
+var L = (u, e, s) => e in u ? P(u, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : u[e] = s;
+var n = (u, e, s) => (L(u, typeof e != "symbol" ? e + "" : e, s), s);
+var I = (u, e, s) => new Promise((y, c) => {
+  var r = (h) => {
+    try {
+      p(s.next(h));
+    } catch (w) {
+      c(w);
+    }
+  }, M = (h) => {
+    try {
+      p(s.throw(h));
+    } catch (w) {
+      c(w);
+    }
+  }, p = (h) => h.done ? y(h.value) : Promise.resolve(h.value).then(r, M);
+  p((s = s.apply(u, e)).next());
+});
+import * as t from "three";
+import { DigitalStateMachine as S } from "./DigitalStateMachine.js";
+import { Trace as B } from "./Trace.js";
+const q = 300;
+class D {
+  constructor(e, s) {
+    n(this, "model");
+    n(this, "keyframesManager");
+    n(this, "keyframes");
+    n(this, "items");
+    n(this, "effects");
+    n(this, "digitalPlayground");
+    n(this, "mixer");
+    n(this, "action");
+    n(this, "state");
+    n(this, "animationFrameId");
+    n(this, "itemMatrixMap");
+    n(this, "trace");
+    n(this, "curveLine");
+    n(this, "effectsGroup");
+    n(this, "effectObjects");
+    n(this, "container");
+    this.model = e, this.model.visible = !1, this.model.mixer = null, this.mixer = new t.AnimationMixer(this.model), this.action = null, this.keyframesManager = new S(), this.keyframes = [], this.items = [], this.effects = [], this.digitalPlayground = s, this.state = {
+      currentTime: 0,
+      currentAnimation: null,
+      playing: !1
+    }, this.animationFrameId = null, this.itemMatrixMap = /* @__PURE__ */ new Map(), this.trace = new B(), this.curveLine = new t.Line(), this.curveLine.material = new t.LineBasicMaterial({ color: 14467195, linewidth: 5 }), this.effectsGroup = new t.Group(), this.effectObjects = /* @__PURE__ */ new Map(), this.container = new t.Group(), this.container.add(this.model), this.container.add(this.curveLine), this.container.add(this.effectsGroup);
+  }
+  playAnimation(e, s, y) {
+    const c = this.action, r = this.mixer.clipAction(e);
+    r.reset(), s || (r.setLoop(t.LoopOnce, 1), r.clampWhenFinished = !0), c && (r.enabled = !0, r.setEffectiveTimeScale(1), r.crossFadeFrom(c, y / 1e3, !0)), r.play(), c && c !== r && setTimeout(() => {
+      c.stop();
+    }, y), this.action = r;
+  }
+  pauseAnimation() {
+    this.action && (this.action.paused = !0), this.animationFrameId && (cancelAnimationFrame(this.animationFrameId), this.animationFrameId = null), this.state.playing = !1;
+  }
+  stopAnimation() {
+    this.state.currentAnimation = null, this.mixer.stopAllAction(), this.state.playing = !1;
+  }
+  continueAnimation() {
+    this.action && (this.action.paused = !1), this.animationFrameId && (cancelAnimationFrame(this.animationFrameId), this.animationFrameId = null), this.keyframes.length > 0 && this.play(), this.state.playing = !0;
+  }
+  attachItem() {
+  }
+  init() {
+    this.state.currentTime = 0, this.model.position.copy(new t.Vector3().fromArray(this.keyframes[0].position)), this.model.quaternion.copy(new t.Quaternion().fromArray(this.keyframes[0].quaternion)), this.model.visible = this.keyframes[0].visible;
+  }
+  reset() {
+    this.state.currentTime = 0, this.keyframes && this.keyframes.length > 0 && (this.model.position.copy(new t.Vector3().fromArray(this.keyframes[0].position)), this.model.quaternion.copy(new t.Quaternion().fromArray(this.keyframes[0].quaternion))), this.model.visible = !1, this.container.visible = !1, this.animationFrameId && cancelAnimationFrame(this.animationFrameId), this.stopAnimation(), this.clearTrace(), this.state.playing = !1;
+  }
+  play(e) {
+    return I(this, null, function* () {
+      const { keyframes: s, items: y, effects: c } = e || {};
+      return this.keyframes = s || this.keyframes, this.items = y || this.items, this.effects = c || this.effects, this.state.currentAnimation = null, this.state.playing = !0, new Promise((r, M) => {
+        this.state.currentTime || this.init();
+        let p = null;
+        for (let o = 0; o < this.items.length; o++) {
+          const m = this.digitalPlayground.getDigitalItem(this.items[o].model);
+          if (m) {
+            let i = null;
+            const d = this.model.children[0].children.find((f) => f instanceof t.Bone), g = this.model.children[0].children.find((f) => f instanceof t.SkinnedMesh);
+            if (!d || !g)
+              throw new Error("模型骨骼缺失");
+            if (this.model.children[0].children[2].traverse((f) => {
+              f instanceof t.Bone && f.name === "RightHand" && (i = f);
+            }), !i)
+              throw new Error("没有找到绑定的骨骼");
+            i.add(m);
+            const a = new t.Vector3(), l = new t.Quaternion(), A = new t.Vector3();
+            new t.Matrix4().fromArray(this.items[o].initialMatrix).decompose(a, l, A), m.position.copy(a), m.quaternion.copy(l), m.scale.copy(A), m.updateMatrixWorld(!0);
+          }
+        }
+        const h = /* @__PURE__ */ new Map(), w = new t.TextureLoader();
+        for (let o = 0; o < this.effects.length; o++) {
+          const m = this.effects[o];
+          if (m.type === "frameSequence") {
+            const i = m.keyframes;
+            for (let d = 0; d < i.length; d++)
+              w.load(i[d].image, (g) => {
+                g.name = i[d].image, h.set(i[d].image, g);
+              });
+          }
+        }
+        const v = (o) => {
+          var g;
+          p === null && (p = o);
+          const m = o - p;
+          p = o, this.state.currentTime += m;
+          const i = this.keyframesManager.getStateByTime(this.state.currentTime, this.keyframes, "model");
+          this.trace.addPoint(i.translation);
+          const d = new t.BufferGeometry().setFromPoints(this.trace.tracePoints);
+          if (this.curveLine.geometry = d, this.model.position.copy(i.translation), this.model.quaternion.copy(i.quaternion), this.model.scale.copy(i.scale), this.model.visible = i.visible, i.isFinal) {
+            this.model.visible = !1, this.container.visible = !1, this.stopAnimation(), this.model.needsRender = !0, r(!0), this.animationFrameId !== null && (cancelAnimationFrame(this.animationFrameId), this.animationFrameId = null);
+            return;
+          } else if (i.animation) {
+            const a = this.digitalPlayground.getAnimation(i.animation.url);
+            a !== this.state.currentAnimation && (this.state.currentAnimation = a, this.playAnimation(
+              a,
+              i.animation.repeat,
+              (g = i.animation.switchDuration) != null ? g : q
+            )), this.mixer.update(m / 1e3), i.animation.isOver === !0 && (this.action.paused = !0, this.action.time = this.state.currentAnimation.duration, this.mixer.update(0));
+          }
+          for (let a = 0; a < this.items.length; a++) {
+            const l = this.digitalPlayground.getDigitalItem(this.items[a].model);
+            l && (this.keyframesManager.getStateByTime(
+              this.state.currentTime,
+              this.items[a].keyframes,
+              "item"
+            ).visible === !0 ? l.visible = !0 : l.visible = !1);
+          }
+          for (let a = 0; a < this.effects.length; a++) {
+            const l = this.effects[a];
+            if (l.type === "frameSequence") {
+              const A = l.type + a;
+              if (!this.effectObjects.has(A)) {
+                const b = new t.PlaneGeometry(1, 1), x = new t.MeshBasicMaterial({
+                  transparent: !0
+                }), F = new t.Mesh(b, x);
+                F.rotateX(-Math.PI / 2), F.position.copy(new t.Vector3().fromArray(l.position)), this.effectObjects.set(A, F), this.effectsGroup.add(F);
+              }
+              const k = this.effectObjects.get(A), f = this.keyframesManager.getStateByTime(
+                this.state.currentTime,
+                this.effects[a].keyframes,
+                "effect"
+              ), T = h.get(f.image);
+              k.material.map = T, k.visible = f.visible;
+            }
+          }
+          this.model.needsRender = !0, this.animationFrameId = requestAnimationFrame(v);
+        };
+        this.animationFrameId && (cancelAnimationFrame(this.animationFrameId), this.animationFrameId = null), this.animationFrameId = requestAnimationFrame(v);
+      });
+    });
+  }
+  // 用于分段时 更新轨迹
+  traceUpDate() {
+    this.trace.clear();
+    for (let e = 0; e <= this.state.currentTime; e += 100) {
+      const s = this.keyframesManager.getStateByTime(e, this.keyframes, "model");
+      this.trace.addPoint(s.translation);
+      const y = new t.BufferGeometry().setFromPoints(this.trace.tracePoints);
+      this.curveLine.geometry = y;
+    }
+  }
+  // 清楚轨迹
+  clearTrace() {
+    this.trace.clear();
+    const e = new t.BufferGeometry().setFromPoints(this.trace.tracePoints);
+    this.curveLine.geometry = e;
+  }
+}
+export {
+  D as DigitalHuman
+};

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

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+import { GLTFLoader } from '@realsee/five/gltf-loader';
+import { DigitalHuman } from './DigitalHuman';
+import type { DigitalScript, DigitalChapter } from './DigitalStateMachine';
+export declare class DigitalPlayground {
+    gltfLoader: GLTFLoader;
+    private digitalHumanMap;
+    private digitalItemMap;
+    private skeletalAnimationMap;
+    script: DigitalScript | null;
+    currentChapter: DigitalChapter | null;
+    private debugMode;
+    constructor(debugMode?: boolean);
+    setScript(script: DigitalScript): void;
+    loadModel(url: string, id?: string): Promise<DigitalHuman>;
+    loadModels(urls: string[], ids?: string[]): Promise<DigitalHuman[]>;
+    loadAnimation(url: string): Promise<THREE.AnimationClip>;
+    loadAnimations(urls: string[]): Promise<THREE.AnimationClip[]>;
+    getAnimation(url: string): THREE.AnimationClip | null;
+    getDigitalHuman(url: string, id?: string): DigitalHuman | null;
+    playByChapter(chapter: DigitalChapter): Promise<any[]>;
+    loadItems(urls: string[]): Promise<any[]>;
+    loadItem(url: string): Promise<any>;
+    getDigitalItem(url: string): any | null;
+    pause(): void;
+    continue(): void;
+    reset(): void;
+    setTimelineTo(time: number): void;
+    /**
+     * 销毁 playground
+     */
+    dispose(): void;
+}

package/libs/DigitalPerformancePlugin/core/DigitalPlayground.js

@@ -0,0 +1,155 @@
+var d = Object.defineProperty;
+var g = (n, t, e) => t in n ? d(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var r = (n, t, e) => (g(n, typeof t != "symbol" ? t + "" : t, e), e);
+var o = (n, t, e) => new Promise((a, i) => {
+  var l = (m) => {
+    try {
+      s(e.next(m));
+    } catch (p) {
+      i(p);
+    }
+  }, h = (m) => {
+    try {
+      s(e.throw(m));
+    } catch (p) {
+      i(p);
+    }
+  }, s = (m) => m.done ? a(m.value) : Promise.resolve(m.value).then(l, h);
+  s((e = e.apply(n, t)).next());
+});
+import { GLTFLoader as c } from "@realsee/five/gltf-loader";
+import { DigitalHuman as u } from "./DigitalHuman.js";
+import "three";
+import "./DigitalStateMachine.js";
+import "./Trace.js";
+class k {
+  constructor(t = !1) {
+    r(this, "gltfLoader");
+    r(this, "digitalHumanMap");
+    r(this, "digitalItemMap");
+    r(this, "skeletalAnimationMap");
+    r(this, "script");
+    r(this, "currentChapter");
+    r(this, "debugMode");
+    this.gltfLoader = new c(), this.digitalHumanMap = /* @__PURE__ */ new Map(), this.digitalItemMap = /* @__PURE__ */ new Map(), this.skeletalAnimationMap = /* @__PURE__ */ new Map(), this.script = null, this.currentChapter = null, this.debugMode = t;
+  }
+  setScript(t) {
+    this.script = t;
+  }
+  loadModel(t, e) {
+    return o(this, null, function* () {
+      const a = e ? `${t}_${e}` : t;
+      if (this.digitalHumanMap.has(a)) {
+        const i = this.digitalHumanMap.get(a);
+        return Promise.resolve(i);
+      } else
+        return new Promise((i, l) => {
+          t.endsWith(".gltf") || t.endsWith(".glb") ? this.gltfLoader.load(t, ({ scene: h }) => {
+            const s = new u(h, this);
+            this.digitalHumanMap.set(a, s), i(s);
+          }) : l(new Error("不支持的模型格式"));
+        });
+    });
+  }
+  loadModels(t, e) {
+    return o(this, null, function* () {
+      return e && e.length === t.length ? Promise.all(t.map((a, i) => this.loadModel(a, e[i]))) : Promise.all(t.map((a) => this.loadModel(a)));
+    });
+  }
+  // 加载骨骼动画，暂且认为一个glb只包含一个骨骼动画
+  loadAnimation(t) {
+    return o(this, null, function* () {
+      if (this.skeletalAnimationMap.has(t)) {
+        const e = this.skeletalAnimationMap.get(t);
+        return Promise.resolve(e);
+      } else
+        return new Promise((e, a) => {
+          this.gltfLoader.load(t, ({ animations: i }) => {
+            const l = i[0];
+            this.skeletalAnimationMap.set(t, l), e(l);
+          });
+        });
+    });
+  }
+  loadAnimations(t) {
+    return o(this, null, function* () {
+      return Promise.all(t.map((e) => this.loadAnimation(e)));
+    });
+  }
+  getAnimation(t) {
+    return this.skeletalAnimationMap.get(t) || null;
+  }
+  getDigitalHuman(t, e) {
+    const a = e ? `${t}_${e}` : t;
+    return this.digitalHumanMap.get(a) || null;
+  }
+  playByChapter(t) {
+    return o(this, null, function* () {
+      if (!t || !Array.isArray(t.players))
+        throw new Error("Invalid chapter: chapter or chapter.players is undefined");
+      this.currentChapter = t;
+      const e = t.players.filter((i) => i.type === "model");
+      this.digitalHumanMap.forEach((i) => {
+        i.model.visible = !1, i.container.visible = !1;
+      });
+      const a = [];
+      for (let i = 0; i < e.length; i++) {
+        const l = e[i], h = `${l.model}_${l.id}`, s = this.digitalHumanMap.get(h);
+        s && (s.model.visible = !0, s.container.visible = !0, a.push(s.play({ keyframes: l.keyframes, items: [], effects: [] })));
+      }
+      return Promise.all(a);
+    });
+  }
+  loadItems(t) {
+    return o(this, null, function* () {
+      return Promise.all(t.map((e) => this.loadItem(e)));
+    });
+  }
+  loadItem(t) {
+    return o(this, null, function* () {
+      if (this.digitalItemMap.has(t)) {
+        const e = this.digitalItemMap.get(t);
+        return Promise.resolve(e);
+      } else
+        return new Promise((e, a) => {
+          t.endsWith(".gltf") || t.endsWith(".glb") ? this.gltfLoader.load(t, ({ scene: i }) => {
+            this.digitalItemMap.set(t, i), e(i);
+          }) : a(new Error("不支持的模型格式"));
+        });
+    });
+  }
+  getDigitalItem(t) {
+    return this.digitalItemMap.get(t) || null;
+  }
+  pause() {
+    this.digitalHumanMap.forEach((t) => {
+      t.pauseAnimation();
+    });
+  }
+  continue() {
+    this.digitalHumanMap.forEach((t) => {
+      t.continueAnimation();
+    });
+  }
+  reset() {
+    this.digitalHumanMap.forEach((t) => {
+      t.reset();
+    });
+  }
+  setTimelineTo(t) {
+    this.digitalHumanMap.forEach((e) => {
+      e.state.currentTime = t;
+    });
+  }
+  /**
+   * 销毁 playground
+   */
+  dispose() {
+    this.digitalHumanMap.forEach((t) => {
+      t.reset();
+    }), this.digitalHumanMap.clear(), this.digitalItemMap.clear(), this.skeletalAnimationMap.clear();
+  }
+}
+export {
+  k as DigitalPlayground
+};

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

@@ -0,0 +1,143 @@
+import * as THREE from 'three';
+interface DigitalScript {
+    name: string;
+    uuid: string;
+    assets: {
+        models: string[];
+        animations: string[];
+    };
+    chapters: DigitalChapter[];
+}
+interface DigitalDataPlayer {
+    name: string;
+    type: 'data';
+    data: DigitalModelKeyframe[];
+}
+interface DigitalModelPlayerItem {
+    name: string;
+    initialMatrix: number[];
+    attachedBone: string;
+    model: string;
+    keyframes: DigitalItemKeyframe[];
+}
+interface DigitalEffectKeyframe {
+    timeStamp: number;
+    image: string;
+    visible: boolean;
+}
+interface DigitalModelPlayerEffect {
+    type: 'frameSequence';
+    position: number[];
+    keyframes: DigitalEffectKeyframe[];
+}
+interface DigitalModelPlayer {
+    id: string;
+    name: string;
+    type: 'model';
+    model: string;
+    keyframes: DigitalModelKeyframe[];
+    items: DigitalModelPlayerItem[];
+    effects: DigitalModelPlayerEffect[];
+}
+interface DigitalSubTitlePlayer {
+    name: string;
+    type: 'subTitle';
+    keyframes: DigitalSubTitleKeyframe[];
+}
+interface DigitalCameraPlayer {
+    name: string;
+    type: 'camera';
+    keyframes: DigitalCameraKeyframe[];
+}
+interface DigitalChapter {
+    name: string;
+    players: Array<DigitalModelPlayer | DigitalSubTitlePlayer | DigitalCameraPlayer>;
+}
+interface DigitalItemKeyframe {
+    timeStamp: number;
+    visible: boolean;
+}
+interface DigitalCameraKeyframe {
+    timeStamp: number;
+    matrix: number[];
+    fov: number;
+}
+interface DigitalSubTitleKeyframe {
+    visible: boolean;
+    timeStamp: number;
+    title: string;
+    content: string;
+    audio?: string;
+    image?: string;
+}
+interface DigitalModelKeyframe {
+    visible: boolean;
+    timeStamp: number;
+    animation?: {
+        url: string;
+        repeat: boolean;
+        isOver?: boolean;
+        switchDuration?: number;
+    };
+    position: number[];
+    interpolationType?: 'linear' | 'parabola';
+    quaternion: number[];
+    scale: number[];
+    adddon?: {
+        text?: string;
+        audio?: string;
+    };
+}
+interface DigitalDataKeyframe {
+    timeStamp: number;
+    data: any;
+}
+interface DigitalModelState {
+    translation: THREE.Vector3;
+    quaternion: THREE.Quaternion;
+    scale: THREE.Vector3;
+    animation?: DigitalModelKeyframe['animation'];
+    keyframeIndex: number;
+    visible: boolean;
+    isFinal: boolean;
+}
+interface DigitalSubTitleState {
+    title: string;
+    content: string;
+    audio?: string;
+    image?: string;
+    keyframeIndex: number;
+}
+interface DigitalCameraState {
+    matrix: number[];
+    fov: number;
+    transitionType: 'linear' | 'instant';
+}
+interface DigitalDataState {
+    currentFrameData: DigitalDataKeyframe['data'];
+    nextFrameData: DigitalDataKeyframe['data'] | null;
+    progress: number;
+}
+interface DigitalItemState {
+    timeStamp: number;
+    visible: boolean;
+}
+interface DigitalEffectState {
+    image: string;
+    visible: boolean;
+}
+type KeyframeType<T> = T extends 'model' ? DigitalModelKeyframe : T extends 'camera' ? DigitalCameraKeyframe : T extends 'subtitle' ? DigitalSubTitleKeyframe : T extends 'data' ? DigitalDataKeyframe : T extends 'item' ? DigitalItemKeyframe : T extends 'effect' ? DigitalEffectKeyframe : never;
+type StateType<T> = T extends 'model' ? DigitalModelState : T extends 'camera' ? DigitalCameraState : T extends 'subtitle' ? DigitalSubTitleState : T extends 'data' ? DigitalDataState : T extends 'item' ? DigitalItemState : T extends 'effect' ? DigitalEffectState : never;
+declare class DigitalStateMachine {
+    constructor();
+    getStateByTime<T extends 'model' | 'camera' | 'subtitle' | 'data' | 'item' | 'effect'>(time: number, keyframes: Array<KeyframeType<T>>, type: T): StateType<T>;
+    private getDataStateByTime;
+    private getEffectStateByTime;
+    private getItemStateByTime;
+    private getCameraStateByTime;
+    private getSubtitleStateByTime;
+    private getModelStateByTime;
+    private getKeyframeIndexByTime;
+}
+export { DigitalStateMachine };
+export type { DigitalModelPlayerEffect, DigitalEffectKeyframe, DigitalDataState, DigitalModelPlayerItem, DigitalDataPlayer, DigitalCameraKeyframe, DigitalChapter, DigitalModelKeyframe, DigitalScript, DigitalSubTitleKeyframe, DigitalModelPlayer, DigitalSubTitlePlayer, DigitalCameraPlayer, DigitalModelState, DigitalSubTitleState, DigitalCameraState, KeyframeType, StateType, };

package/libs/DigitalPerformancePlugin/core/DigitalStateMachine.js

@@ -0,0 +1,153 @@
+import * as n from "three";
+class T {
+  constructor() {
+  }
+  getStateByTime(r, t, e) {
+    switch (e) {
+      case "model":
+        return this.getModelStateByTime(r, t);
+      case "camera":
+        return this.getCameraStateByTime(r, t);
+      case "subtitle":
+        return this.getSubtitleStateByTime(r, t);
+      case "data":
+        return this.getDataStateByTime(r, t);
+      case "item":
+        return this.getItemStateByTime(r, t);
+      case "effect":
+        return this.getEffectStateByTime(r, t);
+      default:
+        throw new Error(`Unsupported type: ${e}`);
+    }
+  }
+  getDataStateByTime(r, t) {
+    const e = this.getKeyframeIndexByTime(r, t);
+    if (e === t.length - 1)
+      return {
+        currentFrameData: t[e].data,
+        nextFrameData: null,
+        progress: 0
+      };
+    {
+      const a = t[e].data, o = t[e + 1].data, i = t[e + 1].timeStamp - t[e].timeStamp, l = (r - t[e].timeStamp) / i;
+      return {
+        currentFrameData: a,
+        nextFrameData: o,
+        progress: l
+      };
+    }
+  }
+  getEffectStateByTime(r, t) {
+    const e = this.getKeyframeIndexByTime(r, t);
+    return {
+      image: t[e].image,
+      visible: t[e].visible
+    };
+  }
+  getItemStateByTime(r, t) {
+    const e = this.getKeyframeIndexByTime(r, t);
+    return {
+      timeStamp: t[e].timeStamp,
+      visible: t[e].visible
+    };
+  }
+  getCameraStateByTime(r, t) {
+    const e = this.getKeyframeIndexByTime(r, t);
+    return {
+      matrix: t[e].matrix,
+      fov: t[e].fov,
+      transitionType: "linear"
+    };
+  }
+  getSubtitleStateByTime(r, t) {
+    const e = this.getKeyframeIndexByTime(r, t);
+    return {
+      title: t[e].title,
+      content: t[e].content,
+      audio: t[e].audio,
+      image: t[e].image,
+      keyframeIndex: e
+    };
+  }
+  getModelStateByTime(r, t) {
+    var l;
+    const e = this.getKeyframeIndexByTime(r, t);
+    if (e === t.length - 1)
+      return {
+        translation: new n.Vector3().fromArray(t[e].position),
+        quaternion: new n.Quaternion().fromArray(t[e].quaternion),
+        scale: new n.Vector3().fromArray(t[e].scale),
+        keyframeIndex: e,
+        animation: t[e].animation,
+        visible: t[e].visible,
+        isFinal: !0
+      };
+    const a = t[e], o = t[e + 1], i = r - a.timeStamp;
+    if (((l = o.interpolationType) != null ? l : "linear") === "parabola") {
+      const u = o.timeStamp - a.timeStamp, s = Math.min(i / u, 1), p = S(
+        new n.Vector3().fromArray(a.position),
+        new n.Vector3().fromArray(o.position)
+      )(s), y = s, w = new n.Quaternion().copy(
+        new n.Quaternion().fromArray(a.quaternion).slerp(new n.Quaternion().fromArray(o.quaternion), y)
+      ), x = new n.Vector3().lerpVectors(
+        new n.Vector3().fromArray(a.scale),
+        new n.Vector3().fromArray(o.scale),
+        s
+      );
+      return {
+        translation: p,
+        quaternion: w,
+        scale: x,
+        keyframeIndex: e,
+        animation: a.animation,
+        visible: a.visible,
+        isFinal: !1
+      };
+    } else {
+      const u = o.timeStamp - a.timeStamp, s = Math.min(i / u, 1), d = new n.Vector3().lerpVectors(
+        new n.Vector3().fromArray(a.position),
+        new n.Vector3().fromArray(o.position),
+        s
+      ), p = s, y = new n.Quaternion().copy(
+        new n.Quaternion().fromArray(a.quaternion).slerp(new n.Quaternion().fromArray(o.quaternion), p)
+      ), w = new n.Vector3().lerpVectors(
+        new n.Vector3().fromArray(a.scale),
+        new n.Vector3().fromArray(o.scale),
+        s
+      );
+      return {
+        translation: d,
+        quaternion: y,
+        scale: w,
+        keyframeIndex: e,
+        animation: a.animation,
+        visible: a.visible,
+        isFinal: !1
+      };
+    }
+  }
+  getKeyframeIndexByTime(r, t) {
+    r < 0 && (r = 0);
+    let e = 0, a = t.length - 1, o = -1;
+    for (; e <= a; ) {
+      const i = Math.floor((e + a) / 2);
+      if (t[i].timeStamp === r) {
+        o = i;
+        break;
+      } else
+        t[i].timeStamp < r ? e = i + 1 : a = i - 1;
+    }
+    return o !== -1 ? o : a;
+  }
+}
+function S(c, r) {
+  return (e) => {
+    const a = Math.sqrt(Math.pow(r.x - c.x, 2) + Math.pow(r.z - c.z, 2)), o = e * a, i = new n.Vector2(c.x, c.z).add(
+      new n.Vector2(r.x, r.z).sub(new n.Vector2(c.x, c.z)).normalize().multiplyScalar(o)
+    ), m = (r.y - c.y) / (Math.pow(r.x - c.x, 2) + Math.pow(r.z - c.z, 2)) * Math.pow(o, 2) + c.y;
+    return new n.Vector3(i.x, m, i.y);
+  };
+}
+export {
+  T as DigitalStateMachine
+};