@realsee/dnalogel 3.77.4-alpha.0 → 3.77.4-alpha.2

package/dist/DigitalPerformancePlugin/controller/index.d.ts

@@ -0,0 +1,224 @@
+import type { Five } from '@realsee/five';
+import { DigitalPlayground } from '../core/DigitalPlayground';
+import type { DigitalHuman } from '../core/DigitalHuman';
+import type { DigitalScript, DigitalChapter, DigitalPerformancePluginConfig, GlobalProgress, ChapterTimeInfo, ChapterLocation, ProgressListener } from '../typings';
+export default class DigitalPerformancePluginController {
+    five: Five;
+    playground: DigitalPlayground;
+    config: DigitalPerformancePluginConfig;
+    state: {
+        enabled: boolean;
+        playing: boolean;
+        currentChapter: DigitalChapter | null;
+        currentScript: DigitalScript | null;
+        continuousPlaying: boolean;
+        playMode: 'single' | 'continuous';
+    };
+    NAME: string;
+    private totalDurationCache;
+    private chapterTimeMapCache;
+    private progressListeners;
+    private progressUpdateInterval;
+    private progressUpdateTimer;
+    private _autoPlayOnNaturalEnd;
+    private playingPlayersListeners;
+    constructor(five: Five, config?: DigitalPerformancePluginConfig);
+    /**
+     * 加载剧本数据
+     */
+    loadScript(script: DigitalScript): Promise<void>;
+    private init;
+    /**
+     * 预加载资源
+     */
+    private preloadResources;
+    /**
+     * 播放指定章节
+     */
+    playChapter(chapter: DigitalChapter): Promise<void>;
+    /**
+     * 播放指定章节（内部方法，用于连续播放）
+     */
+    private playChapterForContinuous;
+    /**
+     * 播放指定章节（通过索引）
+     */
+    playChapterByIndex(index: number): Promise<void>;
+    /**
+     * 暂停播放
+     */
+    pause(): void;
+    /**
+     * 继续播放
+     */
+    continue(): Promise<void>;
+    /**
+     * 连续播放模式下的继续播放（从暂停位置继续播放所有剩余章节）
+     */
+    private continueAllRemaining;
+    /**
+     * 从当前章节播放到最后一个章节（连续自动播放）
+     */
+    playAllRemaining(): Promise<void>;
+    /**
+     * 重置播放
+     */
+    reset(): void;
+    /**
+     * 设置时间线
+     */
+    setTimelineTo(time: number): void;
+    /**
+     * 启用插件
+     */
+    enable(): void;
+    /**
+     * 禁用插件
+     */
+    disable(): void;
+    /**
+     * 重置并清理（完全重置插件状态，包括对 five 的操作和 DigitalHuman）
+     */
+    private resetAndCleanup;
+    /**
+     * 销毁插件（彻底释放资源）
+     */
+    dispose(): void;
+    /**
+     * 获取当前状态
+     */
+    getState(): {
+        enabled: boolean;
+        playing: boolean;
+        currentChapter: DigitalChapter;
+        currentScript: DigitalScript;
+        continuousPlaying: boolean;
+        playMode: "single" | "continuous";
+    };
+    /**
+     * 获取可用章节列表
+     */
+    getChapters(): DigitalChapter[];
+    /**
+     * 获取数字人实例
+     */
+    getDigitalHuman(modelUrl: string, id?: string): DigitalHuman | null;
+    /**
+     * 获取当前播放进度信息
+     */
+    getProgress(): {
+        currentTime: number;
+        totalTime: number;
+    } | null;
+    /**
+     * 对原始 res 数据进行 transformPosition 处理和章节分组，返回完整结构
+     * @param res 原始数据
+     * @param work 可选，存在时才做transformPosition
+     * @param totalDelay 可选，默认0
+     */
+    transformScriptData(res: any, work?: any, totalDelay?: number): any;
+    /**
+     * 清理进度缓存
+     */
+    private clearProgressCache;
+    /**
+     * 计算单个章节的时长
+     */
+    private calculateChapterDuration;
+    /**
+     * 获取所有章节的总时长（毫秒）
+     */
+    getTotalDuration(): number;
+    /**
+     * 获取章节时间映射信息
+     */
+    getChapterTimeMap(): ChapterTimeInfo[];
+    /**
+     * 获取当前全局播放时间（毫秒）
+     *
+     * @deprecated 建议使用 getGlobalProgress().currentTime 获取更完整的信息
+     * @returns 当前全局时间（毫秒）
+     */
+    getCurrentGlobalTime(): number;
+    /**
+     * 获取全局进度信息
+     */
+    getGlobalProgress(): GlobalProgress;
+    /**
+     * 根据全局时间获取对应的章节信息
+     */
+    getChapterByGlobalTime(globalTime: number): ChapterLocation | null;
+    /**
+     * 跳转到指定的全局时间
+     */
+    seekToGlobalTime(globalTime: number, autoPlay?: boolean): Promise<void>;
+    /**
+     * 初始化章节用于跳转（不自动播放）
+     */
+    private initializeChapterForSeek;
+    /**
+     * 跳转到指定百分比位置
+     */
+    seekToPercentage(percentage: number, autoPlay?: boolean): Promise<void>;
+    /**
+     * 跳转到指定章节的指定时间
+     */
+    seekToChapter(chapterIndex: number, chapterTime?: number, autoPlay?: boolean): Promise<void>;
+    /**
+     * 从指定全局时间开始播放所有剩余内容
+     */
+    playFromGlobalTime(globalTime: number): Promise<void>;
+    /**
+     * 注册进度变化监听器
+     */
+    onProgressChanged(callback: ProgressListener): () => void;
+    /**
+     * 移除进度监听器
+     */
+    offProgressChanged(callback: ProgressListener): void;
+    /**
+     * 设置进度回调频率（毫秒）
+     */
+    setProgressUpdateInterval(interval: number): void;
+    /**
+     * 启动进度更新定时器
+     */
+    private startProgressUpdateTimer;
+    /**
+     * 停止进度更新定时器
+     */
+    private stopProgressUpdateTimer;
+    /**
+     * 播放完整的所有章节（从头开始）
+     */
+    playAllChapters(): Promise<void>;
+    /**
+     * 获取播放范围信息
+     */
+    getPlaybackRange(): {
+        startTime: number;
+        endTime: number;
+        estimatedDuration: number;
+    };
+    /**
+     * 停止所有 player 的播放状态
+     */
+    private stopAllPlayers;
+    private emit;
+    /**
+     * 注册监听当前正在播放的所有player变化
+     */
+    onPlayingPlayersChanged(callback: (players: any[]) => void): () => void;
+    /**
+     * 获取当前正在播放的所有player（数组）
+     */
+    private getCurrentPlayingPlayers;
+    /**
+     * 从指定章节获取正在播放的players
+     */
+    private getPlayingPlayersFromChapter;
+    /**
+     * 触发 playing-players-changed 事件
+     */
+    private emitPlayingPlayersChanged;
+}

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

@@ -0,0 +1,54 @@
+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;
+    state: {
+        currentTime: number;
+        currentAnimation: THREE.AnimationClip | null;
+        playing: boolean;
+    };
+    animationFrameId: number | null;
+    curveLine: THREE.Line;
+    effectsGroup: THREE.Group;
+    effectObjects: Map<string, THREE.Mesh>;
+    container: THREE.Group;
+    private mixer;
+    private action;
+    private itemMatrixMap;
+    private trace;
+    private processedNeedRenderKeyframeIndices;
+    private attachedItems;
+    private rightHandBone;
+    constructor(model: GLTFObject, digitalPlayground: any);
+    playAnimation({ animation, repeat, switchDuration }: {
+        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;
+    clearProcessedNeedRenderKeyframeIndices(): void;
+    private hasProcessedNeedRenderForTimestamp;
+    private markNeedRenderProcessedForTimestamp;
+    private getRightHandBone;
+    private updateKeyframeItems;
+    private detachAllKeyframeItems;
+}

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

@@ -0,0 +1,40 @@
+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;
+    script: DigitalScript | null;
+    currentChapter: DigitalChapter | null;
+    private digitalHumanMap;
+    private digitalItemMap;
+    private skeletalAnimationMap;
+    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[], offsets?: Map<string, {
+        position: number[];
+        rotation: number[];
+    }>): Promise<any[]>;
+    loadItem(url: string, offset?: {
+        position: number[];
+        rotation: number[];
+    }): Promise<any>;
+    getDigitalItem(url: string): any | null;
+    pause(): void;
+    continue(): void;
+    reset(): void;
+    setTimelineTo(time: number): void;
+    /**
+     * 销毁 playground
+     */
+    dispose(): void;
+    private loadGLTF;
+}

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

@@ -0,0 +1,150 @@
+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;
+        duration?: number;
+        item?: {
+            url: string;
+            position?: number[];
+            name?: string;
+            rotation?: 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/dist/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/dist/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/dist/DigitalPerformancePlugin/mock.d.ts

@@ -0,0 +1,76 @@
+interface MockAction {
+    repeat: boolean;
+    name: string;
+    animationUrl: string;
+    duration: number;
+    rotation?: any;
+    subAction?: {
+        url: string;
+        position?: number[];
+        rotation?: number[];
+    };
+}
+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/dist/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/dist/GuideLinePlugin/Controller.d.ts

@@ -6,20 +6,13 @@ import type { Config as BaseConfig } from '../base/BasePlugin';
 import { GuideLineItem } from './GuideLineItem';
 import CruisePluginController from '../CruisePlugin/Work';
 export declare const pluginFlag: (name: string) => string;
-type Config = BaseConfig & {
-    /**
-     * @description 格式化距离函数，用于将米转换为显示文本（包含单位）
-     * @param distanceInMeter 距离（单位：米）
-     * @returns 格式化后的距离字符串，例如 "10m" 或 "32'10""
-     */
-    formatDistance?: (distanceInMeter: number) => string;
-};
+type Config = BaseConfig;
 export default class Controller extends BasePluginWithData.Controller<PluginState, EventMap, PluginServerData, PluginData> {
     readonly name = "GuideLinePlugin";
     readonly cruisePlugin: CruisePluginController;
     /** GuideLineItem 索引 */
     readonly itemMap: Map<string | number, GuideLineItem>;
-    get config(): Config;
+    get config(): BaseConfig;
     state: {
         visible: boolean;
         enabled: boolean;
@@ -61,31 +54,6 @@ export default class Controller extends BasePluginWithData.Controller<PluginStat
     getGuideLineItemByID(id: string | number): GuideLineItem;
     /** 移除一个 GuideLineItem */
     removeGuideLineItem(item: GuideLineItem): void;
-    /**
-     * 动态更新距离格式化函数，立即刷新所有路线标签的距离显示。
-     * 不传参时恢复为默认格式（i18n('全程') + 距离 + i18n('米')）。
-     * @param fn 格式化函数，输入米数，返回带单位的完整字符串
-     * @example
-     *   // 室内英制：英尺 + 英寸（如 "5'10""）
-     *   plugin.setDistanceFormatter((m) => {
-     *     const totalInches = Math.round(m * 39.3701)
-     *     const feet = Math.floor(totalInches / 12)
-     *     const inches = totalInches % 12
-     *     return `${feet}'${inches}"`
-     *   })
-     *   // 室外英制：英里（如 "1.24 mi"）
-     *   plugin.setDistanceFormatter((m) => `${(m * 0.000621371).toFixed(2)} mi`)
-     *   // 自动切换：近距离用英尺，远距离用英里
-     *   plugin.setDistanceFormatter((m) => {
-     *     if (m < 300) return `${Math.round(m * 3.28084)} ft`
-     *     return `${(m * 0.000621371).toFixed(2)} mi`
-     *   })
-     *   // 恢复默认（i18n '米'）
-     *   plugin.setDistanceFormatter()
-     */
-    setDistanceFormatter(fn?: (distanceInMeter: number) => string): void;
-    /** 更新所有 tag 的距离显示（当 formatDistance 函数改变时调用） */
-    private updateTagDistances;
     /** 全量更新 tag */
     updateTagsEnable(): void;
     /** 清空所有 GuideLineItem */