@realsee/dnalogel 3.80.8-alpha.2 → 3.81.0-alpha.1

package/libs/DigitalPerformanceV2Plugin/controller/index.js

@@ -0,0 +1,750 @@
+var k = Object.defineProperty;
+var C = Object.getOwnPropertySymbols;
+var S = Object.prototype.hasOwnProperty, w = Object.prototype.propertyIsEnumerable;
+var d = (l, e, t) => e in l ? k(l, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : l[e] = t, g = (l, e) => {
+  for (var t in e || (e = {}))
+    S.call(e, t) && d(l, t, e[t]);
+  if (C)
+    for (var t of C(e))
+      w.call(e, t) && d(l, t, e[t]);
+  return l;
+};
+var h = (l, e, t) => (d(l, typeof e != "symbol" ? e + "" : e, t), t);
+var c = (l, e, t) => new Promise((r, a) => {
+  var s = (i) => {
+    try {
+      o(t.next(i));
+    } catch (u) {
+      a(u);
+    }
+  }, n = (i) => {
+    try {
+      o(t.throw(i));
+    } catch (u) {
+      a(u);
+    }
+  }, o = (i) => i.done ? r(i.value) : Promise.resolve(i.value).then(s, n);
+  o((t = t.apply(l, e)).next());
+});
+import { PerformancePlayground as F, getChapterModelDuration as T, getChapterDuration as b } from "../core/Playground.js";
+import { CameraTrack as E } from "../core/CameraTrack.js";
+import "three";
+import "../../DigitalPerformancePlugin/core/DigitalPlayground.js";
+import "@realsee/five/gltf-loader";
+import "../../DigitalPerformancePlugin/core/DigitalHuman.js";
+import "../../DigitalPerformancePlugin/core/DigitalStateMachine.js";
+import "../../DigitalPerformancePlugin/core/Trace.js";
+import "@realsee/five";
+import "../core/PerformanceClock.js";
+import "../core/CameraDirector.js";
+import "../core/FiveModelCameraBridge.js";
+import "../core/CameraSampler.js";
+const M = "Dnalogel-DigitalPerformanceV2Plugin", P = "five-world";
+class B {
+  constructor(e, t = {}) {
+    h(this, "five");
+    h(this, "config");
+    h(this, "NAME", M);
+    h(this, "playground");
+    h(this, "state", {
+      enabled: !0,
+      playing: !1,
+      continuousPlaying: !1,
+      currentChapter: null,
+      currentScript: null,
+      selectedShotIndex: null
+    });
+    h(this, "progressListeners", /* @__PURE__ */ new Set());
+    h(this, "groupProgressListeners", /* @__PURE__ */ new Set());
+    h(this, "keyframesChangedListeners", /* @__PURE__ */ new Set());
+    h(this, "currentChapterChangedListeners", /* @__PURE__ */ new Set());
+    h(this, "unsubClockTick", null);
+    /**
+     * 进入编辑时的运镜内存态快照：以章节对象为 key，值为该章节相机关键帧的深拷贝；
+     * 值为 null 表示进入编辑时该章节不存在 camera player。null（整体）表示尚未打过快照。
+     */
+    h(this, "cameraEditSnapshot", null);
+    /**
+     * 组级章节时间映射缓存（加法式）：按 currentScript 引用缓存。
+     * - `groupChapterTimeMapCacheScript` 记录缓存对应的 script 引用；
+     * - script 变更 / loadScript 时引用不一致 ⇒ 缓存失效、下次请求重算。
+     */
+    h(this, "groupChapterTimeMapCache", null);
+    h(this, "groupChapterTimeMapCacheScript", null);
+    /**
+     * D-SEEK-LIVE（方案 A）：连播中「跨章 seek」的重定向令牌。
+     * 播放态跨章 seek 时置位 { index, fromTime } 并 abortCurrentPlay；连播循环 await 返回后据此跳转到目标章节继续播放。
+     */
+    h(this, "seekRedirect", null);
+    /**
+     * 加法式：动画组「章节索引 → 楼层」映射（用于 Mapview 只显示当前章节所在楼层）。
+     * - number：该章节单一楼层 ⇒ `five.model.show(floor)`；
+     * - null：该章节内多段动画跨楼层 ⇒ `five.model.show()`（显示全部，避免藏掉其它层的动画）；
+     * - 映射缺项按显示全部处理。
+     * `null`（整体）表示未启用该能力（不触碰楼层可见性）。由消费方经 `setChapterFloorMap` 注入。
+     */
+    h(this, "chapterFloorMap", null);
+    this.five = e, this.config = g({ autoPlay: !1, loop: !1, debug: !1 }, t), this.playground = new F(e, this.config.debug), this.unsubClockTick = this.playground.getClock().onTick(() => this.emitProgress());
+  }
+  /** 加载剧本：预加载资源 + 将模型加入 five 场景；autoPlay 时自动播放首章 */
+  loadScript(e) {
+    return c(this, null, function* () {
+      if (this.state.currentScript = e, this.playground.setScript(e), this.groupChapterTimeMapCache = null, this.groupChapterTimeMapCacheScript = null, this.chapterFloorMap = null, yield this.preloadResources(e), this.five && this.five.scene) {
+        yield new Promise((r) => requestAnimationFrame(() => r()));
+        let t = 0;
+        if (e.chapters.forEach((r) => {
+          r.players.forEach((a) => {
+            if (a.type === "model") {
+              const s = this.playground.loader.getDigitalHuman(a.model, a.id);
+              s != null && s.container && (this.five.scene.add(s.container), t++);
+            }
+          });
+        }), t === 0)
+          throw new Error("没有模型被添加到场景中");
+      }
+      this.config.autoPlay && e.chapters.length > 0 && (yield this.playChapter(e.chapters[0]));
+    });
+  }
+  /** 播放指定章节 */
+  playChapter(e) {
+    return c(this, null, function* () {
+      this.state.currentChapter = e, this.applyChapterFloor(this.getCurrentChapterIndex()), this.state.continuousPlaying = !1, this.state.playing = !0;
+      try {
+        yield this.playground.playByChapter(e);
+      } finally {
+        this.state.playing = !1, this.emitProgress();
+      }
+    });
+  }
+  /** 通过索引播放章节 */
+  playChapterByIndex(e) {
+    return c(this, null, function* () {
+      const t = this.getChapters();
+      if (e < 0 || e >= t.length)
+        throw new Error("Invalid chapter index");
+      yield this.playChapter(t[e]);
+    });
+  }
+  /** 从当前章节连续播放到最后一章（连播中跨章 seek 可经 seekRedirect 令牌无缝重定向） */
+  playAllRemaining() {
+    return c(this, null, function* () {
+      const e = this.getChapters();
+      if (e.length === 0)
+        throw new Error("No chapters to play");
+      let t = 0;
+      if (this.state.currentChapter) {
+        const r = e.findIndex((a) => a.name === this.state.currentChapter.name);
+        t = r === -1 ? 0 : r;
+      }
+      this.state.continuousPlaying = !0, this.state.playing = !0, this.seekRedirect = null;
+      try {
+        for (; t >= 0 && t < e.length && this.state.continuousPlaying; ) {
+          let r = 0;
+          if (this.seekRedirect && this.seekRedirect.index === t && (r = this.seekRedirect.fromTime), this.seekRedirect = null, this.state.currentChapter = e[t], this.applyChapterFloor(t), this.emitProgress(), yield this.playground.playByChapter(e[t], r), this.seekRedirect) {
+            t = this.seekRedirect.index;
+            continue;
+          }
+          t++;
+        }
+      } finally {
+        this.state.playing = !1, this.state.continuousPlaying = !1, this.seekRedirect = null, this.emitProgress();
+      }
+    });
+  }
+  /** 从第一章开始按顺序连续播放（用于"重播全部"，保留已捕获的各章节运镜） */
+  playAllFromStart() {
+    return c(this, null, function* () {
+      yield this.playFromChapterIndex(0);
+    });
+  }
+  /** 从指定章节索引开始，按顺序连续播放到本动画组最后一章（保留已捕获的各章节运镜） */
+  playFromChapterIndex(e) {
+    return c(this, null, function* () {
+      const t = this.getChapters();
+      if (t.length === 0)
+        throw new Error("No chapters to play");
+      const r = e < 0 ? 0 : e >= t.length ? t.length - 1 : e;
+      this.state.currentChapter = t[r], yield this.playAllRemaining();
+    });
+  }
+  /**
+   * 编辑态：仅播放当前章节（不连播下一章）。
+   * 章节自然播放到末尾（ended）后，由 controller 执行「进度归零 + 恢复当前章节默认视角」，
+   * SHALL NOT 自动连播下一章节（区别于展示端 playAllRemaining 的章节连续播放）。
+   * 无当前章节时为 no-op。
+   */
+  playCurrentChapterForEdit() {
+    return c(this, null, function* () {
+      const e = this.state.currentChapter;
+      if (!e)
+        return;
+      const t = this.getCurrentChapterIndex(), r = this.playground.getClock().getTime();
+      this.state.continuousPlaying = !1, this.state.playing = !0;
+      try {
+        yield this.playground.playByChapter(e, r, {
+          prepare: () => this.playground.prepareCameraTo(r)
+        });
+      } finally {
+        this.state.playing = !1, this.playground.setTimelineTo(0), this.applyChapterDefaultView(t), this.emitProgress();
+      }
+    });
+  }
+  /** 暂停 */
+  pause() {
+    this.playground.pause(), this.state.playing = !1, this.emitProgress();
+  }
+  continue(e) {
+    if (e != null && e.prepare)
+      return (() => c(this, null, function* () {
+        yield this.playground.prepareCameraTo(this.playground.getClock().getTime()), this.playground.resume(), this.state.playing = !0, this.emitProgress();
+      }))();
+    this.playground.resume(), this.state.playing = !0, this.emitProgress();
+  }
+  /**
+   * 编辑态暂停（playing→paused，相机由「导演」交还「用户」拥有）。
+   * 统一 Mapview 后，导演接管期间 five 始终是合法 Mapview orbit 状态，暂停瞬间画面不变、
+   * 且 five 手势天然为正常模型视角（左键绕 target orbit、右键平移），无需特殊转换。见设计 §5.3.1。
+   * 仅供编辑端（camera-mode）暂停路径调用。
+   */
+  pauseForEdit() {
+    this.pause();
+  }
+  /**
+   * 编辑态续播（当前章节）：在恢复时钟前先 `await prepareCameraTo(当前时间)`，
+   * 以内插动画平滑回到暂停瞬间对应的运镜视角（无突变 user→director 切换，Req 13.9 / 18.9），
+   * prepare 不计入播放时间（时钟在 prepare 期间不推进）后再 resume。
+   * 章节无运镜关键帧时 prepare 为 no-op。不改变通用 `continue()`/`pause()` 语义。
+   */
+  continueForEdit() {
+    return c(this, null, function* () {
+      yield this.playground.prepareCameraTo(this.playground.getClock().getTime()), this.playground.resume(), this.state.playing = !0, this.emitProgress();
+    });
+  }
+  /** 运镜开关：关闭后播放仅驱动模型动画，不接管 five 相机（立即生效） */
+  setCameraDirectionEnabled(e) {
+    this.playground.setCameraDirectionEnabled(e);
+  }
+  /**
+   * 加法式：设置「章节索引 → 楼层」映射，启用「播放/切章时 Mapview 只显示当前章节所在楼层」。
+   * - number：该章节单一楼层；null：该章节内跨楼层 → 显示全部；映射缺项按显示全部处理。
+   * - 传入非 null：立即对当前章节应用一次；此后在任意章节切换（连播推进 / 切章 / 播放预览切章）时自动应用。
+   * - 传入 null：停用该能力（不再随章节应用），但**不主动恢复**楼层可见性（恢复由 `reset()` 负责）。
+   * 楼层可见性是 five 空间模型的显隐（`five.model.show`），与运镜相机接管相互独立。
+   * 各消费方（workshop 编辑端 / NextVR 展示端）自行从各自数据算好映射注入，保证两端行为一致（parity）。
+   */
+  setChapterFloorMap(e) {
+    if (this.chapterFloorMap = e, e) {
+      const t = this.getCurrentChapterIndex();
+      this.applyChapterFloor(t >= 0 ? t : 0);
+    }
+  }
+  /** 按章节楼层映射对指定章节应用楼层可见性（映射未启用时 no-op） */
+  applyChapterFloor(e) {
+    if (!this.chapterFloorMap)
+      return;
+    const t = e in this.chapterFloorMap ? this.chapterFloorMap[e] : null;
+    this.showModelFloor(typeof t == "number" ? t : void 0);
+  }
+  /** 显示指定楼层（传 undefined 显示全部）。安全访问 five.model.show，避免类型/运行时缺失。 */
+  showModelFloor(e) {
+    var r, a, s;
+    const t = (r = this.five) == null ? void 0 : r.model;
+    typeof e == "number" ? (a = t == null ? void 0 : t.show) == null || a.call(t, e) : (s = t == null ? void 0 : t.show) == null || s.call(t);
+  }
+  /**
+   * seek 预览：跳转到指定时间并渲染当前帧（不改变播放/暂停状态）。
+   * - 无当前章节：不改时钟、不渲染，返回失败指示且不抛异常。
+   * - 运镜启用：经 director seek 应用相机；运镜禁用：仅驱动 DigitalHuman。
+   */
+  setTimelineTo(e) {
+    return this.state.currentChapter ? (this.playground.setTimelineTo(e), this.state.playing || this.playground.previewCameraAt(this.playground.getClock().getTime()), this.emitProgress(), { success: !0 }) : { success: !1, error: "无当前章节" };
+  }
+  /**
+   * 在指定时间捕获当前 five 相机为一个运镜关键帧。
+   * - 位姿取自 five 当前 Mapview 状态（target=offset、longitude、latitude、distance）；fov 取自 fiveState（缺省读 five.getCurrentState()）。
+   * - 按 timeStamp 升序插入；同 timeStamp 覆盖。
+   * 拒绝（保持序列不变并返回 error）：未加载 script / 无当前章节 / time 非负有限数校验失败。
+   */
+  addCameraKeyframe(e, t, r) {
+    const a = this.guardKeyframeEdit();
+    if (a)
+      return a;
+    if (!(Number.isFinite(e) && e >= 0))
+      return this.rejectKeyframe("time 必须为非负有限数");
+    const s = this.ensureCameraPlayer(), n = this.captureCameraPose(), o = this.resolveFov(t), i = {
+      timeStamp: e,
+      target: n.target,
+      longitude: n.longitude,
+      latitude: n.latitude,
+      distance: n.distance,
+      fov: o
+    };
+    r != null && r.transition && (i.transition = r.transition), r != null && r.thumbnail && (i.thumbnail = r.thumbnail);
+    const u = s.keyframes.findIndex((m) => m.timeStamp === e);
+    return u >= 0 ? s.keyframes[u] = i : s.keyframes.push(i), s.keyframes.sort((m, p) => m.timeStamp - p.timeStamp), this.afterKeyframesChanged(s);
+  }
+  /**
+   * 更新指定下标关键帧：合并 patch 中出现的字段，按 timeStamp 重排序。
+   * 拒绝（保持序列不变）：未加载 script / 无章节 / index 越界 / patch.timeStamp 非负有限数校验失败。
+   */
+  updateCameraKeyframe(e, t) {
+    const r = this.guardKeyframeEdit();
+    if (r)
+      return r;
+    const a = this.getCameraPlayer();
+    if (!a || e < 0 || e >= a.keyframes.length)
+      return this.rejectKeyframe("index 越界");
+    if (t.timeStamp !== void 0 && !(Number.isFinite(t.timeStamp) && t.timeStamp >= 0))
+      return this.rejectKeyframe("time 必须为非负有限数");
+    const s = g(g({}, a.keyframes[e]), t);
+    return a.keyframes[e] = s, a.keyframes.sort((n, o) => n.timeStamp - o.timeStamp), this.afterKeyframesChanged(a);
+  }
+  /** 移除指定下标关键帧。拒绝（保持序列不变）：未加载 script / 无章节 / index 越界。 */
+  removeCameraKeyframe(e) {
+    const t = this.guardKeyframeEdit();
+    if (t)
+      return t;
+    const r = this.getCameraPlayer();
+    return !r || e < 0 || e >= r.keyframes.length ? this.rejectKeyframe("index 越界") : (r.keyframes.splice(e, 1), this.afterKeyframesChanged(r));
+  }
+  /** 获取当前章节的运镜关键帧（升序副本；无章节/无 camera player 时返回空数组） */
+  getCameraKeyframes() {
+    const e = this.getCameraPlayer();
+    return e ? e.keyframes.map((t) => g({}, t)) : [];
+  }
+  /**
+   * 序列化当前章节的运镜 player。
+   * keyframes 按 timeStamp 升序，仅写入已设置的可选字段（不写 undefined 占位）。
+   * 空/无 camera player 返回 keyframes:[]；未加载 script / 无章节 时拒绝并返回 error。
+   */
+  serializeCameraPlayer() {
+    var t;
+    if (!this.state.currentScript)
+      return { success: !1, error: "未加载剧本" };
+    if (!this.state.currentChapter)
+      return { success: !1, error: "无当前章节" };
+    const e = this.getCameraPlayer();
+    return {
+      success: !0,
+      player: {
+        name: (t = e == null ? void 0 : e.name) != null ? t : "camera",
+        type: "camera",
+        keyframes: this.serializeKeyframes(e),
+        coordinateSpace: P
+      }
+    };
+  }
+  /**
+   * 序列化全部章节中"含非空关键帧"的运镜 player，按章节索引返回。
+   * 供编辑端按"章节起始动画 id"聚合后整组保存。未加载 script 时返回空数组。
+   */
+  serializeAllCameraPlayers() {
+    if (!this.state.currentScript)
+      return [];
+    const e = [];
+    return this.getChapters().forEach((t, r) => {
+      var s;
+      const a = this.cameraPlayerOf(t);
+      a && a.keyframes.length > 0 && e.push({
+        chapterIndex: r,
+        player: {
+          name: (s = a.name) != null ? s : "camera",
+          type: "camera",
+          keyframes: this.serializeKeyframes(a),
+          coordinateSpace: P
+        }
+      });
+    }), e;
+  }
+  /**
+   * 按章节索引批量加载运镜（用于从持久化数据还原）：替换对应章节 camera player 的关键帧。
+   * 调用方负责"对账"（只传锚点命中的章节），越界索引忽略。
+   */
+  loadCameraPlayersByChapterIndex(e) {
+    const t = this.getChapters();
+    Object.keys(e).forEach((a) => {
+      var u, m;
+      const s = Number(a);
+      if (!Number.isInteger(s) || s < 0 || s >= t.length)
+        return;
+      const n = t[s], o = e[s];
+      let i = n.players.find((p) => p.type === "camera");
+      i || (i = { name: (u = o.name) != null ? u : "camera", type: "camera", keyframes: [] }, n.players.push(i)), i.keyframes = [...(m = o.keyframes) != null ? m : []].sort((p, f) => p.timeStamp - f.timeStamp), o.coordinateSpace && (i.coordinateSpace = o.coordinateSpace);
+    });
+    const r = this.cameraPlayerOf(this.state.currentChapter);
+    r && this.playground.setCameraKeyframes(r.keyframes);
+  }
+  /** 注册关键帧序列变更监听（camera-keyframes-changed）；返回反订阅函数 */
+  onCameraKeyframesChanged(e) {
+    return this.keyframesChangedListeners.add(e), () => this.keyframesChangedListeners.delete(e);
+  }
+  // —— 编辑端加法式新增能力（Requirement 18 / design Part III §7）——
+  /**
+   * 章节默认视角（Chapter_Default_View）。
+   * - 章节存在 ≥1 个运镜关键帧：返回该章节相机轨道 `sample(0)`（因首帧夹紧，等于首帧 CameraState）。
+   * - 章节存在 0 个运镜关键帧：返回 `undefined`。
+   * 默认视角不单独持久化，完全由关键帧派生（不在 cameraPlayers 新增字段）。
+   */
+  getChapterDefaultView(e) {
+    const t = this.buildChapterCameraTrack(e);
+    if (!(!t || !t.hasContent()))
+      return t.sample(0);
+  }
+  /**
+   * 应用章节默认视角到 five。
+   * - 章节存在关键帧：经 FiveModelCameraBridge 立即应用 `sample(0)`。
+   * - 章节存在 0 个关键帧：no-op（保持当前 five 相机状态、不强制移动）。
+   */
+  applyChapterDefaultView(e) {
+    const t = this.getChapterDefaultView(e);
+    t && this.playground.applyCameraStateImmediately(t);
+  }
+  /**
+   * 设为当前编辑章节（不开始播放）。该次调用内联动完成：
+   * 切暂停 → `seek(0)`（进度归零、各 DigitalHuman 渲染 t=0）→ 重建 director 轨道到该章节关键帧 →
+   * 应用该章节默认视角 → 读取并更新该章节总时长 → 清除已选中运镜项 → 派发 onCurrentChapterChanged。
+   * 越界索引为 no-op。
+   */
+  setCurrentChapter(e) {
+    const t = this.getChapters();
+    if (e < 0 || e >= t.length)
+      return;
+    const r = t[e];
+    this.playground.pause(), this.state.playing = !1, this.state.currentChapter = r, this.playground.prepareChapter(r, 0), this.applyChapterFloor(e), this.applyChapterDefaultView(e), this.state.selectedShotIndex = null, this.emitProgress(), this.emitCurrentChapterChanged();
+  }
+  /** 当前章节信息：{ index, name, duration }；duration 为该章节模型动画时长（排除相机 player） */
+  getCurrentChapterInfo() {
+    const e = this.state.currentChapter;
+    return e ? {
+      index: this.getCurrentChapterIndex(),
+      name: e.name,
+      duration: T(e)
+    } : { index: -1, name: "", duration: 0 };
+  }
+  /** 注册当前章节变更监听（current-chapter-changed）；返回反订阅函数 */
+  onCurrentChapterChanged(e) {
+    return this.currentChapterChangedListeners.add(e), () => this.currentChapterChangedListeners.delete(e);
+  }
+  /**
+   * 进入运镜编辑：对全部章节运镜内存态打一次深快照（供 discardCameraChanges 还原）。
+   * 仅记录内存快照，不触碰持久化、不改相机/播放状态。
+   */
+  beginCameraEditSession() {
+    const e = /* @__PURE__ */ new Map();
+    this.getChapters().forEach((t) => {
+      const r = this.cameraPlayerOf(t);
+      e.set(t, r ? this.cloneKeyframes(r.keyframes) : null);
+    }), this.cameraEditSnapshot = e;
+  }
+  /**
+   * 放弃运镜修改：将运镜内存态还原到 `beginCameraEditSession` 时的快照（不走服务端重载）。
+   * 未打过快照时为 no-op。还原后重建当前章节 director 轨道并派发关键帧变更事件。
+   */
+  discardCameraChanges() {
+    const e = this.cameraEditSnapshot;
+    if (!e)
+      return;
+    e.forEach((r, a) => {
+      const s = this.cameraPlayerOf(a);
+      if (r === null)
+        s && (s.keyframes = []);
+      else if (s)
+        s.keyframes = this.cloneKeyframes(r);
+      else {
+        const n = { name: "camera", type: "camera", keyframes: this.cloneKeyframes(r) };
+        a.players.push(n);
+      }
+    });
+    const t = this.cameraPlayerOf(this.state.currentChapter);
+    this.playground.setCameraKeyframes(t ? t.keyframes : []), this.emitKeyframesChanged(this.getCameraKeyframes());
+  }
+  /** 当前进度（当前章节内 currentTime/totalTime，单位 ms；含当前章节索引/总章节数） */
+  getProgress() {
+    const e = this.playground.getClock(), t = e.getTime();
+    let r = e.getDuration();
+    r <= 0 && this.state.currentChapter && (r = b(this.state.currentChapter));
+    const a = this.getChapters(), s = this.state.currentChapter, n = s ? a.findIndex((o) => o === s || o.name === s.name) : -1;
+    return { currentTime: t, totalTime: r, currentChapterIndex: n, totalChapters: a.length };
+  }
+  /** 注册进度监听；返回反订阅函数 */
+  onProgressChanged(e) {
+    return this.progressListeners.add(e), () => this.progressListeners.delete(e);
+  }
+  /**
+   * 组级章节时间映射（加法式）：每章 { index, name, startTime, endTime, duration } 逐章累计。
+   * - duration[i] = getChapterModelDuration(chapters[i])（排除 camera player）
+   * - startTime[0]=0、startTime[i]=endTime[i-1]、endTime[i]=startTime[i]+duration[i]
+   * - 未加载 / 空章节组返回 []；纯读，不修改任何引擎状态。
+   * 按 currentScript 引用缓存；loadScript / script 变更时失效重算。
+   */
+  getGroupChapterTimeMap() {
+    const e = this.state.currentScript;
+    if (!e)
+      return [];
+    if (this.groupChapterTimeMapCache && this.groupChapterTimeMapCacheScript === e)
+      return this.groupChapterTimeMapCache;
+    const t = this.getChapters(), r = [];
+    let a = 0;
+    for (let s = 0; s < t.length; s++) {
+      const n = T(t[s]), o = a, i = o + n;
+      r.push({ index: s, name: t[s].name, startTime: o, endTime: i, duration: n }), a = i;
+    }
+    return this.groupChapterTimeMapCache = r, this.groupChapterTimeMapCacheScript = e, r;
+  }
+  /**
+   * 组级进度聚合（加法式）：由章节级 getProgress() + getGroupChapterTimeMap() 派生。
+   * - groupTotalTime = Σ duration
+   * - groupCurrentTime = startTime[currentChapterIndex] + clamp(currentTime, 0, duration[idx])（无当前章节为 0）
+   * - 0 ≤ groupCurrentTime ≤ groupTotalTime；percentage ∈ [0,100]（groupTotalTime=0 时为 0）
+   * 纯读，不修改任何引擎状态。
+   */
+  getGroupProgress() {
+    const e = this.getProgress(), t = this.getGroupChapterTimeMap(), r = t.length === 0 ? 0 : t[t.length - 1].endTime, a = e.currentChapterIndex;
+    let s = 0;
+    if (a >= 0 && a < t.length) {
+      const o = t[a].startTime, i = this.clamp(e.currentTime, 0, t[a].duration);
+      s = this.clamp(o + i, 0, r);
+    }
+    const n = r > 0 ? this.clamp(s / r * 100, 0, 100) : 0;
+    return {
+      groupCurrentTime: s,
+      groupTotalTime: r,
+      percentage: n,
+      currentChapterIndex: a,
+      currentChapterTime: e.currentTime,
+      currentChapterTotalTime: e.totalTime,
+      totalChapters: e.totalChapters
+    };
+  }
+  /**
+   * 注册组级进度监听（加法式，独立监听集合）；返回反订阅函数。
+   * 在既有 emitProgress() 内追加组级广播，每 tick / 章节切换 / pause / seek 时随章节级广播一并触发。
+   */
+  onGroupProgressChanged(e) {
+    return this.groupProgressListeners.add(e), () => this.groupProgressListeners.delete(e);
+  }
+  /**
+   * 播放/预览专用：设为当前章节（不开始播放，区别于编辑端 setCurrentChapter）。
+   * 透传 playground.prepareChapter：切模型可见性 + 重绑相机轨道 + 配置时钟时长并 seek 到 fromTime（不 start）。
+   * 不做编辑端默认视角设置 / 选中清理等联动。越界索引为 no-op。
+   */
+  setCurrentChapterForPlayback(e, t) {
+    const r = this.getChapters();
+    e < 0 || e >= r.length || (this.state.currentChapter = r[e], this.applyChapterFloor(e), this.playground.prepareChapter(r[e], t));
+  }
+  /**
+   * 跳转到组级时间(ms)：映射为 (章节 index, 章节内时间)，必要时切章后 setTimelineTo。
+   * 保留 seek 前的播放/暂停状态（D-SEEK-LIVE，方案 A）：
+   * - 暂停态：跨章则先 setCurrentChapterForPlayback 切章，再 setTimelineTo 预览该帧后交还用户。
+   * - 播放态同章：clock.seek 续播（经 setTimelineTo）。
+   * - 播放态跨章：置 seekRedirect 并 abortCurrentPlay，由连播循环跳到目标章节从 localTime 继续。
+   * 越界钳制到 [0, groupTotalTime]；未加载 script 返回 { success:false } 不抛异常。
+   */
+  seekToGroupTime(e) {
+    if (!this.state.currentScript)
+      return { success: !1, error: "未加载剧本" };
+    const t = this.getGroupChapterTimeMap();
+    if (t.length === 0)
+      return { success: !1, error: "无章节" };
+    const r = t[t.length - 1].endTime, a = this.clamp(e, 0, r), { index: s, localTime: n } = this.mapGroupTimeToChapter(a, t), o = s !== this.getCurrentChapterIndex();
+    if (this.state.playing && this.state.continuousPlaying && o)
+      return this.seekRedirect = { index: s, fromTime: n }, this.playground.abortCurrentPlay(), { success: !0 };
+    o && this.setCurrentChapterForPlayback(s, n);
+    const i = this.setTimelineTo(n);
+    return this.emitProgress(), i;
+  }
+  /** 跳转到组级百分比 [0,100]（= seekToGroupTime(clamp(pct,0,100)/100 * groupTotalTime)） */
+  seekToGroupPercentage(e) {
+    const t = this.getGroupChapterTimeMap(), r = t.length === 0 ? 0 : t[t.length - 1].endTime;
+    return this.seekToGroupTime(this.clamp(e, 0, 100) / 100 * r);
+  }
+  /**
+   * 组级时间 → (章节索引, 章节内时间)（加法式内部）。
+   * - g ≤ 0          → { index: 0, localTime: 0 }
+   * - g ≥ groupTotal → { index: last, localTime: duration[last] }
+   * - 否则 startTime[index] ≤ g < endTime[index] 且 localTime = g - startTime[index]
+   * - 零时长章节（start==end）被自动跳过（不会定位其内部）
+   * 前置条件：timeMap 非空。
+   */
+  mapGroupTimeToChapter(e, t) {
+    const r = t[t.length - 1], a = r.endTime;
+    if (e <= 0)
+      return { index: 0, localTime: 0 };
+    if (e >= a)
+      return { index: r.index, localTime: r.duration };
+    for (const s of t)
+      if (e < s.endTime)
+        return { index: s.index, localTime: e - s.startTime };
+    return { index: r.index, localTime: r.duration };
+  }
+  /** 数值钳制工具 */
+  clamp(e, t, r) {
+    return e < t ? t : e > r ? r : e;
+  }
+  /** 当前可用章节 */
+  getChapters() {
+    var e;
+    return ((e = this.state.currentScript) == null ? void 0 : e.chapters) || [];
+  }
+  /** 当前状态快照 */
+  getState() {
+    return { playing: this.state.playing, currentChapter: this.state.currentChapter };
+  }
+  /** 重置播放（保留已加载资源） */
+  reset() {
+    this.playground.reset(), this.state.playing = !1, this.state.continuousPlaying = !1, this.state.currentChapter = null, this.state.selectedShotIndex = null, this.seekRedirect = null, this.chapterFloorMap && (this.showModelFloor(), this.chapterFloorMap = null), this.emitProgress();
+  }
+  /** 销毁插件、释放资源 */
+  dispose() {
+    this.unsubClockTick && (this.unsubClockTick(), this.unsubClockTick = null), this.chapterFloorMap && (this.showModelFloor(), this.chapterFloorMap = null), this.progressListeners.clear(), this.keyframesChangedListeners.clear(), this.currentChapterChangedListeners.clear(), this.groupProgressListeners.clear(), this.cameraEditSnapshot = null, this.playground.dispose();
+  }
+  /** 预加载模型 / 动画 / 道具（复用 Shared_Core 加载） */
+  preloadResources(e) {
+    return c(this, null, function* () {
+      const t = [], r = [], a = /* @__PURE__ */ new Set(), s = [], n = /* @__PURE__ */ new Map();
+      e.chapters.forEach((o) => {
+        o.players.forEach((i) => {
+          if (i.type !== "model")
+            return;
+          const u = i;
+          t.push(u.model), r.push(i.id), u.keyframes.forEach((m) => {
+            var f, y;
+            if (!m.animation)
+              return;
+            a.add(m.animation.url);
+            const p = m.animation.item;
+            p && (s.push(p.url), n.set(p.url, {
+              position: (f = p.position) != null ? f : [0, 0, 0],
+              rotation: (y = p.rotation) != null ? y : [0, 0, 0]
+            }));
+          });
+        });
+      }), yield Promise.all([
+        this.playground.loader.loadModels(t, r),
+        this.playground.loader.loadItems(s, n),
+        this.playground.loader.loadAnimations(Array.from(a))
+      ]);
+    });
+  }
+  emitProgress() {
+    if (this.progressListeners.size > 0) {
+      const e = this.getProgress();
+      this.progressListeners.forEach((t) => t(e));
+    }
+    this.emitGroupProgress();
+  }
+  /** 组级进度广播（加法式新增；独立监听集合，既有 onProgressChanged 语义不变） */
+  emitGroupProgress() {
+    if (this.groupProgressListeners.size === 0)
+      return;
+    const e = this.getGroupProgress();
+    this.groupProgressListeners.forEach((t) => t(e));
+  }
+  // —— 运镜关键帧编辑辅助 ——
+  /** 编辑前置校验：未加载 script / 无当前章节时返回拒绝结果，否则返回 null */
+  guardKeyframeEdit() {
+    return this.state.currentScript ? this.state.currentChapter ? null : this.rejectKeyframe("无当前章节") : this.rejectKeyframe("未加载剧本");
+  }
+  /** 拒绝结果：保持当前序列不变并返回 error */
+  rejectKeyframe(e) {
+    return { success: !1, error: e, keyframes: this.getCameraKeyframes() };
+  }
+  /** 当前章节的 camera player（不存在返回 null） */
+  getCameraPlayer() {
+    return this.cameraPlayerOf(this.state.currentChapter);
+  }
+  /** 指定章节的 camera player（不存在返回 null） */
+  cameraPlayerOf(e) {
+    if (!e)
+      return null;
+    const t = e.players.find((r) => r.type === "camera");
+    return t != null ? t : null;
+  }
+  /** 把 camera player 的关键帧序列化为升序、仅含已设置可选字段的副本（Mapview 位姿） */
+  serializeKeyframes(e) {
+    return (e ? [...e.keyframes].sort((r, a) => r.timeStamp - a.timeStamp) : []).map((r) => {
+      const a = {
+        timeStamp: r.timeStamp,
+        target: [...r.target],
+        longitude: r.longitude,
+        latitude: r.latitude,
+        distance: r.distance,
+        fov: r.fov
+      };
+      return r.transition !== void 0 && (a.transition = r.transition), r.thumbnail !== void 0 && (a.thumbnail = r.thumbnail), a;
+    });
+  }
+  /** 获取当前章节的 camera player，不存在则创建并挂到章节 players 上 */
+  ensureCameraPlayer() {
+    const e = this.state.currentChapter;
+    let t = e.players.find((r) => r.type === "camera");
+    return t || (t = { name: "camera", type: "camera", keyframes: [] }, e.players.push(t)), t;
+  }
+  /** fov 取值：优先 fiveState.fov，否则读 five 当前状态 */
+  resolveFov(e) {
+    var r, a;
+    if (e && Number.isFinite(e.fov))
+      return e.fov;
+    const t = (a = (r = this.five).getCurrentState) == null ? void 0 : a.call(r).fov;
+    return Number.isFinite(t) ? t : 60;
+  }
+  /** 捕获 five 当前 Mapview 位姿（target=offset、longitude、latitude、distance） */
+  captureCameraPose() {
+    var r, a;
+    const e = (a = (r = this.five).getCurrentState) == null ? void 0 : a.call(r), t = e == null ? void 0 : e.offset;
+    return {
+      target: t ? [t.x, t.y, t.z] : [0, 0, 0],
+      longitude: Number.isFinite(e == null ? void 0 : e.longitude) ? e.longitude : 0,
+      latitude: Number.isFinite(e == null ? void 0 : e.latitude) ? e.latitude : 0,
+      distance: Number.isFinite(e == null ? void 0 : e.distance) ? e.distance : 0
+    };
+  }
+  /** 关键帧变更后：重建并绑定相机轨道（供 seek 预览/后续播放接管），派发事件，返回成功结果 */
+  afterKeyframesChanged(e) {
+    this.playground.setCameraKeyframes(e.keyframes);
+    const t = this.getCameraKeyframes();
+    return this.emitKeyframesChanged(t), { success: !0, keyframes: t };
+  }
+  emitKeyframesChanged(e) {
+    this.keyframesChangedListeners.forEach((t) => t(e.map((r) => g({}, r))));
+  }
+  emitCurrentChapterChanged() {
+    if (this.currentChapterChangedListeners.size === 0)
+      return;
+    const e = this.getCurrentChapterInfo();
+    this.currentChapterChangedListeners.forEach((t) => t(g({}, e)));
+  }
+  /** 当前章节索引（0-based；无当前章节为 -1），按引用或名称匹配 */
+  getCurrentChapterIndex() {
+    const e = this.state.currentChapter;
+    return e ? this.getChapters().findIndex((t) => t === e || t.name === e.name) : -1;
+  }
+  /** 由指定章节的相机关键帧构建一条 CameraTrack（无章节/无 camera player 返回 null） */
+  buildChapterCameraTrack(e) {
+    const t = this.getChapters();
+    if (e < 0 || e >= t.length)
+      return null;
+    const r = this.cameraPlayerOf(t[e]);
+    if (!r || r.keyframes.length === 0)
+      return null;
+    const a = new E();
+    return a.setKeyframes(r.keyframes), a;
+  }
+  /** 深拷贝关键帧序列（数组字段亦深拷贝），供快照/还原使用（Mapview 位姿） */
+  cloneKeyframes(e) {
+    return e.map((t) => {
+      const r = {
+        timeStamp: t.timeStamp,
+        target: [...t.target],
+        longitude: t.longitude,
+        latitude: t.latitude,
+        distance: t.distance,
+        fov: t.fov
+      };
+      return t.transition !== void 0 && (r.transition = t.transition), t.thumbnail !== void 0 && (r.thumbnail = t.thumbnail), r;
+    });
+  }
+}
+export {
+  B as default
+};