run-scene-v2 0.0.50 → 0.0.51

package/index.d.ts

@@ -0,0 +1,3335 @@
+declare module 'run-scene-v2/index' {
+  import { TransformControls } from "three/examples/jsm/controls/TransformControls";
+  import RunScene, { Utils, ModelEx, MaterialEx, TextureEx, Bus } from "run-scene-v2/src/RunScene";
+  const _default: {
+      RunScene: typeof RunScene;
+      Utils: typeof Utils;
+      ModelEx: typeof ModelEx;
+      MaterialEx: typeof MaterialEx;
+      TextureEx: typeof TextureEx;
+      Three: typeof import("three");
+      ThreeEx: {
+          TransformControls: typeof TransformControls;
+      };
+      Bus: typeof Bus;
+  };
+  export default _default;
+
+}
+declare module 'run-scene-v2/src/Anima/Anima' {
+  import { Obj } from "js-funcs/dts/def";
+  import { AnimationAction, AnimationClip, AnimationMixer, Clock } from "three";
+  import BaseEx from "run-scene-v2/src/BaseEx";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export type AnimaItem = {
+      model: E.unknowModel;
+      mixer: AnimationMixer;
+      action: AnimationAction;
+      clip: AnimationClip;
+      options?: AnimaPlayOptions;
+      time: number;
+      runState: "play" | "pause" | "close";
+      eventMap: {
+          finished: () => void;
+          loop: () => void;
+      };
+  };
+  export type AnimaCloseOptions = {
+      lastFrame?: boolean;
+      fadeOut?: number;
+      resetAction?: boolean;
+  };
+  export type AnimaPlayOptions = {
+      onProgress?: (progress: number) => void;
+      onLoop?: () => void;
+      onFinished?: () => void;
+      onClose?: () => void;
+      onPause?: () => void;
+      onResume?: () => void;
+      onBeforeEnd?: () => void;
+      lastFrame?: boolean;
+      loop?: boolean;
+      reset?: boolean;
+  };
+  export default class Anima extends BaseEx {
+      map: {
+          [id: string]: AnimaItem;
+      };
+      clock: Clock;
+      tickIndex: number;
+      playings: Set<AnimaItem>;
+      updates: {
+          [id: string]: (detal: number) => void;
+      };
+      constructor(runScene: RunScene);
+      onModelDelete(model: any): void;
+      parses(model: any): void;
+      findId(model: E.unknowModel, name: string): any;
+      parse(model: E.unknowModel, clipsJSON?: Obj[]): void;
+      play(model: E.unknowModel, name: string, iOptions?: AnimaPlayOptions): void;
+      pause(model: E.unknowModel, name: string): void;
+      resume(model: E.unknowModel, name: string): void;
+      playAll(): void;
+      setValue(num: number): void;
+      getDetal(): number;
+      update(iDetal?: number): void;
+      anima(): void;
+      closeAnima(): void;
+      resetItem(item: AnimaItem): void;
+      pauseAll(): void;
+      reset(): void;
+      updateTime(item: AnimaItem, num?: number): void;
+      setPlayState(item: AnimaItem, state: boolean): void;
+      getItem(model: E.unknowModel, name: string): AnimaItem;
+      close(model: E.unknowModel, name: string, inputOptions?: AnimaCloseOptions): void;
+      setUpdates(id: string, fn: () => void): void;
+      fadeTo(map: {
+          lastModel: E.unknowModel;
+          lastName: string;
+          nextModel: E.unknowModel;
+          nextName: string;
+          duration: number;
+      }): void;
+      resetTime(model: E.unknowModel, name: string): void;
+  }
+
+}
+declare module 'run-scene-v2/src/AssetsEx' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { CSS3DRenderer } from "three/examples/jsm/renderers/CSS3DRenderer";
+  import { CSS2DRenderer } from "three/examples/jsm/renderers/CSS2DRenderer";
+  export default class EngineAssets {
+      scene: E.Scene;
+      camera: E.Camera;
+      controls: E.Controls;
+      renderer: E.Render;
+      engineDom: HTMLElement;
+      render2?: CSS3DRenderer;
+      render3?: CSS3DRenderer;
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      initRender3(): CSS3DRenderer;
+      initRender2(): CSS2DRenderer;
+      reset(): void;
+      dispose(): void;
+      setRender2(state: boolean): void;
+      setRender3(state: boolean): void;
+      init(engineDom: HTMLElement): {
+          scene: import("three").Scene;
+          camera: import("three").PerspectiveCamera;
+          render: import("three").WebGLRenderer;
+          controls: import("three/examples/jsm/controls/OrbitControls").OrbitControls;
+          engineDom: HTMLElement;
+      };
+      get(): {
+          scene: import("three").Scene;
+          camera: import("three").PerspectiveCamera;
+          renderer: import("three").WebGLRenderer;
+          controls: import("three/examples/jsm/controls/OrbitControls").OrbitControls;
+          engineDom: HTMLElement;
+      };
+      disposeRender: (renderer: any) => void;
+  }
+
+}
+declare module 'run-scene-v2/src/BaseEx' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  export default class BaseEx {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+  }
+
+}
+declare module 'run-scene-v2/src/Bloom/Glow/BloomMTU' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  export class BloomMTU {
+      private readonly BLOOM_SCENE;
+      private mainScene;
+      private mainCamera;
+      private renderer;
+      private rtSize;
+      private effectRT;
+      private effectComposer;
+      private taaRenderPass;
+      private sampleRT;
+      private holdRT;
+      private bloomRenderPass;
+      private mixingPass;
+      private effectCopy;
+      private mtGlow;
+      runScene: RunScene;
+      /**
+       * 初始化后处理
+       */
+      constructor(runScene: RunScene, mtGlow: any);
+      /**
+       * 若scene.background=Color，且Color!=black，则加上UnrealBloomPass效果后会导致全白屏；
+       * 若scene.background=Color，且Color==black，则加上UnrealBloomPass效果后会导致深度绘制不正确；
+       * 若scene.background=Texture|null，则加上UnrealBloomPass效果后才是正确的深度绘制；
+       */
+      private postProcessing;
+      /**
+       * 重置窗口变化导致的renderer的绘制调整
+       */
+      setSize(width: number, height: number): void;
+      /**
+       * 废置MTGlow
+       */
+      dispose(): void;
+      /**
+       * 渲染循环
+       */
+      update(): void;
+      setSceneBg(): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Bloom/Glow/BloomThree' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  export class BloomThree {
+      private readonly ENTIRE_SCENE;
+      private readonly BLOOM_SCENE;
+      private mainScene;
+      private mainCamera;
+      private renderer;
+      private bloomLayer;
+      private readonly darkMaterial;
+      private readonly materials;
+      private rtSize;
+      private bloomComposer;
+      private finalComposer;
+      private mtGlow;
+      private blackColor;
+      runScene: RunScene;
+      /**
+       * 初始化后处理
+       */
+      constructor(runScene: RunScene, mtGlow: any);
+      /**
+       * 若scene.background=Color，且Color!=black，则加上UnrealBloomPass效果后会导致全白屏；
+       * 若scene.background=Color，且Color==black，则加上UnrealBloomPass效果后会导致深度绘制不正确；
+       * 若scene.background=Texture|null，则加上UnrealBloomPass效果后才是正确的深度绘制；
+       */
+      private postProcessing;
+      private renderBloom;
+      /**
+       * 渲染循环
+       */
+      update(): void;
+      /**
+       * 重置窗口变化导致的renderer的绘制调整
+       */
+      setSize(width: number, height: number): void;
+      /**
+       * 废置MTGlow
+       */
+      dispose(): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Bloom/Glow/GlowEffectShader' {
+  const GlowEffectShader: {
+      uniforms: {
+          baseTexture: {
+              value: any;
+          };
+          bloomTexture: {
+              value: any;
+          };
+      };
+      vertexShader: string;
+      fragmentShader: string;
+  };
+  export { GlowEffectShader };
+
+}
+declare module 'run-scene-v2/src/Bloom/Glow/GLowInfo' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export default class GLowInfo {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      modelLength: Set<unknown>;
+      init(): void;
+      add(m: E.unknowModel): void;
+      remove(m: E.unknowModel): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Bloom/Glow/GlowThreeShader' {
+  const GlowThreeShader: {
+      vertexShader: string;
+      fragmentShader: string;
+  };
+  export { GlowThreeShader };
+
+}
+declare module 'run-scene-v2/src/Bloom/Glow/MTGlow' {
+  import * as THREE from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import GLowInfo from "run-scene-v2/src/Bloom/Glow/GLowInfo";
+  export class MTGlow {
+      private static instance;
+      renderer: THREE.WebGLRenderer | null;
+      private sceneFogColor;
+      private sceneBackground;
+      private isUpdate;
+      private readonly isSafari;
+      private readonly isChrome;
+      private bloomMtu;
+      private bloomThree;
+      info: GLowInfo;
+      bloomPass: any;
+      bloomParams: {
+          isBloom: boolean;
+          bloomStrength: number;
+          bloomThreshold: number;
+          bloomRadius: number;
+      };
+      runScene: RunScene;
+      static getInstance(runScene: RunScene): MTGlow;
+      constructor(runScene: RunScene);
+      set rendererTone(show: boolean);
+      /**
+       * 初始化后处理
+       */
+      init(map: {
+          camera: any;
+          scene: any;
+          renderer: any;
+      }): void;
+      /**
+       * 重置辉光相关数据
+       */
+      setData(data: {
+          bloomParams: any;
+      }): void;
+      /**
+       * 重置窗口变化导致的renderer的绘制调整
+       */
+      setSize(width: number, height: number): void;
+      /**
+       * 废置MTGlow
+       */
+      dispose(): void;
+      /**
+       * 是否绘制场景
+       */
+      setUpdate(isUpdate: boolean): void;
+      /**
+       * 渲染循环
+       */
+      update(): void;
+      toJSON(): string;
+      reset(): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Bloom/Glow/MTMixShaderPass' {
+  /***
+   * 此通道有两个RT图作为参数，一个是不带特效的原图，一个是带特效的渲染图
+   * 所以必须作为最后一个Pass使用
+   */
+  import { Pass } from 'three/examples/jsm/postprocessing/Pass.js';
+  export class MTMixShaderPass extends Pass {
+      private baseTextureID;
+      private effectTextureID;
+      private uniforms;
+      private material;
+      private fsQuad;
+      constructor(shader: any, baseTextureID?: any, effectTextureID?: any);
+      render(renderer: any, writeBuffer: any, readBuffer: any): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Bloom/Glow/MTRenderPass' {
+  import { Scene, Camera, Material, Color } from 'three';
+  import { Pass } from 'three/examples/jsm/postprocessing/Pass.js';
+  export class MTRenderPass extends Pass {
+      layerIndex: any;
+      clearDepth: any;
+      sceneBg: any;
+      private readonly scene;
+      private readonly camera;
+      private readonly overrideMaterial;
+      private readonly clearColor;
+      private readonly clearAlpha;
+      private readonly oldClearColor;
+      private readonly oldCameraLayer;
+      constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: Color, clearAlpha?: number);
+      render(renderer: any, _writeBuffer: any, readBuffer: any): void;
+  }
+
+}
+declare module 'run-scene-v2/src/CallBack/CallBack' {
+  import { ExportGltfJson } from "run-scene-v2/src/Exporter/GLTFExporter/ExporterGltf";
+  import { TextureUserDataEx } from "run-scene-v2/src/TextureEx";
+  import { TimeLineType } from "run-scene-v2/src/TimeLine/TimeLine";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  export type addArgs<T> = {
+      name: string;
+      fn: (data: T) => void;
+  };
+  class BindEvent<inputType> {
+      private cbs;
+      cb: (data: inputType) => Promise<any[]>;
+      emit: (data: inputType) => Promise<any[]>;
+      /**
+       *
+       * @param name 传入的函数名称，用来确定该函数的作用
+       * @param fn 函数本身
+       * @returns
+       */
+      add(name: string, fn: (data: inputType) => void): number;
+      on(fn: (data: inputType) => void, name?: string): number;
+      get(name: string): {
+          data: undefined | addArgs<inputType>;
+          index: number;
+      } | undefined;
+      reset(name: string, fn: ((data: inputType) => void) | null): Boolean;
+      remove(name: string): void;
+      delete(name: any): void;
+  }
+  export default class OptionCb {
+      resize: BindEvent<{
+          width: number;
+          height: number;
+      }>;
+      setSelectMaterial: BindEvent<E.Material>;
+      setScene: BindEvent<{
+          scene: E.Scene;
+          type: string;
+          val: any;
+      }>;
+      reset: BindEvent<import("three").Scene>;
+      render: BindEvent<any>;
+      baseLog: BindEvent<{
+          msg: string;
+          type: string;
+      }>;
+      inited: BindEvent<any>;
+      texture: {
+          add: BindEvent<import("three").Texture>;
+          remove: BindEvent<import("three").Texture>;
+          setAnima: BindEvent<{
+              texture: E.Texture;
+              uvScript: TextureUserDataEx["uvScript"];
+          }>;
+      };
+      model: {
+          multiSelect: {
+              setEmpty: BindEvent<void>;
+          };
+          setSelect: BindEvent<any>;
+          click: BindEvent<any>;
+          add: BindEvent<{
+              model: E.unknowModel;
+              parent: E.unknowModel;
+              isClone: boolean;
+          }>;
+          remove: BindEvent<any>;
+          multipDrop: BindEvent<{
+              models: E.unknowModel[];
+              dropModel: E.unknowModel;
+          }>;
+          focus: BindEvent<{
+              model: E.Model;
+              status: boolean;
+              domActive: boolean;
+          }>;
+          unFocus: BindEvent<E.Model>;
+          changeName: BindEvent<{
+              model: E.unknowModel;
+              name: string;
+              oldName: string;
+          }>;
+          setOpen: BindEvent<{
+              isOpen: boolean;
+              model: E.unknowModel;
+          }>;
+          setMainStatue: BindEvent<{
+              status: boolean;
+              model: E.unknowModel;
+          }>;
+          setVisible: BindEvent<{
+              visible: boolean;
+              model: E.unknowModel;
+          }>;
+          setParent: BindEvent<{
+              parent: E.unknowModel;
+              model: E.unknowModel;
+          }>;
+          setLayers: BindEvent<{
+              model: E.unknowModel;
+              val: number;
+          }>;
+          clone: BindEvent<any>;
+          dispose: BindEvent<any>;
+      };
+      material: {
+          add: BindEvent<E.BaseMaterial>;
+          dispose: BindEvent<any>;
+          setName: BindEvent<{
+              id: string;
+              name: string;
+          }>;
+      };
+      unique: {
+          material: {
+              add: BindEvent<E.Material>;
+          };
+      };
+      undo: {
+          addUndos: BindEvent<{
+              undoVal: UndoBase | UndoBase[];
+              undos: Array<UndoBase | UndoBase[]>;
+          }>;
+          removeUndos: BindEvent<{
+              index: number;
+              undos?: Array<UndoBase | UndoBase[]>;
+          }>;
+          undoByIndex: BindEvent<number>;
+          reset: BindEvent<any>;
+      };
+      scene: {
+          save: BindEvent<any>;
+          saveNet: BindEvent<any>;
+      };
+      timeLine: {
+          setProgress: BindEvent<number>;
+          playGroup: BindEvent<{
+              groupName: string;
+              progress: number;
+          }>;
+          setGroupMap: BindEvent<{
+              group: TimeLineType.Group;
+              groupName: string;
+          }>;
+          reset: BindEvent<any>;
+          closeGroup: BindEvent<string>;
+      };
+      events: {
+          key: {
+              down: BindEvent<{
+                  key: string;
+                  event: KeyboardEvent;
+              }>;
+              up: BindEvent<{
+                  key: string;
+                  event: KeyboardEvent;
+              }>;
+          };
+          mouse: {
+              move: BindEvent<MouseEvent>;
+              down: BindEvent<MouseEvent>;
+              up: BindEvent<MouseEvent>;
+          };
+          pointer: {
+              down: BindEvent<PointerEvent>;
+              up: BindEvent<PointerEvent>;
+              move: BindEvent<PointerEvent>;
+          };
+      };
+      bloom: {
+          glow: {
+              setData: BindEvent<any>;
+              setStatus: BindEvent<boolean>;
+          };
+      };
+      load: {
+          lazyLoadedTexture: BindEvent<any>;
+          loaded: BindEvent<any>;
+          modelLoaded: BindEvent<any[]>;
+          progress: BindEvent<number>;
+          getJOSN: BindEvent<ExportGltfJson>;
+          getArrayBuffer: BindEvent<ArrayBuffer>;
+          complete: BindEvent<{
+              models: E.unknowModel[];
+              json: ExportGltfJson;
+          }>;
+      };
+      custom: {
+          [key: string]: BindEvent<any>;
+      };
+  }
+  export {};
+
+}
+declare module 'run-scene-v2/src/CameraEx' {
+  import { PerspectiveCamera } from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export default class EngineCamera {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      backgroudDom: HTMLElement;
+      setBackground(img: string | null): void;
+      create(): PerspectiveCamera;
+      reset(camera: E.Camera): void;
+      get(): PerspectiveCamera;
+  }
+
+}
+declare module 'run-scene-v2/src/Const/constMaterial' {
+  export const defMaterialNames: readonly ["BaseMaterial", "SpriteMaterial", "FakeInterior", "Reflector", "Fresnel", "Physical"];
+
+}
+declare module 'run-scene-v2/src/Const/constModel' {
+  export const defModelNames: readonly ["Group", "Box", "Circle", "Cylinder", "Dodecahedron", "Icosahedron", "Lathe", "Octahedron", "Plane", "Ring", "Sphere", "Sprite", "Tetrahedron", "Torus", "TorusKnot", "Tube", "Reflector"];
+  export const exModelNames: string[];
+
+}
+declare module 'run-scene-v2/src/Const/constTexture' {
+  export const officialTexture: readonly ["map", "metalnessMap", "roughnessMap", "normalMap", "aoMap", "emissiveMap"];
+  export const officialTexture2: string[];
+  export const notOfficialTexture: readonly ["alphaMap", "lightMap", "envMap", "displacementMap"];
+  export const allTextureNames: readonly ["map", "metalnessMap", "roughnessMap", "normalMap", "aoMap", "emissiveMap", "alphaMap", "lightMap", "envMap", "displacementMap"];
+
+}
+declare module 'run-scene-v2/src/ControlsEx' {
+  import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export default class EngineControls {
+      create(camera: E.Camera, dom: HTMLElement): OrbitControls;
+      static toJSON(controls: E.Controls): import("three").Vector3;
+  }
+
+}
+declare module 'run-scene-v2/src/Events/EventDrag' {
+  import Events from "run-scene-v2/src/Events/Events";
+  export namespace EventDragMap {
+      interface BaseModel {
+          val: string;
+          type: "base-model" | "base-material" | "base-light" | "net-model";
+      }
+      interface Libs {
+          data: any;
+          type: "texture";
+      }
+  }
+  export default class EventDrag {
+      private _state;
+      private _libsState;
+      private map;
+      private libsMap;
+      events: Events;
+      constructor(events: Events);
+      get state(): boolean;
+      set state(state: boolean);
+      setVal(data: EventDragMap.BaseModel): void;
+      getVal(): undefined | EventDragMap.BaseModel;
+      setLibsVal(data: EventDragMap.Libs): void;
+      getLibsVal(): undefined | EventDragMap.Libs;
+  }
+
+}
+declare module 'run-scene-v2/src/Events/EventKey' {
+  import MapEx from "run-scene-v2/src/Ex/MapEx";
+  import Events from "run-scene-v2/src/Events/Events";
+  export default class EventKey {
+      alt: boolean;
+      ctrl: boolean;
+      shift: boolean;
+      events: Events;
+      unExec: MapEx<unknown, unknown>;
+      constructor(events: Events);
+      init(_dom: HTMLElement): void;
+      allFn: {
+          s_saveScene: () => Promise<void>;
+          d_copyModel: () => void;
+          f_focusModel: () => void;
+          z_undo: (_e: Event) => void;
+          y_redo: (_e: Event) => void;
+      };
+      keyDown(e: KeyboardEvent): Promise<void>;
+      keyUp(e: KeyboardEvent): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Events/EventMouse' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import Events from "run-scene-v2/src/Events/Events";
+  export default class EventMouse {
+      downPosition: {
+          x: number;
+          y: number;
+      };
+      enableUp: boolean;
+      events: Events;
+      constructor(events: Events);
+      init(dom: HTMLElement): void;
+      down: (event: PointerEvent) => void;
+      up: (event: any) => void;
+      getTriggerModels(event: any): E.Model[];
+      removeHideModel(models: E.Model[]): E.Model | undefined;
+      trigger(event: any): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Events/Events' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import EventDrag from "run-scene-v2/src/Events/EventDrag";
+  import EventKey from "run-scene-v2/src/Events/EventKey";
+  import EventMouse from "run-scene-v2/src/Events/EventMouse";
+  class Events {
+      key: EventKey;
+      mouse: EventMouse;
+      drag: EventDrag;
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      init(dom: HTMLElement): void;
+  }
+  export default Events;
+
+}
+declare module 'run-scene-v2/src/Ex/MapEx' {
+  export default class MapEx<T, F> extends Map<T, F> {
+      constructor(obj?: {
+          [key: string]: any;
+      });
+      map(fn: (k: T, v: F) => any): any[];
+      toJSON(): {};
+      filter<G extends "key" | "value">(fn: (k: T, v: F) => boolean, type: G): undefined | G extends "key" ? T[] : F[];
+      find(fn: (k: T, v: F) => boolean): undefined | F;
+  }
+
+}
+declare module 'run-scene-v2/src/Exporter/Exporter' {
+  import BaseEx from "run-scene-v2/src/BaseEx";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import ExporterGltf from "run-scene-v2/src/Exporter/GLTFExporter/ExporterGltf";
+  export default class Exporter extends BaseEx {
+      gltf: ExporterGltf;
+      constructor(runScene: RunScene);
+  }
+
+}
+declare module 'run-scene-v2/src/Exporter/GLTFExporter/ExporterGltf' {
+  import BaseEx from "run-scene-v2/src/BaseEx";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { ExportGltfHelperBeforeJson } from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperBefore";
+  import ExporterGltfOptions from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperOptions";
+  export type ExportGltfType = "model" | "scene" | "material";
+  export type ExportGltfJson = {
+      asset: {
+          ex: {
+              type: ExportGltfType;
+              materialMap: ExportGltfHelperBeforeJson["materialMap"];
+              textureMap: ExportGltfHelperBeforeJson["textureMap"];
+              camera: string;
+              controls: {
+                  x: number;
+                  y: number;
+                  z: number;
+              };
+              base64: string;
+              lights: any[];
+              nodeMap: {
+                  id: string;
+                  visible: boolean;
+              };
+              timeLine: any;
+              options: Array<{
+                  type: string;
+                  data: string;
+              }>;
+              sceneEx: {
+                  materialId: string;
+                  backgroundMapping: number;
+                  backgroundColor: string;
+                  fog: {
+                      color: string;
+                      far: number;
+                      near: number;
+                  };
+              };
+          };
+      };
+      animations: any[];
+  };
+  export default class ExporterGltf extends BaseEx {
+      private _gltf;
+      private _originGltf;
+      options: ExporterGltfOptions;
+      getArrayBuffer(model?: E.Model, type?: ExportGltfType): Promise<ArrayBuffer>;
+      getOriginArrayBuffer(model: E.Model): Promise<unknown>;
+      export(model: E.Model): Promise<void>;
+      model(inputModel?: E.unknowModel): Promise<void>;
+      material(inputMaterial?: E.Material): Promise<void>;
+      scene(down?: boolean): Promise<ArrayBuffer>;
+      originModel(model?: E.Model): Promise<void>;
+  }
+
+}
+declare module 'run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/GltfHelper' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { ExportGltfType } from "run-scene-v2/src/Exporter/GLTFExporter/ExporterGltf";
+  import ExportGltfHelperBefore from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperBefore";
+  import ExportGltfHelperMaterial from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperMaterial";
+  import { Bone } from "three";
+  import HelperMergeSameGeo from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperMergeSameGeo";
+  import HelperBindClonedId from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperBindClonedId";
+  export default class ExportGltfHelper {
+      material: ExportGltfHelperMaterial;
+      helperModels: E.Model[];
+      type: ExportGltfType;
+      runScene: RunScene;
+      before: ExportGltfHelperBefore;
+      constructor(map: {
+          type: ExportGltfType;
+          runScene: RunScene;
+      });
+      mergeSameGeo: HelperMergeSameGeo;
+      bindClondId: HelperBindClonedId;
+      init(model: E.Model): void;
+      parseNode(map: {
+          object: E.unknowModel;
+          nodeDef: any;
+          options: object;
+      }): void;
+      getNodeMapValueWithBone(bone: Bone, nodeMap: Map<any, any>): any;
+      done(json: any): void;
+      setSceneEx(baseMap: any): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperBefore' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { ExportGltfType } from "run-scene-v2/src/Exporter/GLTFExporter/ExporterGltf";
+  import ExportGltfHelper from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/GltfHelper";
+  import { ExportGltfTextureMapItem2 } from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperMaterial";
+  export type ExportGltfHelperBeforeJson = {
+      materialMap: {
+          [uuid: string]: {
+              normal: {
+                  [type: string]: any;
+              };
+              textures: {
+                  [uuid: string]: string;
+              };
+          };
+      };
+      textureMap: {
+          [uuid: string]: ExportGltfTextureMapItem2;
+      };
+  };
+  export default class ExportGltfHelperBefore {
+      materialMap: {
+          [uuid: string]: {
+              oldMaterial?: E.Material;
+              normalMaterial?: E.Material;
+              material: E.Material;
+              models?: Array<E.unknowModel>;
+          };
+      };
+      textureMap: {
+          [uuid: string]: {
+              blob: Blob;
+              md5: string;
+              texture: E.Texture;
+              id: string;
+              cloneSourceId: string | undefined;
+          };
+      };
+      type: ExportGltfType;
+      runScene: RunScene;
+      helper: ExportGltfHelper;
+      constructor(map: {
+          type: ExportGltfType;
+          runScene: RunScene;
+          helper: ExportGltfHelper;
+      });
+      /**
+       * 解析主流程
+       *  1、新建一个空组 起名”back-texture-ex“ 将空组存放在模型上 辅助线开启
+       *    2、当解析模型类型为scene时即进行特殊处理 取出重要的环境贴图、背景等属性
+       *        * 解析场景中特别注意的是需要使用一个全新模型 承载scene的材质属性用于恢复而不被清除掉
+       *          * 场景中的背景有俩种情况：1、贴图   2、颜色rgb
+       *      3、解析材质
+       *  */
+      parse(model: E.Model): void;
+      parseScene(helperModel: E.Model): void;
+      private _processMaterial;
+      private modelType;
+      private compressLocal;
+      private _processModel;
+      parseModel(model: E.Model): void;
+      materialMapToJson(): any[];
+      mergeSame(newTexture: E.Texture): {
+          isSame: boolean;
+          texture: E.Texture;
+      };
+      mergeAndRemoveTexture(textures: {
+          type: string;
+          texture: E.Texture;
+      }[], material: E.Material): Promise<void[]>;
+      parseCloneTexture(texture: E.Texture): import("three").Texture;
+      setMultipMaterial(parent: E.unknowModel, textureids: string[]): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperBindClonedId' {
+  import MapEx from "run-scene-v2/src/Ex/MapEx";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export default class HelperBindClonedId {
+      savedMap: MapEx<string, {
+          id: string;
+          materialUuid: string;
+          geometryUuid: string;
+      }>;
+      getSameNode(n: E.Mesh): {
+          id: string;
+          materialUuid: string;
+          geometryUuid: string;
+      };
+      parseNode(n: E.Mesh): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperMaterial' {
+  import { Obj } from "js-funcs/dts/def";
+  import { PixelFormat } from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import ExportGltfHelper from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/GltfHelper";
+  import { ExportGltfHelperBeforeJson } from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperBefore";
+  export type ExportGltfTextureMapItem = {
+      bufferView: number;
+      repeat?: E.V2;
+      format: PixelFormat;
+  };
+  export type ExportGltfTextureMapItem2 = {
+      repeat?: E.V2 | number;
+      center?: E.V2 | number;
+      rotation?: number;
+      offset?: E.V2 | number;
+      format: PixelFormat;
+  };
+  export default class ExportGltfHelperMaterial {
+      materialMap: ExportGltfHelperBeforeJson["materialMap"];
+      textureMap: ExportGltfHelperBeforeJson["textureMap"];
+      runScene: RunScene;
+      helper: ExportGltfHelper;
+      constructor(map: {
+          runScene: RunScene;
+          helper: ExportGltfHelper;
+      });
+      parseMaterial(map: {
+          material: E.Material;
+          materialDef: Obj;
+          options: any;
+      }): void;
+      parseNormal(material: any): void;
+      setMaterialDef(map: {
+          normal: Obj;
+          type: string;
+          data: any;
+      }): void;
+      processTexture(map: {
+          texture: E.Texture;
+          textureDef: Obj;
+      }): void;
+      done(json: any): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperMergeSameGeo' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import MapEx from "run-scene-v2/src/Ex/MapEx";
+  import { BufferGeometry } from "three";
+  export default class HelperMergeSameGeo {
+      savedMap: MapEx<string, {
+          count: number;
+          geometry: BufferGeometry;
+      }>;
+      getSameCount(count: number): {
+          count: number;
+          geometry: BufferGeometry;
+      }[];
+      setSameNode(n: E.Mesh, geo: BufferGeometry): void;
+      getSameGeo(newGeo: BufferGeometry, oldGeos: BufferGeometry[]): BufferGeometry;
+      parseNode(n: E.Mesh): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperOptions' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export default class ExporterGltfOptions {
+      optionsConfigs: {
+          [type: string]: {
+              type: string;
+              process: (scene: E.Scene) => string;
+              parse: (data: string) => void;
+          };
+      };
+      getParse(type: string): {
+          type: string;
+          process: (scene: import("three").Scene) => string;
+          parse: (data: string) => void;
+      };
+      addOption(map: {
+          type: string;
+          process: (scene: E.Scene) => string;
+          parse: (data: string) => void;
+      }): void;
+      getOptions(scene: E.Scene): {
+          type: string;
+          data: string;
+      }[];
+  }
+
+}
+declare module 'run-scene-v2/src/FileEx/FileEx' {
+  import { ObjectLoader } from "three";
+  import { FBXLoader } from "three/examples/jsm/loaders/FBXLoader";
+  import { OBJLoader } from "three/examples/jsm/loaders/OBJLoader";
+  import RunScene from "run-scene-v2/src/RunScene";
+  export type filExParse = {
+      type: "model" | "scene" | "material";
+      result: any;
+  };
+  export default class FileEx {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      parses: {
+          fbx: FBXLoader;
+          obj: OBJLoader;
+          object: ObjectLoader;
+      };
+      getBack(file: File): string;
+      parseFiles(file: File[]): Promise<Array<filExParse>>;
+      parse(file: File): Promise<filExParse>;
+      img(file: File): void;
+      glb(file: File): Promise<filExParse>;
+      fbx(file: File | ArrayBuffer): Promise<filExParse>;
+      obj(file: File | String): Promise<filExParse>;
+      json(file: File): Promise<filExParse>;
+  }
+
+}
+declare module 'run-scene-v2/src/GlobalConfig' {
+  import BaseEx from "run-scene-v2/src/BaseEx";
+  import { OptionsMap } from "run-scene-v2/src/OptionsEx";
+  import RunScene from "run-scene-v2/src/RunScene";
+  export default class GlobalConfig extends BaseEx {
+      _lastRenderMode: null | OptionsMap["renderMode"];
+      constructor(runScene: RunScene);
+      setGlow(state: boolean): void;
+      setRender2(state: boolean): void;
+      setRender3(state: boolean): void;
+      setRenderMode: (mode: OptionsMap["renderMode"]) => void;
+  }
+
+}
+declare module 'run-scene-v2/src/Helper/HelperEx' {
+  import { BoxHelper, GridHelper } from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import TransContro from "run-scene-v2/src/Helper/TransContaro";
+  export default class EngineHelper {
+      grid: GridHelper;
+      transContro: TransContro;
+      boxHelper: BoxHelper;
+      focusModelId: string | undefined;
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      init(): void;
+      createGrid(): any;
+      dispose(): void;
+      reset(): void;
+      isHelper(model: E.unknowModel): boolean;
+      deepIsHelper: (model: E.Model) => any;
+      getBoxHelper: (model: E.unknowModel) => BoxHelper;
+      setHelper(model: E.unknowModel, deep?: boolean, cb?: (m: E.unknowModel) => void): any;
+      focus(model: E.Model): void;
+      unfocus(): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Helper/MTTransformControls' {
+  import { Camera } from 'three';
+  import { TransformControls } from 'three/examples/jsm/controls/TransformControls';
+  export class MTTransformControls extends TransformControls {
+      private readonly transGizmo;
+      private readonly scaleCoefficient;
+      private readonly beginScale;
+      private readonly posStart;
+      private readonly posEnd;
+      constructor(object: Camera, domElement?: HTMLElement);
+      /**
+       * 删除translate的多余箭头，以及scale的多余方块
+       */
+      private deleteRedundantParts;
+      /**
+       * 继承父类的pointerDown鼠标点击事件，并记录鼠标在屏幕的初始位置
+       */
+      pointerDown(pointer: any): void;
+      /**
+       * 继承父类的pointerMove鼠标移动事件，并修改缩放操作
+       */
+      pointerMove(pointer: any): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Helper/TransContaro' {
+  import { Obj } from "js-funcs/dts/def";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { EngineModelV3Names } from "run-scene-v2/src/ModelEx/ModelEx";
+  import Three from "run-scene-v2/src/Libs/Three";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { MTTransformControls } from "run-scene-v2/src/Helper/MTTransformControls";
+  class TransContro {
+      tansControls: MTTransformControls;
+      controlsMode: EngineModelV3Names;
+      isDraggingChange: boolean;
+      modelNewVal: E.V3;
+      transControlsStatusMap: Obj;
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      init(): void;
+      multipObj: any;
+      changeMode(status: EngineModelV3Names): void;
+      transControSize(status: boolean): void;
+      changeState(state: boolean): void;
+      addObject(object: any): void;
+      removeFocus(): void;
+      changeSpaceState(): void;
+      worldOldVal: Three.Vector3;
+      multipSelectLast: undefined | E.unknowModel;
+      draggingChanged: (event: any) => void;
+      transChangeFn(_event: any): void;
+      close(): void;
+      open(): void;
+      reset(): void;
+      dispose(): void;
+  }
+  export default TransContro;
+
+}
+declare module 'run-scene-v2/src/Libs/Bus' {
+  import { Obj } from "js-funcs/dts/def";
+  export class Bus {
+      list: Obj;
+      on(name: string, fn: Function): void;
+      emit(...data: any[]): any;
+      off(name: string): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Libs/Three' {
+  import * as Three from "three";
+  export default Three;
+
+}
+declare module 'run-scene-v2/src/Lights/AmbientLightEx' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import BaseLightEx from "run-scene-v2/src/Lights/BaseLightEx";
+  export type AmbientLightJSON = {
+      type: string;
+      intensity: number;
+      name: string;
+      visible: boolean;
+      color: string;
+  };
+  export default class AmbientLightEx extends BaseLightEx {
+      get(): void;
+      static toJSON(light: E.unknowModel): AmbientLightJSON;
+      parseJSON(json: AmbientLightJSON): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Lights/BaseLightEx' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  export default abstract class BaseLightEx {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      abstract get(): any;
+      abstract parseJSON(json: any): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Lights/DirectionalLightEx' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import BaseLightEx from "run-scene-v2/src/Lights/BaseLightEx";
+  export type DirectionalLightJSON = {
+      type: string;
+      intensity: number;
+      name: string;
+      visible: boolean;
+      color: string;
+      castShadow: boolean;
+      shadow: {
+          mapSize: number;
+          camera: {
+              near: number;
+              far: number;
+              scale: number;
+          };
+      };
+      position: {
+          x: number;
+          y: number;
+          z: number;
+      };
+      rotation: {
+          x: number;
+          y: number;
+          z: number;
+      };
+      targetPosition: {
+          x: number;
+          y: number;
+          z: number;
+      };
+  };
+  export default class DirectionalLightEx extends BaseLightEx {
+      get(): void;
+      static toJSON(light: E.unknowModel): DirectionalLightJSON;
+      parseJSON(json: DirectionalLightJSON): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Lights/HemisphereLightEx' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import BaseLightEx from "run-scene-v2/src/Lights/BaseLightEx";
+  export type HemisphereLightJSON = {
+      type: string;
+      intensity: number;
+      name: string;
+      visible: boolean;
+      color: string;
+      groundColor: string;
+      position: {
+          x: number;
+          y: number;
+          z: number;
+      };
+  };
+  export default class HemisphereLightEx extends BaseLightEx {
+      get(): void;
+      static toJSON(light: E.unknowModel): HemisphereLightJSON;
+      parseJSON(json: HemisphereLightJSON): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Lights/LightEx' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import AmbientLightEx from "run-scene-v2/src/Lights/AmbientLightEx";
+  import DirectionalLightEx from "run-scene-v2/src/Lights/DirectionalLightEx";
+  import HemisphereLightEx from "run-scene-v2/src/Lights/HemisphereLightEx";
+  import PointLightEx from "run-scene-v2/src/Lights/PointLightEx";
+  import RectAreaLightEx from "run-scene-v2/src/Lights/RectAreaLightEx";
+  import SpotLightEx from "run-scene-v2/src/Lights/SpotLightEx";
+  import Three from "run-scene-v2/src/Libs/Three";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  export const lightExMap: {
+      DirectionalLight: typeof DirectionalLightEx;
+      PointLight: typeof PointLightEx;
+      SpotLight: typeof SpotLightEx;
+      RectAreaLight: typeof RectAreaLightEx;
+      HemisphereLight: typeof HemisphereLightEx;
+      AmbientLight: typeof AmbientLightEx;
+  };
+  export default class EngineLight {
+      lightExMap: {
+          DirectionalLight: DirectionalLightEx;
+          PointLight: PointLightEx;
+          SpotLight: SpotLightEx;
+          RectAreaLight: RectAreaLightEx;
+          HemisphereLight: HemisphereLightEx;
+          AmbientLight: AmbientLightEx;
+      };
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      getLightsByScene(scene?: E.Model): Three.Object3D<Three.Event>[];
+      shadowList: string[];
+      helperList: string[];
+      lightDom: any;
+      helperUpdateList: string[];
+      get(lightName: any, options?: {
+          isClone?: boolean;
+          id?: string;
+          addUndo?: boolean;
+          addToScene?: boolean;
+      }): any;
+      setNull(light: E.unknowModel): void;
+      setSelect(light: E.unknowModel): void;
+      update(light: E.unknowModel): void;
+      remove(light: E.unknowModel, addUndo?: boolean): UndoBase[];
+      getLightHelper(lightName: string, light: any): Array<{
+          model: E.unknowModel;
+          parent: E.unknowModel;
+          addTree: boolean;
+      }>;
+      setLightHelper(light: any): {
+          model: any;
+          parent: any;
+          addTree: boolean;
+      }[];
+      isUpdateHelper(lightType: string): boolean;
+      initLight(lightList: any[]): void;
+      setNormal(map: {
+          model: E.Model;
+          info: string;
+          val: any;
+          cb?: () => void;
+      }, _addUndo?: boolean): UndoBase;
+      setMultip(map: {
+          model: any;
+          typeList: string[];
+          newVal: any;
+      } | Array<{
+          model: any;
+          typeList: string[];
+          newVal: any;
+      }>, cb?: (info: any) => void, execute?: boolean, addUndo?: boolean): UndoBase | UndoBase[];
+      isLight(model: E.unknowModel): any;
+      setLight(model: E.unknowModel): void;
+      isHelperTarget(model: E.unknowModel): any;
+      clone(light: E.unknowModel): any;
+      static toJSON(lights: any[]): any[];
+  }
+  export const isLight: (m: E.unknowModel) => any;
+
+}
+declare module 'run-scene-v2/src/Lights/PointLightEx' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import BaseLightEx from "run-scene-v2/src/Lights/BaseLightEx";
+  export type PointLightJSON = {
+      name: string;
+      type: string;
+      intensity: number;
+      distance: number;
+      decay: number;
+      renderOrder: number;
+      color: string;
+      visible: boolean;
+      castShadow: boolean;
+      shadow: {
+          bias: number;
+          camera: {
+              near: number;
+              far: number;
+              scale: number;
+          };
+          mapSize: number;
+          radius: number;
+      };
+      position: {
+          x: number;
+          y: number;
+          z: number;
+      };
+  };
+  export default class PointLightEx extends BaseLightEx {
+      get(): void;
+      static toJSON(light: E.unknowModel): PointLightJSON;
+      parseJSON(json: PointLightJSON): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Lights/RectAreaLightEx' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export type RectAreaLightJSON = {
+      type: string;
+      intensity: number;
+      name: string;
+      visible: boolean;
+      color: string;
+      position: {
+          x: number;
+          y: number;
+          z: number;
+      };
+  };
+  export default class RectAreaLightEx {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      static toJSON(light: E.unknowModel): RectAreaLightJSON;
+      parseJSON(json: RectAreaLightJSON): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Lights/SpotLightEx' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export type SpotLightJSON = {
+      name: string;
+      type: string;
+      color: string;
+      distance: number;
+      decay: number;
+      intensity: number;
+      angle: number;
+      penumbra: number;
+      visible: boolean;
+      castShadow: boolean;
+      shadow: {
+          bias: number;
+          camera: {
+              near: number;
+          };
+          normalBias: number;
+          mapSize: number;
+          radius: number;
+      };
+      renderOrder: number;
+      position: {
+          x: number;
+          y: number;
+          z: number;
+      };
+      targetPosition: {
+          x: number;
+          y: number;
+          z: number;
+      };
+  };
+  export default class SpotLightEx {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      static toJSON(light: E.unknowModel): SpotLightJSON;
+      parseJSON(json: SpotLightJSON): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Loaderer/AnimaLoader' {
+  import { Obj } from "js-funcs/dts/def";
+  import { AnimationLoader } from "three";
+  export default class AnimaLoader {
+      load: AnimationLoader;
+      parse(anima: Obj[]): import("three").AnimationClip[];
+  }
+
+}
+declare module 'run-scene-v2/src/Loaderer/GLTFLoader/GLTFLoaderHelper/GLTFLoaderHelper' {
+  import { GLTFParser } from "run-scene-v2/libs/loaderer/GLTFLoader/index";
+  import MapEx from "run-scene-v2/src/Ex/MapEx";
+  import { ExportGltfJson } from "run-scene-v2/src/Exporter/GLTFExporter/ExporterGltf";
+  import { ModelDef } from "run-scene-v2/src/ModelEx/ModelEx";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { ParseType } from "run-scene-v2/src/Loaderer/GLTFLoader/LoaderGltf";
+  import GLTFLoaderHelperMaterial from "run-scene-v2/src/Loaderer/GLTFLoader/GLTFLoaderHelper/LoaderMaterial";
+  import GltfLoaderHelperOptions from "run-scene-v2/src/Loaderer/GLTFLoader/GLTFLoaderHelper/LoaderOptions";
+  import GltfLoaderHelperScene from "run-scene-v2/src/Loaderer/GLTFLoader/GLTFLoaderHelper/LoaderScene";
+  export default class GLTFLoaderHelper {
+      material: GLTFLoaderHelperMaterial;
+      scene: GltfLoaderHelperScene;
+      parser: GLTFParser | undefined;
+      helperModels: E.Model[];
+      runScene: RunScene;
+      options: GltfLoaderHelperOptions;
+      pending: Promise<any>[];
+      loadConfig: ParseType;
+      nodeMap: MapEx<string, any>;
+      constructor(runScene: RunScene, loadConfig: ParseType);
+      processInput(input: any, parser: GLTFParser): Promise<void>;
+      beforeLoader(json: ExportGltfJson): boolean;
+      private nodeType;
+      processBase64(json: ExportGltfJson): boolean;
+      processNode(map: {
+          node: E.unknowModel;
+          nodeDef: ModelDef;
+      }): any;
+      done(json: ExportGltfJson): Promise<any[]>;
+      cloneMap: {
+          [parentId: string]: Set<string>;
+      };
+      mergeGeometry(): void;
+      mergeClone(): void;
+      sceneEx(json: ExportGltfJson): void;
+      removeHelperModel(): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Loaderer/GLTFLoader/GLTFLoaderHelper/LoaderMaterial' {
+  import { Obj } from "js-funcs/dts/def";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { GLTFParser } from "run-scene-v2/libs/loaderer/GLTFLoader/index";
+  import { ExportGltfHelperBeforeJson } from "run-scene-v2/src/Exporter/GLTFExporter/ExportGltfHelper/HelperBefore";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { ParseType } from "run-scene-v2/src/Loaderer/GLTFLoader/LoaderGltf";
+  export default class GLTFLoaderHelperMaterial {
+      materialMap: {
+          [materialUuid: string]: {
+              textures: {
+                  [textureUuid: string]: E.Texture;
+              };
+              normal: {
+                  [type: string]: any;
+              };
+          };
+      };
+      textureMap: {
+          [key: string]: E.Texture;
+      };
+      materialIns: {
+          [uuid: string]: {
+              material: E.Material;
+              models: E.Model[];
+          };
+      };
+      textureIns: {
+          [id: string]: E.Texture;
+      };
+      pending: any[];
+      clonedTextures: any[];
+      runScene: RunScene;
+      loadConfig: ParseType;
+      constructor(runScene: RunScene, loadConfig: ParseType);
+      parser: GLTFParser | null;
+      processInput(_input: any, parser: GLTFParser): Promise<void>;
+      processTexture(map: {
+          texture: E.Texture;
+          textureDef: Obj;
+      }): void;
+      process(map: {
+          material: E.Material;
+          materialDef: Obj;
+          model: E.Model;
+      }): void;
+      done(json: any): Promise<any>;
+      processTextureMap: (textureMap: ExportGltfHelperBeforeJson["textureMap"]) => void;
+      processMaterialMap: (materialMap: ExportGltfHelperBeforeJson["materialMap"]) => void;
+      baseMaterialTextures: {
+          texture: E.Texture;
+          material: E.Material;
+          type: string;
+      }[];
+      processBaseMaterialTextures: (map: {
+          material: E.Material;
+          textures: {
+              [uuid: string]: string;
+          };
+      }) => void;
+      lazyLoad: () => Promise<unknown>;
+      processClonedTextures(): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Loaderer/GLTFLoader/GLTFLoaderHelper/LoaderOptions' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { ImageBitmapLoader } from "run-scene-v2/libs/loaderer/ImageBitmapLoader/index";
+  import { ParseType } from "run-scene-v2/src/Loaderer/GLTFLoader/LoaderGltf";
+  export default class GltfLoaderHelperOptions {
+      textureLoader: ImageBitmapLoader;
+      runScene: RunScene;
+      loadConfig: ParseType;
+      constructor(runScene: RunScene, loadConfig: ParseType);
+      setTextureLoader(textureLoader: ImageBitmapLoader): void;
+      initTextureLoader(textureLoader: ImageBitmapLoader): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Loaderer/GLTFLoader/GLTFLoaderHelper/LoaderScene' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { ExportGltfJson } from "run-scene-v2/src/Exporter/GLTFExporter/ExporterGltf";
+  import { ParseType } from "run-scene-v2/src/Loaderer/GLTFLoader/LoaderGltf";
+  export default class GltfLoaderHelperModel {
+      runScene: RunScene;
+      loadConfig: ParseType;
+      constructor(runScene: RunScene, loadConfig: ParseType);
+      done(json: ExportGltfJson): void;
+      controls(controls: ExportGltfJson["asset"]["ex"]["controls"]): void;
+      camera(camera: ExportGltfJson["asset"]["ex"]["camera"]): void;
+      lights(lights: ExportGltfJson["asset"]["ex"]["lights"]): void;
+      options(options: Array<{
+          type: string;
+          data: string;
+      }>): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Loaderer/GLTFLoader/LoaderGltf' {
+  import { gltfExOptions } from "run-scene-v2/libs/loaderer/GLTFLoader/index";
+  import { ExportGltfJson, ExportGltfType } from "run-scene-v2/src/Exporter/GLTFExporter/ExporterGltf";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export type ParseType = {
+      addToScene?: boolean;
+      cleanJSON?: boolean;
+      triggerCb?: boolean;
+      reverseTexture?: boolean;
+      getJSON?: (json: ExportGltfJson) => void;
+  };
+  export default class LoaderGltf {
+      dracoPath: string;
+      private _gltf;
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      load(url: string, options?: ParseType): Promise<void | any[]>;
+      /**
+       *
+       * @param data arrayBuffer 类型化数组
+       * @param options  配置想
+       *{
+        是否添加到场景 默认开
+          addToScene?: boolean;
+        是否解析后销毁json 默认开
+          cleanJSON?: boolean;
+        是否触发挂载的事件 默认关
+          triggerCb?: boolean;
+        是否在加载是翻转贴图 默认关
+          reverseTexture?: boolean;
+       }
+       * @returns 加载成功 返回模型数组
+       */
+      parse(data: ArrayBuffer, options?: ParseType): Promise<E.unknowModel[]>;
+      beforeParse(type: ExportGltfType): void;
+      afterParse(options: gltfExOptions, json: ExportGltfJson, loadConfig: ParseType): E.unknowModel[] | undefined;
+      parseMaterial(models: E.unknowModel[]): undefined;
+      parseModel(model: E.unknowModel): any[];
+      parseScene(map: {
+          model: E.unknowModel;
+          json: ExportGltfJson;
+          config: ParseType;
+      }): any;
+      disposeJSON(json: ExportGltfJson): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Loaderer/JsonModelLoader/JsonModelLoader' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { ObjectLoader } from "three";
+  export default class JsonModelLoader {
+      runScene: RunScene;
+      _objectLoader: ObjectLoader;
+      private _parser;
+      constructor(runScene: RunScene);
+      parse(json: any): Promise<any>;
+  }
+
+}
+declare module 'run-scene-v2/src/Loaderer/Loaderer' {
+  import { ImageBitmapLoader, ObjectLoader } from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import LoaderGltf from "run-scene-v2/src/Loaderer/GLTFLoader/LoaderGltf";
+  import AnimaLoader from "run-scene-v2/src/Loaderer/AnimaLoader";
+  import JsonModelLoader from "run-scene-v2/src/Loaderer/JsonModelLoader/JsonModelLoader";
+  export default class Loaderer {
+      gltf: LoaderGltf;
+      imgBitMap: ImageBitmapLoader;
+      object: ObjectLoader;
+      runScene: RunScene;
+      json: JsonModelLoader;
+      constructor(runScene: RunScene);
+  }
+  export const animaLoader: AnimaLoader;
+
+}
+declare module 'run-scene-v2/src/Material/BaseMaterial' {
+  import { Obj } from "js-funcs/dts/def";
+  import { Color, Material, MeshStandardMaterial, Vector2 } from "three";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export type ExportGltfTextures = {
+      type: string;
+      texture: E.Texture;
+  }[];
+  export type BaseMaterialTools = {
+      type: string;
+      getTextures(material: E.Material): ExportGltfTextures;
+      parseData(map: {
+          normal: Obj;
+          textures: ExportGltfTextures;
+          models: E.unknowModel[];
+          material: E.BaseMaterial;
+      }): E.Material;
+      toNormal(material: E.Material): Material;
+      clone(material: E.Material, newModel: E.unknowModel): Material;
+  };
+  export class BaseMaterial {
+      static create(): MeshStandardMaterial;
+      static isDefval(materail: E.BaseMaterial): boolean;
+      static defVal: {
+          color: Color;
+          emissive: Color;
+          roughness: number;
+          metalness: number;
+          lightMapIntensity: number;
+          aoMapIntensity: number;
+          emissiveIntensity: number;
+          bumpScale: number;
+          normalScale: Vector2;
+          displacementScale: number;
+          envMapIntensity: number;
+          wireframe: boolean;
+          transparent: boolean;
+          depthTest: boolean;
+          depthWrite: boolean;
+          opacity: number;
+      };
+  }
+
+}
+declare module 'run-scene-v2/src/Material/defMaterial/FakeInterior' {
+  import * as THREE from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { BaseMaterialTools } from "run-scene-v2/src/Material/BaseMaterial";
+  export class FakeInterior {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      private static TextureNames;
+      create(): THREE.ShaderMaterial;
+      undo(map: {
+          material: E.Material;
+          list: string[];
+          val: any;
+      }): void;
+      tools: BaseMaterialTools;
+  }
+
+}
+declare module 'run-scene-v2/src/Material/defMaterial/Fresnel' {
+  import { MeshPhysicalMaterial, Uniform } from "three";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { BaseMaterialTools } from "run-scene-v2/src/Material/BaseMaterial";
+  import RunScene from "run-scene-v2/src/RunScene";
+  export class Fresnel {
+      runScene: RunScene;
+      private static TextureNames;
+      constructor(runScene: RunScene);
+      create(newModel?: E.unknowModel): MeshFresnelMaterial;
+      undo(map: {
+          material: E.Material;
+          list: string[];
+          val: any;
+      }): void;
+      tools: BaseMaterialTools;
+  }
+  class MeshFresnelMaterial extends MeshPhysicalMaterial {
+      isSurge: Uniform;
+      deltaTime: Uniform;
+      fresnelBias: Uniform;
+      fresnelScale: Uniform;
+      fresnelPower: Uniform;
+      private readonly cubeCamera;
+      private readonly clock;
+      runScene: RunScene;
+      constructor(baseParameters?: any, additionalParameters?: any, runScene?: RunScene);
+      insertFresnelShader(): void;
+      update(): void;
+  }
+  export {};
+
+}
+declare module 'run-scene-v2/src/Material/defMaterial/MySpriteMaterial' {
+  import { Material, SpriteMaterial } from "three";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { BaseMaterialTools } from "run-scene-v2/src/Material/BaseMaterial";
+  export default class MySpriteMaterial {
+      static create(): SpriteMaterial;
+      static modelTools: {
+          merge(f: E.unknowModel, t: E.unknowModel): void;
+          toNormal: (model: E.unknowModel, _material?: E.Material) => any;
+          parseData: (m: E.unknowModel, _normal: {
+              type: string;
+          }) => any;
+      };
+      static tools: BaseMaterialTools;
+  }
+
+}
+declare module 'run-scene-v2/src/Material/defMaterial/Physical' {
+  import { MeshPhysicalMaterial } from "three";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { BaseMaterialTools } from "run-scene-v2/src/Material/BaseMaterial";
+  import RunScene from "run-scene-v2/src/RunScene";
+  export class Physical {
+      private readonly runScene;
+      private static readonly IgnoredAttributes;
+      private static readonly TextureNames;
+      constructor(runScene: RunScene);
+      create(newModel?: E.unknowModel): MeshPhysicalMaterial;
+      undo(map: {
+          material: E.Material;
+          list: string[];
+          val: any;
+      }): void;
+      tools: BaseMaterialTools;
+  }
+
+}
+declare module 'run-scene-v2/src/Material/defMaterial/Reflector/GaussBlurShader' {
+  import { Uniform } from "three";
+  export const HorizontalBlurShader: {
+      uniforms: {
+          tDiffuse: Uniform;
+          h: Uniform;
+      };
+      vertexShader: string;
+      fragmentShader: string;
+  };
+  export const VerticalBlurShader: {
+      uniforms: {
+          tDiffuse: Uniform;
+          v: Uniform;
+      };
+      vertexShader: string;
+      fragmentShader: string;
+  };
+  export const DepthShader: {
+      uniforms: {
+          tDiffuse: Uniform;
+          depthBuffer: Uniform;
+          depthScale: Uniform;
+          minDepthThreshold: Uniform;
+          maxDepthThreshold: Uniform;
+          texelSize: Uniform;
+          cameraNear: Uniform;
+          cameraFar: Uniform;
+      };
+      vertexShader: string;
+      fragmentShader: string;
+  };
+
+}
+declare module 'run-scene-v2/src/Material/defMaterial/Reflector/Reflector' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { BaseMaterialTools } from "run-scene-v2/src/Material/BaseMaterial";
+  import { MeshStandardMaterial, Uniform } from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  export class Reflector {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      private static TextureNames;
+      private materials;
+      init(): void;
+      bindData(map: {
+          model: E.unknowModel;
+          material: any;
+      }): void;
+      create(newModel?: E.unknowModel): MeshReflectorMaterial;
+      render: () => void;
+      undo(map: {
+          material: E.Material;
+          list: string[];
+          val: any;
+      }): void;
+      tools: BaseMaterialTools;
+      dispose(): void;
+  }
+  class MeshReflectorMaterial extends MeshStandardMaterial {
+      resolution: number;
+      blurSize: number;
+      tDiffuse: Uniform;
+      tDiffuseBlur: Uniform;
+      textureMatrix: Uniform;
+      mirror: Uniform;
+      mixBlur: Uniform;
+      mixStrength: Uniform;
+      mixContrast: Uniform;
+      private readonly reflectorWorldPosition;
+      private readonly cameraWorldPosition;
+      private readonly rotationMatrix;
+      private readonly normal;
+      private readonly view;
+      private readonly lookAtPosition;
+      private readonly target;
+      private readonly tempQuaternion;
+      private readonly virtualCamera;
+      private reflectorPlane;
+      private clipPlane;
+      private glRT1;
+      private glRT2;
+      private readonly hBlurPass;
+      private readonly vBlurPass;
+      runScene: RunScene;
+      constructor(baseParameters?: any, additionalParameters?: any, runScene?: RunScene);
+      insertReflectorShader(): void;
+      setRTSize(resolution: number): void;
+      setBlurPass(blurSize: number): void;
+      copy(source: any): any;
+      private swapBuffers;
+      private beforeRender;
+      update(reflector: any): void;
+  }
+  export {};
+
+}
+declare module 'run-scene-v2/src/Material/MaterialEx' {
+  import { Obj } from "js-funcs/dts/def";
+  import { MeshStandardMaterial } from "three";
+  import { defMaterialNames } from "run-scene-v2/src/Const/constMaterial";
+  import { BaseMaterial, ExportGltfTextures } from "run-scene-v2/src/Material/BaseMaterial";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { ArrayToUni } from "run-scene-v2/src/Types/type";
+  import MaterialUndo from "run-scene-v2/src/Undo/UndoMaterial";
+  export const defBaseMaterialMap: {
+      depthTest: boolean;
+      depthWrite: boolean;
+      alphaTest: number;
+      side: number;
+      displacementScale: number;
+      visible: boolean;
+      normalScale: {
+          x: number;
+          y: number;
+      };
+      aoMapIntensity: number;
+      lightMapIntensity: number;
+      envMapIntensity: number;
+  };
+  export const defAllMaterialMap: readonly ["color", "emissive", "roughness", "metalness", "normalScale", "aoMapIntensity", "displacementScale", "transparent", "lightMapIntensity", "envMapIntensity", "opacity", "alphaTest"];
+  export default class EngineMaterial {
+      runScene: RunScene;
+      select: undefined | E.Material;
+      constructor(runScene: RunScene);
+      defMaterialMap: Obj;
+      defMaterial: MeshStandardMaterial;
+      addCb: (mate: E.BaseMaterial) => void;
+      add(m: E.Material, useModel?: E.unknowModel, oldMaterial?: E.BaseMaterial): void;
+      create(): MeshStandardMaterial;
+      clone(m: E.Material): E.Material;
+      setParses: any[];
+      addSetParses(parse: (map: {
+          material: E.BaseMaterial;
+          type: ArrayToUni<typeof defAllMaterialMap>;
+          newVal: any;
+          oldVal: any;
+      }) => void): void;
+      set(map: {
+          material: E.BaseMaterial;
+          type: ArrayToUni<typeof defAllMaterialMap>;
+          val: any;
+      }): any[];
+      setNormal(map: {
+          target: E.BaseMaterial;
+          info: E.BaseMaterialInfo;
+          newVal: any;
+          oldVal: any;
+      }, addUndo?: boolean): MaterialUndo;
+      setTexture(map: {
+          target: E.BaseMaterial;
+          info: E.BaseMaterialTexture;
+          newVal: File | E.Texture | string | null;
+      }, addUndo?: boolean): Promise<E.Texture>;
+      resetMaterial(model: E.unknowModel | null | undefined | E.unknowModel[], material: E.Material | null, addUndo?: boolean): void;
+      getBase(type: ArrayToUni<typeof defMaterialNames>): any;
+      toNromal(material: E.Material): any;
+      setSelect(mate: E.Material | null): void;
+      getDataByType(type: ArrayToUni<typeof defMaterialNames>, map: {
+          normal: Obj;
+          textures: ExportGltfTextures;
+          models: E.unknowModel[];
+          material: E.BaseMaterial;
+      }): any;
+      dispose(): void;
+      remove(_m: E.BaseMaterial): void;
+      getDefNromals(material: E.BaseMaterial): Obj;
+      parseNromals(map: any, material: E.Material): void;
+      isBaseMaterial(material: E.BaseMaterial): boolean;
+  }
+  export const createDefMaterial: () => MeshStandardMaterial;
+  export const mergeMaterial: (from: E.BaseMaterial, to: E.BaseMaterial) => E.BaseMaterial;
+  export const disposeMaterial: (m: E.Material) => void;
+  export const getTexturesByMaterial: (material: E.Material) => {
+      type: string;
+      texture: E.Texture;
+  }[];
+  export const getTextures: (m: E.Material) => any;
+  export const getBaseTextures: (m: E.Material) => {
+      type: "map" | "metalnessMap" | "roughnessMap" | "normalMap" | "aoMap" | "emissiveMap" | "alphaMap" | "lightMap" | "envMap" | "displacementMap";
+      texture: any;
+  }[];
+  export const setMaterialTexture: (map: {
+      material: E.Material;
+      type: E.BaseMaterialTexture;
+      texture: E.Texture | null;
+  }) => void;
+  export const initMaterial: (material: E.Material) => void;
+  export const isColor: (color: any) => any;
+  export const updateMaterial: (material: E.Material) => void;
+  export const isMaterial: (m: E.Material) => boolean;
+
+}
+declare module 'run-scene-v2/src/ModelEx/ModelEx.Clone' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export const getModelExCloneFn: (runScene: RunScene) => (model: E.unknowModel, add?: boolean) => any;
+
+}
+declare module 'run-scene-v2/src/ModelEx/ModelEx' {
+  import { Mesh, Vector3 } from "three";
+  import { defModelNames, exModelNames } from "run-scene-v2/src/Const/constModel";
+  import { ArrayToUni } from "run-scene-v2/src/Types/type";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  import { NormalUndoCbData } from "run-scene-v2/src/Undo/UndoNormal";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import Three from "run-scene-v2/src/Libs/Three";
+  import { Obj } from "js-funcs/dts/def";
+  export type EngineModelV3Names = "position" | "rotation" | "scale";
+  export type EngineModelNormalNames = "name" | "receiveShadow" | "castShadow" | "renderOrder" | "visible";
+  export type ModelDef = {
+      wireframe: boolean;
+      extras: {
+          isHelper: Boolean;
+          layers: number | undefined;
+          normal: {
+              type: string;
+          };
+          local: string;
+          cloneId: string;
+          id?: string;
+          animations?: Obj[];
+      };
+  };
+  export type DefModelTypes = ArrayToUni<typeof defModelNames>;
+  export type ExModelNames = ArrayToUni<typeof exModelNames>;
+  export default class EngineModel {
+      private _selectModel;
+      get select(): E.Model | undefined;
+      set select(model: E.Model | undefined);
+      defNodeMap: {
+          castShadow: boolean;
+          receiveShadow: boolean;
+          renderOrder: number;
+          visible: boolean;
+      };
+      runScene: RunScene;
+      clone: (model: E.unknowModel, add?: boolean) => E.unknowModel;
+      constructor(runScene: RunScene);
+      add: (model: E.Model | E.Model[], parent?: E.Model, options?: {
+          addUndo?: boolean;
+          isClone?: boolean;
+          select?: boolean;
+      }) => any;
+      setSelectByModel(model: E.unknowModel, options?: {
+          isDomTreeActive?: boolean;
+          isClone?: boolean;
+      }): boolean;
+      setSelectById(id: string): void;
+      remove(model: E.Model | E.Model[], addUndo?: boolean): any;
+      isNavieV3(v3: E.V3, targetNum?: number): boolean;
+      isNavieV2(v2: E.V2, num?: number): boolean;
+      isUnless(model: E.unknowModel): boolean;
+      isUnlessLevel(model: E.unknowModel): boolean;
+      create(): any;
+      getLevel(model: E.Model, level?: number): number;
+      selectNull(): void;
+      cloneV3(v3: E.V3): E.V3;
+      setParent(model: E.Model, parent: E.Model, addUndo?: boolean): undefined | UndoBase;
+      deepIsVisible: (model: E.Model) => any;
+      setV3(map: {
+          model: E.Model | E.Model[];
+          info: EngineModelV3Names;
+          newV3: any;
+          oldV3?: E.V3;
+      }, addUndo?: boolean, execute?: boolean): void;
+      setNormal(map: {
+          model: E.Model | E.Model[];
+          info: EngineModelNormalNames;
+          val: any;
+          oldVal?: any;
+          executeCb?: (data: NormalUndoCbData) => void;
+      }, addUndo?: boolean): UndoBase | UndoBase[];
+      setMaterial(model: E.unknowModel, val: any, addUndo?: boolean): void;
+      addDef(type: DefModelTypes): void;
+      isModel(model: E.unknowModel): boolean;
+      getSphere(): E.unknowModel;
+      getIndexByModel(model: E.unknowModel): number;
+      getBeTweenChildByTwoModel(a: E.unknowModel, b: E.unknowModel): undefined | E.unknowModel[];
+      setMultip(map: {
+          model: any;
+          typeList: string[];
+          newVal: any;
+      }): void;
+      createGroup(model: E.unknowModel | E.unknowModel[], parent?: E.unknowModel, groupParent?: E.unknowModel): void;
+      cleanGroup(model: E.unknowModel, addUndo?: boolean): any[];
+      hideOther(model: any): void;
+      showAll(): void;
+      removeHide(): void;
+      /**
+       *
+       * @param {*} name string | array<string>
+       * @param {*} type array | map
+       * @returns model | models | map { [modelName] : model}
+       */
+      private _getModel;
+      /**
+       *
+       * @param name 模型名或者模型名字的数组
+       * @param type array或者map
+       *  如果传入的name是字符串 那么返回名称对应的模型
+       *  如果传入的name是数组，
+       *       如果type是array 那么返回模型数组
+       *       如果type是map 那么返回 模型名称和模型的键值对{ [name:string]：model}
+       * @returns
+       */
+      getModel(name: string | string[], type?: string): any;
+      getWorldLocal(obj: E.unknowModel | Mesh): Vector3;
+      getClickObj(e: any, needsClickModels: any[], filterHideModel?: boolean): {
+          intersects: any[] | null;
+          obj: any;
+      };
+      getCamLocal(): {
+          cx: number;
+          cy: number;
+          cz: number;
+          tx: number;
+          ty: number;
+          tz: number;
+      };
+      /**
+       * 作用：
+       * @param {*} begin map 开始的对象
+       * @param {*} end map 结束的map
+       * @param {*} time 时间， 默认1秒
+       * @returns promise 动画结束回调res函数，返回动画实例
+       *
+       */
+      camAnima(begin: Obj, end: Obj, time: number, onDone: Function, onUpdate: Function): import("run-scene-v2/libs/Anima/index").TweenMax;
+      /**
+       *
+       * @param model 模型
+       * @param status  是否开启辉光
+       */
+      setGlow(model: E.Mesh, status?: boolean): void;
+      beforeLoad(model: E.Model | E.Model[]): any;
+      focus(model: E.unknowModel): void;
+      instance(m: E.unknowModel): void;
+  }
+  export const createDefModel: (type: DefModelTypes & ExModelNames) => any;
+  export const disposeModel: (m: E.unknowModel, options?: {
+      remove?: boolean;
+  }) => void;
+  export const instanceModel: (base: E.Mesh, models: E.Mesh[]) => Three.InstancedMesh<Three.BufferGeometry, Three.Material | Three.Material[]>;
+  export const mergeModel: (material: E.Material, models: E.Mesh[]) => Mesh<Three.BufferGeometry, E.Material>;
+  export const withAnima: (model: E.unknowModel) => boolean;
+  export const setHelper: (t: any) => void;
+  export const setLayers: (m: E.Model, layers: 0 | 1) => void;
+  export const getDeepModels: (model: any) => void;
+  export const hasSkeleton: (model: any) => boolean;
+  export const isDynamicModel: (m: E.unknowModel) => any;
+  export const getClonedModel: (m: E.unknowModel) => any;
+  export const setClonedModel: (m: E.unknowModel, id: string) => void;
+  export const isGLowModel: (m: E.unknowModel) => boolean;
+  export const isSprite: (m: E.unknowModel) => any;
+
+}
+declare module 'run-scene-v2/src/MultipSelector/MultipSelector' {
+  import { Obj } from "js-funcs/dts/def";
+  import { Group } from "three";
+  import { EngineModelV3Names } from "run-scene-v2/src/ModelEx/ModelEx";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import RunScene from "run-scene-v2/src/RunScene";
+  export default class MultipSelector {
+      selectors: Obj;
+      boxHelperMap: Obj;
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      add(model: E.unknowModel | E.unknowModel[], cover?: boolean): any;
+      setInfo(obj: any, info: EngineModelV3Names, oldVal: any, newVal: any, wNewVal: any, wOldVal: any): void;
+      getLast(): any;
+      addBoxHelper(model: any): void;
+      removeBoxHelper(model: any): void;
+      remove(model: E.unknowModel | E.unknowModel[]): any;
+      isEmpty(): boolean;
+      getSelectedList(type: "key" | "value"): any[];
+      getSelect(): undefined | E.unknowModel[];
+      selectedLoop(fn: (key: string, value: any) => void): void[];
+      delete(): void;
+      setBoxHelperEmpty(): void;
+      setEmpty(): void;
+      createGroup(): void;
+      getSelectorGroup(): Group;
+  }
+
+}
+declare module 'run-scene-v2/src/OptionsEx' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import Stats from "three/examples/jsm/libs/stats.module.js";
+  export type OptionsMap = {
+      msg?: {
+          show: boolean;
+          level: "base" | "detail";
+      };
+      run?: boolean;
+      decodePath?: string;
+      showFps?: boolean;
+      loadInterval?: number;
+      mode?: "editor" | "debug" | "running";
+      hideLocal?: boolean;
+      instanceClone?: boolean;
+      renderMode?: "tick" | "controlsChange";
+      render2?: boolean;
+      render3?: boolean;
+      texture?: {
+          load?: boolean;
+          lazyLoad?: {
+              open?: boolean;
+              intervalTime?: number;
+          };
+          quality?: number;
+      };
+  };
+  export class OptionsEx {
+      options: OptionsMap;
+      exporterOptions: {
+          compressTexture: boolean;
+          notMaterial: boolean;
+          outTime: number;
+      };
+      stats: Stats | undefined;
+      runScene: RunScene;
+      sceneOptions: {
+          loaded: boolean;
+      };
+      constructor(runScene: RunScene);
+      init(options: any): void;
+      setLoadInterval: (map: {
+          inputInterval: number;
+          cb: Function;
+      }) => void;
+      addFps(): void;
+      render(): void;
+      log(msg: any, level?: "base" | "detail", type?: string): void;
+  }
+
+}
+declare module 'run-scene-v2/src/RenderEx' {
+  import { WebGLRenderer } from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  export default class EngineWebGlRender {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      setBackground(color: string | null): void;
+      create(dom: HTMLElement): WebGLRenderer;
+      setSize: (w?: number, h?: number) => void;
+      /**
+       *
+       * @returns {
+        w: number; 根节点dom的宽
+        h: number; 根节点dom的高
+      }
+       */
+      getDomSize(): {
+          width: number;
+          height: number;
+      };
+  }
+  export const disposeRenderer: (renderer: WebGLRenderer, options?: {
+      removeDom?: boolean;
+  }) => void;
+
+}
+declare module 'run-scene-v2/src/RunScene' {
+  import Anima from "run-scene-v2/src/Anima/Anima";
+  import AssetsEx from "run-scene-v2/src/AssetsEx";
+  import { MTGlow } from "run-scene-v2/src/Bloom/Glow/MTGlow";
+  import CallBack from "run-scene-v2/src/CallBack/CallBack";
+  import CameraEx from "run-scene-v2/src/CameraEx";
+  import ControlsEx from "run-scene-v2/src/ControlsEx";
+  import Events from "run-scene-v2/src/Events/Events";
+  import Exporter from "run-scene-v2/src/Exporter/Exporter";
+  import FileEx from "run-scene-v2/src/FileEx/FileEx";
+  import GlobalConfig from "run-scene-v2/src/GlobalConfig";
+  import HelperEx from "run-scene-v2/src/Helper/HelperEx";
+  import three from "run-scene-v2/src/Libs/Three";
+  import LightEx from "run-scene-v2/src/Lights/LightEx";
+  import { ParseType } from "run-scene-v2/src/Loaderer/GLTFLoader/LoaderGltf";
+  import Loaderer from "run-scene-v2/src/Loaderer/Loaderer";
+  import MaterialEx from "run-scene-v2/src/Material/MaterialEx";
+  import ModelEx from "run-scene-v2/src/ModelEx/ModelEx";
+  import MultipSelector from "run-scene-v2/src/MultipSelector/MultipSelector";
+  import { OptionsEx, OptionsMap } from "run-scene-v2/src/OptionsEx";
+  import RenderEx from "run-scene-v2/src/RenderEx";
+  import SceneEx from "run-scene-v2/src/SceneEx";
+  import Script from "run-scene-v2/src/Script/Script";
+  import TextureEx from "run-scene-v2/src/TextureEx";
+  import TimeLine from "run-scene-v2/src/TimeLine/TimeLine";
+  import Undo from "run-scene-v2/src/Undo/Undo";
+  import Unique from "run-scene-v2/src/Unique/Unique";
+  export * from "run-scene-v2/src/Libs/Bus";
+  export * as MaterialEx from "run-scene-v2/src/Material/MaterialEx";
+  export * as ModelEx from "run-scene-v2/src/ModelEx/ModelEx";
+  export * as TextureEx from "run-scene-v2/src/TextureEx";
+  export * as Utils from "run-scene-v2/src/Utils/Utils";
+  export const Three: typeof three;
+  class RunScene {
+      cb: CallBack;
+      script: Script;
+      uniqueEx: Unique;
+      fileEx: FileEx;
+      optionsEx: OptionsEx;
+      undoEx: Undo;
+      textureEx: TextureEx;
+      controlsEx: ControlsEx;
+      assetsEx: AssetsEx;
+      renderEx: RenderEx;
+      events: Events;
+      multipSelector: MultipSelector;
+      helperEx: HelperEx;
+      materialEx: MaterialEx;
+      cameraEx: CameraEx;
+      sceneEx: SceneEx;
+      modelEx: ModelEx;
+      loaderer: Loaderer;
+      exporter: Exporter;
+      lightEx: LightEx;
+      timeLineEx: TimeLine;
+      anima: Anima;
+      globalConfig: GlobalConfig;
+      bloom: {
+          glow: MTGlow;
+      };
+      constructor(map: {
+          rootDom: HTMLElement;
+          path: string | ArrayBuffer;
+          options?: OptionsMap;
+          loadConfig?: ParseType;
+      });
+      load(map: {
+          rootDom: HTMLElement;
+          path: string | ArrayBuffer;
+          loadConfig?: ParseType;
+      }): void;
+      loadScene(path: string | ArrayBuffer, loadConfig?: ParseType): Promise<any[]>;
+      render: () => void;
+      dispose(): void;
+      on(type: "lazyLoadedTexture" | "loaded" | "modelLoaded" | "getJOSN" | "progress" | "getArrayBuffer" | "complete", fn: (...data: any[]) => void): this;
+      setSize(width: number, height: number): void;
+  }
+  export default RunScene;
+
+}
+declare module 'run-scene-v2/src/SceneEx' {
+  import { Obj } from "js-funcs/dts/def";
+  import { Fog, Scene } from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { EngineTextureSupportTypes } from "run-scene-v2/src/TextureEx";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  export type EngineSceneNormalNames = "environment" | "fog" | "background";
+  export default class EngineScene {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      oldFog: null | Fog;
+      each(fn: (model: E.Model) => any): void;
+      get(): Scene;
+      getNromal(): import("three").Object3D<import("three").Event>[];
+      removeMap: {
+          light: {
+              valid: (model: E.unknowModel) => any;
+              remove: (model: E.unknowModel) => UndoBase[];
+          };
+      };
+      remove(model: E.unknowModel | E.unknowModel[]): any;
+      cleanUnlessLevel(model: E.unknowModel): E.unknowModel;
+      searchModel(name: string): any[];
+      getClearModels(): import("three").Object3D<import("three").Event>[];
+      getClear(): any;
+      cleanNormal(): void;
+      cleanSceneInfo(scene: E.Scene): void;
+      setBackground(texture: E.Texture | null | E.Color, addUndo?: boolean): Promise<import("three").Color | import("three").Texture>;
+      isBackground(texture: E.Texture): any;
+      clean(): void;
+      dispose(): void;
+      render(): void;
+      create(): Scene;
+      setEnv(data: EngineTextureSupportTypes): Promise<any>;
+      setNormal(map: {
+          model: E.Scene;
+          info: EngineSceneNormalNames;
+          val: any;
+      }, addUndo?: boolean): void;
+      setFogShow(map: {
+          show: boolean;
+          color?: string;
+      }): void;
+      setFog(map: {
+          type: "near" | "far" | "color";
+          val: any;
+      }): void;
+      sreenShotDefFile(width?: number, height?: number): File;
+      static toJSON(scene: E.Scene): Obj;
+  }
+  export const setUserData: (target: any, type: string, data: any) => void;
+  export const getJsonByFog: (fog: Fog) => {
+      color: string;
+      far: number;
+      near: number;
+  };
+  export const getUserData: (target: any, type: string) => any;
+  export const delUserData: (target: any, type: string) => void;
+
+}
+declare module 'run-scene-v2/src/Script/Script' {
+  import BaseEx from "run-scene-v2/src/BaseEx";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import ScriptTexture from "run-scene-v2/src/Script/ScriptTexture";
+  export default class Script extends BaseEx {
+      texture: ScriptTexture;
+      runAll: boolean;
+      constructor(runScene: RunScene);
+      playAll(): void;
+      closeAll(): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Script/ScriptTexture' {
+  import BaseEx from "run-scene-v2/src/BaseEx";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import MapEx from "run-scene-v2/src/Ex/MapEx";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import { TextureUserDataEx } from "run-scene-v2/src/TextureEx";
+  export default class ScriptTexture extends BaseEx {
+      constructor(runScene: RunScene);
+      map: MapEx<string, {
+          texture: E.Texture;
+          uvScript: TextureUserDataEx["uvScript"];
+      }>;
+      private renderName;
+      parse(uvScript: TextureUserDataEx["uvScript"], texture: E.Texture): void;
+      private bindEvent;
+      playAll(): void;
+      closeAll(): void;
+  }
+
+}
+declare module 'run-scene-v2/src/TextureEx' {
+  import { Texture } from "three";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export type EngineTextureSupportTypes = File | string | null | Texture;
+  export type TextureUserDataEx = {
+      id: string;
+      blob: Blob;
+      md5: string;
+      url: string;
+      isNromalMap: true;
+      notCompress: true;
+      uvScript: {
+          moveX?: number;
+          moveY?: number;
+          rotate?: number;
+      };
+  };
+  export default class EngineTexture {
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      allTextures: Set<E.Texture>;
+      load(url: string): Promise<E.Texture>;
+      parse(file: File | Blob): Promise<E.Texture>;
+      clone(oldTexture: E.Texture): E.Texture;
+      getDef(img?: ImageBitmap): Texture;
+      private getSameAndAddtoAll;
+      afterLoad(texture: E.Texture, blob?: Blob): Promise<Texture>;
+      getSameTexture(md5: string, oldTexture: E.Texture): E.Texture | undefined;
+      initTextureAndAddtoAll(texture: E.Texture): Promise<Texture>;
+      addTextureToAll(texture: E.Texture): void;
+      getBlobAndBase64(texture: E.Texture): Promise<{
+          blob: Blob;
+          base64: string;
+      }>;
+      coverByImage(texture: E.Texture, file: File | null | E.Texture): Promise<void>;
+      remove(texture: E.Texture): void;
+      delete(texture: E.Texture): void;
+      setAnima: (m: {
+          texture: E.Texture;
+          type: "moveX" | "moveY" | "rotate";
+          val: number;
+      }) => void;
+      reverseImageBitMapTexture(texture: E.Texture): Promise<E.Texture>;
+  }
+  export const textureNameMap: {
+      环境遮蔽: string;
+      法线: string;
+      金属度: string;
+      粗糙度: string;
+      自发光: string;
+      颜色: string;
+      置换: string;
+      光照贴图: string;
+      环境: string;
+      透明度: string;
+  };
+  export const getMimeByTexture: (texture: E.Texture) => "image/png" | "image/jpeg";
+  export const getTextureGpuMemory: (texture: E.Texture) => number;
+  export const disposeTexture: (texture: E.Texture | null) => void;
+  export const bindTextureBaseData: (texture: E.Texture, inputBlob?: Blob) => Promise<Texture>;
+  export const getBlobByTexture: (texture: E.Texture) => any;
+  export const initTexture: (texture: E.Texture) => Texture;
+  export const parseImageBitMapByBlob: (blob: Blob) => Promise<ImageBitmap>;
+  export const loadTexture: (urlOrBlob: string | Blob) => Promise<Texture>;
+  export const getUrlByTexture: (texture: E.Texture) => any;
+  export const setTextureMapping: (texture: E.Texture, type?: "repeat" | "normal") => Texture;
+  export const getSizeByTexture: (texture: E.Texture) => {
+      width: any;
+      height: any;
+  };
+  export const isTexture: (texture: any) => boolean;
+  export const isClonedTexture: (texture: E.Texture) => boolean;
+  export const getCloneIdFromTexture: (texture: E.Texture) => string;
+  export const setTextureCloneId: (texture: E.Texture, id: string) => void;
+  export const updateTexture: (texture: E.Texture) => void;
+  export const setTextureMinFilter: (texture: E.Texture, mode: "linear" | "nearest") => void;
+  export const getTextureMinFilter: (texture: E.Texture) => "linear" | "nearest";
+
+}
+declare module 'run-scene-v2/src/TimeLine/TimeLine.Camera' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { TimeLineType } from "run-scene-v2/src/TimeLine/TimeLine";
+  import TimeLineBase from "run-scene-v2/src/TimeLine/TimeLineBase";
+  export namespace TimeLineCameraType {
+      interface beginData {
+          position: TimeLineType.V3;
+          scale: TimeLineType.V3;
+          rotation: TimeLineType.V3;
+          target: TimeLineType.V3;
+      }
+  }
+  class TimeLineCamera extends TimeLineBase {
+      type: string;
+      defOptions: {
+          [targetType: string]: {
+              type: "V3";
+          };
+      };
+      controls: any;
+      beginData: TimeLineCameraType.beginData;
+      constructor(target: any, runScene: RunScene);
+      static getTarget(uuid: any, runScene: RunScene): any;
+      getBeginData(_target: any): any;
+      isRemoved(): boolean;
+      getAllData(notNow?: boolean): any;
+      getData(type: string): {
+          x: number;
+          y: number;
+          z: number;
+      };
+      getAnima(group: TimeLineType.Group, reverse?: boolean): any[];
+      setTargetByBetween: (left: any, right: any, progress: number) => void;
+      getAnimaByModelData: (map: TimeLineType.Data, model: any, group: TimeLineType.Group, reverse?: boolean) => any[];
+      getId(): string;
+      reset(): void;
+  }
+  export default TimeLineCamera;
+
+}
+declare module 'run-scene-v2/src/TimeLine/TimeLine' {
+  import { ArrType } from "js-funcs/type/arr";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import TimeLineCamera from "run-scene-v2/src/TimeLine/TimeLine.Camera";
+  import TimeLineMaterial from "run-scene-v2/src/TimeLine/TimeLine.Material";
+  import TimeLineModel from "run-scene-v2/src/TimeLine/TimeLine.Model";
+  import TimeLineBase from "run-scene-v2/src/TimeLine/TimeLineBase";
+  export const timeLineMap: {
+      model: typeof TimeLineModel;
+      camera: typeof TimeLineCamera;
+      material: typeof TimeLineMaterial;
+  };
+  export namespace TimeLineType {
+      interface Group {
+          time: number;
+          enable: boolean;
+          run: boolean;
+          loop: boolean;
+          reverse: boolean;
+          speed: number;
+          data: ModelItem;
+          curve: boolean;
+          name: string;
+      }
+      interface V3 {
+          x: number;
+          y: number;
+          z: number;
+      }
+      interface ModelItem {
+          [modelUniqueUUid: string]: TimeLineBase;
+      }
+      interface Data {
+          [time: string]: {
+              position?: V3;
+              scale?: V3;
+              rotation?: V3;
+          };
+      }
+      interface allSupportType {
+          any: "position" | "scale" | "rotation";
+      }
+      interface A {
+          position: V3;
+          scale: V3;
+          rotation: V3;
+      }
+      interface GetDataBack {
+      }
+  }
+  class TimeLine {
+      timerMap: {
+          [groupName: string]: {
+              setProgressTime: any;
+              awaitRuned: any;
+          };
+      };
+      animaMap: {
+          [groupName: string]: ArrType.eachTriggerBack[];
+      };
+      groupMap: {
+          [name: string]: TimeLineType.Group;
+      };
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      reset(): void;
+      closeGroup(groupName: string): void;
+      resetGroup(groupName: string): void;
+      getSavedData(): {
+          [name: string]: TimeLineType.Group;
+      };
+      parseSavedGroupMap(groupMap: any): void;
+      playGroup(groupName: string): undefined | Promise<undefined | Promise<any>>;
+      setModelLocal: (group: TimeLineType.Group, nowVal: number) => void;
+  }
+  export default TimeLine;
+
+}
+declare module 'run-scene-v2/src/TimeLine/TimeLine.Material' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import TimeLineBase from "run-scene-v2/src/TimeLine/TimeLineBase";
+  export namespace TimeLineMaterialType {
+      interface beginData {
+          roughness: {
+              type: "number";
+          };
+          metalness: {
+              type: "number";
+          };
+          opacity: {
+              type: "number";
+          };
+          emissive: {
+              type: "color";
+          };
+          color: {
+              type: "color";
+          };
+      }
+  }
+  class TimeLineMaterial extends TimeLineBase {
+      type: string;
+      defOptions: TimeLineMaterialType.beginData;
+      beginData: TimeLineMaterialType.beginData;
+      constructor(target: any, runScene: RunScene);
+      static getTarget(uuid: any, runScene: RunScene): any;
+      isRemoved(): boolean;
+      getId(): string;
+  }
+  export default TimeLineMaterial;
+
+}
+declare module 'run-scene-v2/src/TimeLine/TimeLine.Model' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { TimeLineType } from "run-scene-v2/src/TimeLine/TimeLine";
+  import TimeLineBase, { TimeLineBaseType } from "run-scene-v2/src/TimeLine/TimeLineBase";
+  export namespace TimeLineModelType {
+      interface beginData {
+          position: TimeLineType.V3;
+          scale: TimeLineType.V3;
+          rotation: TimeLineType.V3;
+      }
+  }
+  class TimeLineModel extends TimeLineBase {
+      type: string;
+      defOptions: {
+          [key: string]: {
+              type: TimeLineBaseType.DefOptions["all"];
+          };
+      };
+      beginData: TimeLineModelType.beginData;
+      constructor(target: any, runScene: RunScene);
+      static getTarget(uuid: any, runScene: RunScene): any;
+      isRemoved(): boolean;
+      getAnima(group: TimeLineType.Group, reverse?: boolean): (() => {
+          promise: Promise<unknown>;
+          anima: any;
+      })[];
+      setTargetByBetween: (left: any, right: any, progress: number) => void;
+      getAnimaByModelData: (map: TimeLineType.Data, model: any, group: TimeLineType.Group, reverse?: boolean) => (() => {
+          promise: Promise<unknown>;
+          anima: any;
+      })[];
+      getId(): string;
+      reset(): void;
+  }
+  export default TimeLineModel;
+
+}
+declare module 'run-scene-v2/src/TimeLine/TimeLineBase' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { TimeLineType } from "run-scene-v2/src/TimeLine/TimeLine";
+  export namespace TimeLineBaseType {
+      interface Data {
+          [time: string]: any;
+      }
+      interface allType {
+          all: "model" | "camera" | "material";
+      }
+      interface DefOptions {
+          all: "V3" | "boolean" | "number" | "color";
+      }
+  }
+  abstract class TimeLineBase {
+      abstract type: any;
+      abstract defOptions: any;
+      abstract beginData: any;
+      showTransform: boolean;
+      data: TimeLineBaseType.Data;
+      target: any;
+      uuid: string;
+      runScene: RunScene;
+      constructor(target: any, runScene: RunScene);
+      abstract isRemoved(): boolean;
+      toJSON(): {
+          data: TimeLineBaseType.Data;
+          type: any;
+      };
+      addData(time: string, type: string, getAll?: boolean): any;
+      addTriggerNowData(time: string): any;
+      removeData(time: string): void;
+      static isNotNow(data: any): boolean;
+      getAnimaByModelData: (map: TimeLineType.Data, model: any, group: TimeLineType.Group, reverse: boolean, defOptions: any) => (() => {
+          promise: Promise<unknown>;
+          anima: any;
+      })[];
+      static getAllDefValByType(defOptions: any, target: any, notNow?: boolean): any;
+      /**
+       *
+       * @param inputData 需要取值的对象 可以是模型本身或者beginData
+       * @param infoType 需要取值的属性名称
+       * @param defOptions 默认配置 用来确认值的类型
+       * @returns
+       */
+      static getValByType(inputData: any, infoType: string, defOptions: any): any;
+      static setTargetByBetween: (left: any, right: any, progress: number, defOptions: any, target: any) => void;
+      static SetTargetByData(map: {
+          baseType: TimeLineBaseType.DefOptions["all"];
+          data: any;
+          defType: string;
+          target: any;
+      }): void;
+      getAllData(notNow?: boolean): any;
+      getData(type: string): any;
+      static getTarget(_uuid: string, _runScene: RunScene): any;
+      abstract getId(target: any): string;
+      getAnima(group: TimeLineType.Group, reverse?: boolean): Array<() => {
+          promise: Promise<any>;
+          anima: any;
+      }>;
+      setTargetByBetween(left: any, right: any, progress: number): void;
+      clone(target: any): any;
+      reset(): void;
+      remove(): void;
+  }
+  export default TimeLineBase;
+
+}
+declare module 'run-scene-v2/src/Types/Engine' {
+  import { Obj } from "js-funcs/dts/def";
+  import { Euler, Object3D, Vector2, Vector3 } from "three";
+  import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
+  export interface UserData {
+      isTimeLineUsed: boolean | undefined;
+      id: string;
+      fromUrl: string;
+      cloneId: string;
+  }
+  export namespace E {
+      type V3 = Vector3;
+      type V3Info = "x" | "y" | "z";
+      type V2 = Vector2;
+      type Color = THREE.Color;
+      type rotationV3 = Euler;
+      type Model = Object3D & {
+          dom?: HTMLElement;
+      };
+      type Mesh = THREE.Mesh;
+      type unknowModel = any;
+      type AllModel = Mesh | THREE.Light | THREE.Camera;
+      type Material = THREE.Material & Obj;
+      type BaseMaterial = THREE.MeshStandardMaterial & Obj;
+      type BaseMaterialInfo = "color" | "roughness" | "metalness" | "map" | "lightMap" | "depthWrite" | "lightMapIntensity" | "aoMap" | "aoMapIntensity" | "emissive" | "emissiveIntensity" | "emissiveMap" | "bumpMap" | "side" | "alphaTest" | "bumpScale" | "normalMap" | "transparent" | "opacity" | "normalMapType" | "normalScale" | "displacementMap" | "displacementScale" | "displacementBias" | "roughnessMap" | "metalnessMap" | "alphaMap" | "envMap" | "envMapIntensity" | "refractionRatio" | "wireframe";
+      type BaseMaterialTexture = "map" | "metalnessMap" | "roughnessMap" | "normalMap" | "aoMap" | "emissiveMap" | "alphaMap" | "lightMap" | "envMap" | "displacementMap";
+      type Camera = THREE.PerspectiveCamera;
+      type Scene = THREE.Scene;
+      type Controls = OrbitControls;
+      type Texture = THREE.Texture;
+      type Render = THREE.WebGLRenderer;
+  }
+
+}
+declare module 'run-scene-v2/src/Types/type' {
+  export type ArrayToUni<T extends readonly string[]> = T[number];
+
+}
+declare module 'run-scene-v2/src/Undo/Undo' {
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  import RunScene from "run-scene-v2/src/RunScene";
+  export class UndoDataBase {
+      target: {
+          [key: string]: any;
+      };
+      type: string;
+      old: any;
+      new: any;
+      constructor(data: any);
+  }
+  export interface UndoDatetype {
+      target: {
+          [key: string]: any;
+      };
+      type: string;
+      old: any;
+      new: any;
+  }
+  export default class Undo {
+      private undos;
+      private redos;
+      dataMap: {
+          history: Array<UndoBase | UndoBase[]>;
+          index: number;
+      };
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      undo(): void;
+      private addUndos;
+      private removeUndos;
+      undoByIndex(index: number): void;
+      addUndo(data: UndoBase | UndoBase[]): any;
+      addRedo(data: UndoBase | UndoBase[]): void;
+      redo(): void;
+      reset(): void;
+  }
+  var clone: (obj: any) => any;
+  export { clone };
+
+}
+declare module 'run-scene-v2/src/Undo/UndoAdd' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoAddAndRemove from "run-scene-v2/src/Undo/UndoAddAndRemove";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  export default class UndoAdd extends UndoAddAndRemove implements UndoBase {
+      type: string;
+      constructor(map: {
+          model: E.Model;
+          runScene: RunScene;
+          parent: E.Model;
+          cb?: (model: E.unknowModel, type: 'remove' | 'add') => void;
+          addTree?: boolean;
+          isClone?: boolean;
+      });
+      _execute(_data: any): Promise<never>;
+      undo(): void;
+      redo(): void;
+      execute(): this;
+  }
+
+}
+declare module 'run-scene-v2/src/Undo/UndoAddAndRemove' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export type undoAddAndRemoveInput = {
+      model: E.Model;
+      parent: E.Model;
+      addTree?: boolean;
+      isClone?: boolean;
+      runScene: RunScene;
+      cb?: (model: E.unknowModel, type: "remove" | "add") => void;
+  };
+  export default class UndoAddAndRemove {
+      model: E.Model;
+      parent: E.Model;
+      addTree: boolean;
+      isClone: boolean;
+      runScene: RunScene;
+      cb: (_model: E.unknowModel, _type: "remove" | "add") => void;
+      constructor(map: undoAddAndRemoveInput);
+      remove(map: undoAddAndRemoveInput): void;
+      add(map: undoAddAndRemoveInput): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Undo/UndoBase' {
+  export default abstract class UndoBase {
+      abstract type: string;
+      abstract undo(): void;
+      abstract redo(): void;
+      abstract execute(execute?: boolean): any;
+      abstract _execute(data: any, data1?: any): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Undo/UndoFunc' {
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  interface UnfoFuncData {
+      undo: Function;
+      redo: Function;
+  }
+  class UndoFunc extends UndoBase {
+      type: string;
+      _execute(_data: any, _data1?: any): void;
+      info: string;
+      map: UnfoFuncData;
+      constructor(map: UnfoFuncData);
+      execute(): this;
+      undo(): void;
+      redo(): void;
+  }
+  export default UndoFunc;
+
+}
+declare module 'run-scene-v2/src/Undo/UndoMaterial' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  class MaterialUndo extends UndoBase {
+      _execute(data: any, _old: any): void;
+      type: string;
+      target: E.BaseMaterial;
+      info: E.BaseMaterialInfo;
+      newVal: any;
+      oldVal: any;
+      runScene: RunScene;
+      constructor(data: {
+          target: E.BaseMaterial;
+          runScene: RunScene;
+          info: E.BaseMaterialInfo;
+          newVal: any;
+          oldVal: any;
+      });
+      execute(): this;
+      undo(): void;
+      redo(): void;
+  }
+  export default MaterialUndo;
+
+}
+declare module 'run-scene-v2/src/Undo/UndoMultiLevel' {
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  class MultiLeverUndo extends UndoBase {
+      type: string;
+      execute(): this;
+      _execute(data: any): void;
+      target: any;
+      typeList: string[];
+      old: any;
+      new: any;
+      cb: ((info: any) => void) | undefined;
+      constructor(data: {
+          target: any;
+          typeList: string[];
+          newVal: any;
+          cb?: (info: any) => void;
+      });
+      undo(): void;
+      redo(): void;
+  }
+  export default MultiLeverUndo;
+
+}
+declare module 'run-scene-v2/src/Undo/UndoNormal' {
+  import { Obj } from "js-funcs/dts/def";
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  export type NormalUndoCbData = {
+      target: E.unknowModel;
+      info: any;
+      val: any;
+  };
+  class NormalUndo extends UndoBase {
+      type: string;
+      target: Obj;
+      info: any;
+      oldVal: any;
+      newVal: any;
+      runScene: RunScene;
+      cb: (_model: E.unknowModel) => void;
+      executeCb: ((data: {
+          target: E.unknowModel;
+          info: any;
+          val: any;
+      }) => void) | undefined;
+      constructor(data: {
+          target: E.Model;
+          info: any;
+          oldVal: any;
+          newVal: any;
+          runScene: RunScene;
+          cb?: (model: E.unknowModel) => void;
+          executeCb?: (data: {
+              target: E.unknowModel;
+              info: any;
+              val: any;
+          }) => void;
+      });
+      _execute(data: any): void;
+      execute(): this;
+      undo(): void;
+      redo(): void;
+  }
+  export default NormalUndo;
+
+}
+declare module 'run-scene-v2/src/Undo/UndoParent' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  export interface ChangeParentDataType {
+      oldParent: any;
+      newParent: any;
+      target: any;
+      runScene: RunScene;
+  }
+  class ParentUndo extends UndoBase {
+      type: string;
+      execute(): this;
+      oldParent: any;
+      newParent: any;
+      target: any;
+      runScene: RunScene;
+      constructor(data: ChangeParentDataType);
+      _execute(newParent: E.Model): void;
+      undo(): void;
+      redo(): void;
+  }
+  export default ParentUndo;
+
+}
+declare module 'run-scene-v2/src/Undo/UndoRemove' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoAddAndRemove from "run-scene-v2/src/Undo/UndoAddAndRemove";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  export default class UndoRemove extends UndoAddAndRemove implements UndoBase {
+      type: string;
+      constructor(map: {
+          model: E.Model;
+          runScene: RunScene;
+          parent: E.Model;
+          cb?: (model: E.unknowModel, type: 'remove' | 'add') => void;
+          addTree?: boolean;
+      });
+      undo(): void;
+      redo(): void;
+      _execute(_data: any): Promise<never>;
+      execute(): this;
+  }
+
+}
+declare module 'run-scene-v2/src/Undo/UndoV3' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { EngineModelV3Names } from "run-scene-v2/src/ModelEx/ModelEx";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UndoBase from "run-scene-v2/src/Undo/UndoBase";
+  class UndoV3 extends UndoBase {
+      _execute(data: any): void;
+      type: string;
+      target: E.Model;
+      info: EngineModelV3Names;
+      newV3: any;
+      oldV3: any;
+      runScene: RunScene;
+      constructor(data: {
+          target: E.Model;
+          runScene: RunScene;
+          info: EngineModelV3Names;
+          newV3: E.V3;
+          oldV3: E.V3;
+      });
+      execute(execute?: boolean): this;
+      undo(): void;
+      redo(): void;
+  }
+  export default UndoV3;
+
+}
+declare module 'run-scene-v2/src/Unique/Unique' {
+  import RunScene from "run-scene-v2/src/RunScene";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UniqueMaterial from "run-scene-v2/src/Unique/UniqueMaterial";
+  import UniqueModel from "run-scene-v2/src/Unique/UniqueModel";
+  import UniqueTexture from "run-scene-v2/src/Unique/UniqueTexture";
+  export default class Unique {
+      model: UniqueModel;
+      material: UniqueMaterial;
+      texture: UniqueTexture;
+      runScene: RunScene;
+      constructor(runScene: RunScene);
+      getId(node: E.unknowModel): string;
+      dispose(): void;
+  }
+  export const getUniqueId: (t: any) => any;
+
+}
+declare module 'run-scene-v2/src/Unique/UniqueBase' {
+  import Unique from "run-scene-v2/src/Unique/Unique";
+  export default class UniqueBase {
+      map: {
+          [id: string]: any;
+      };
+      unique: Unique;
+      constructor(unique: Unique);
+      add(data: any): any;
+      get(id: string): any;
+      remove(data: any | any[]): any;
+  }
+
+}
+declare module 'run-scene-v2/src/Unique/UniqueMaterial' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import Unique from "run-scene-v2/src/Unique/Unique";
+  export default class UniqueMaterial {
+      unique: Unique;
+      constructor(unique: Unique);
+      map: {
+          [id: string]: {
+              material: E.Material;
+              models: Set<E.unknowModel>;
+          };
+      };
+      private removes;
+      add(mate: E.Material, useModel?: E.unknowModel, oldMaterial?: E.BaseMaterial): void;
+      addModel(model: E.unknowModel, material?: E.BaseMaterial, oldMaterial?: E.BaseMaterial): void;
+      get(id: string): E.Material;
+      remove(id: string): void;
+      addRemoved(material: any): void;
+      dispose(): void;
+  }
+  export const getMaterialId: (m: E.Material) => any;
+
+}
+declare module 'run-scene-v2/src/Unique/UniqueModel' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import UniqueBase from "run-scene-v2/src/Unique/UniqueBase";
+  export default class UniqueModel extends UniqueBase {
+      nameMap: {
+          [name: string]: string;
+      };
+      add(model: E.unknowModel | E.unknowModel[], options?: {
+          reset?: boolean;
+          hasReset?: boolean;
+      }): any;
+      get(id: string): E.unknowModel;
+      getModelsWithIds(ids: string[]): any[];
+      getByName(name: string): E.unknowModel | undefined;
+      getIdByNames(names: string[]): E.unknowModel;
+      remove(model: E.Model | E.Model[]): any;
+      dispose(): void;
+      findModelWithName(name: string): any[];
+      parseName: (model: any) => any;
+  }
+
+}
+declare module 'run-scene-v2/src/Unique/UniqueTexture' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import Unique from "run-scene-v2/src/Unique/Unique";
+  export default class UniqueTexture {
+      map: {
+          [id: string]: {
+              texture: E.Texture;
+              materialMap: {
+                  [materialID: string]: Set<E.BaseMaterialTexture>;
+              };
+          };
+      };
+      unique: Unique;
+      constructor(unique: Unique);
+      add(data: E.Texture): any;
+      getLength(): number;
+      addMaterial(texture: E.Texture, materialMap?: {
+          material: any;
+          type: E.BaseMaterialTexture;
+      }, oldMaterialMap?: {
+          material: any;
+          type: E.BaseMaterialTexture;
+      }): void;
+      get(id: string): import("three").Texture;
+      getMaterials(id: string): {
+          [materialID: string]: Set<E.BaseMaterialTexture>;
+      };
+      remove(data: any | any[]): any;
+      dispose(): void;
+  }
+
+}
+declare module 'run-scene-v2/src/Utils/Utils' {
+  export * from "run-scene-v2/src/Utils/UtilsImage";
+  export * from "run-scene-v2/src/Utils/UtilsJs";
+  export * from "run-scene-v2/src/Utils/UtilsThree";
+
+}
+declare module 'run-scene-v2/src/Utils/UtilsImage' {
+  import { E } from "run-scene-v2/src/Types/Engine";
+  import Three from "run-scene-v2/src/Libs/Three";
+  export const imgBitMapToBase64: (img: ImageBitmap) => string;
+  export const imgBitMapToBlob: (img: ImageBitmap) => Promise<Blob>;
+  export const reverseImg: (img: ImageBitmap) => void;
+  export const imgBitMapToBlobAndBase64: (texture: E.Texture) => Promise<{
+      blob: Blob;
+      base64: string;
+  }>;
+  export const imgArrayBufferToBlobUrl: (ar: ArrayBuffer, type: BlobPropertyBag) => string;
+  export const compressImgToUrl: (bitMap: ImageBitmap, quality: number) => Promise<unknown>;
+  export const getImgPixels1: (map: {
+      url: string;
+      bitmap: ImageBitmap;
+      texture: E.Texture;
+  }) => Promise<Three.Texture>;
+  export const getImgPixels: (map: {
+      url: string;
+      bitmap: ImageBitmap;
+  }) => void;
+  export const bitMapToCanvas: (bitMap: ImageBitmap) => {
+      ctx: CanvasRenderingContext2D;
+      canvas: HTMLCanvasElement;
+  };
+  export const rgbToHsl: (r: number, g: number, b: number) => number[];
+  export const hslToRgb: (h: number, s: number, l: number) => number[];
+  export const getImg: (url: string) => Promise<HTMLImageElement>;
+  export const getResultFromCanvas: (canvas: HTMLCanvasElement, type: "blob" | "base64", options?: {
+      base64Type: "png" | "jpeg" | "webp";
+  }) => any;
+  export const reverseImageBitMap: (img: ImageBitmap) => Promise<{
+      imageBitMap: ImageBitmap;
+      canvas: HTMLCanvasElement;
+  }>;
+  export const disposeCanvas: (canvas: HTMLCanvasElement) => void;
+  export const disposeImageBitMap: (bitMap: ImageBitmap) => void;
+  export const getEmptyImageData: (map: {
+      width: number;
+      height: number;
+  }) => HTMLCanvasElement;
+
+}
+declare module 'run-scene-v2/src/Utils/UtilsJs' {
+  /// <reference types="node" />
+  import { ResponseType } from "axios";
+  import { TweenMax } from "run-scene-v2/libs/Anima/index";
+  export const anima: (begin: any, end: any, time: number, onUpdate?: any, onComplete?: any) => TweenMax;
+  export const base64ToArrayBuffer: (base64: string) => Promise<ArrayBufferLike>;
+  export const getTruthBase64: (base64: string) => string;
+  export const arrayBufferToBlobUr: (ar: ArrayBuffer) => string;
+  export const arrayBufferToBase64: (ar: ArrayBuffer) => string;
+  export const urlToBlob: (url: string) => Promise<Blob>;
+  export const base64ToBlob: (base64: string) => Blob;
+  export const fileToBlob: (file: File) => Promise<Blob>;
+  export const blobToFile: (blob: Blob, fileName: string) => File;
+  export const getTypeByBase64: (base64: string) => string;
+  export const transByte: (byte: number) => string;
+  export const getMd5: (data: ArrayBuffer | string) => string;
+  export const fileAndBlobToCanvas: (fileDataURL: string, size: {
+      width: number;
+      height: number;
+  }) => Promise<{
+      canvas: HTMLCanvasElement;
+      ctx: CanvasRenderingContext2D;
+  }>;
+  export const getFilesByDataTransfer: (data: DataTransfer) => File[];
+  export const canvasToBlob: (canvas: HTMLCanvasElement) => Promise<Blob>;
+  export const getRes: (url: string, type?: ResponseType) => Promise<any>;
+  export const mergeObject: <T>(base: T, cover: T) => T;
+  export const getMacro: (macroTaskFn: Function, time?: number) => void;
+  export const clone: (obj: any) => any;
+  export const getNamesByNum: (baseName: string, length: any, beginNum: number, endName: string) => any;
+  export const getType: (input: File | Blob) => string;
+  export const deepMergeObject: (base: any, other: any) => any;
+  export const getArrIndexByItem: <T>(arr: T[], item: T) => T;
+  export const getProgress: (num1: number, num2: number, percentage?: boolean) => number;
+  export const urlToCanvas: (url: string) => Promise<{
+      img: HTMLImageElement;
+      canvas: HTMLCanvasElement;
+      ctx: CanvasRenderingContext2D;
+  }>;
+  export const bufferToArrayBuffer: (buf: Buffer) => ArrayBuffer;
+  export const isEmpty: (val: any) => boolean;
+  export const isBlob: (blob: any) => boolean;
+  export const getTime: (day: number) => number;
+  export const toCode: (str: string) => string;
+  export const fromCode: (str: string) => any;
+  export const getFilesFromFileList: (f: FileList) => File[];
+  export type FilterFileType = "image" | "any";
+  export const filterFiles: (f: File[], type: FilterFileType) => File[];
+  export const toTimeString: (time: Date) => string;
+  export const rmPartOfString: (base: string, rmPart: string) => string;
+  export const rmArrEle: (ls: any[], item: any) => number;
+  export const addElesFromIndexToArr: (ls: any[], item: any | any[], index: number) => any[];
+  export const sameArr: (ar1: any[], ar2: any[], rules: "fill" | number) => boolean;
+
+}
+declare module 'run-scene-v2/src/Utils/UtilsThree' {
+  import { BufferGeometry, CatmullRomCurve3, Line, LineBasicMaterial, Texture, Vector2, Vector3, VideoTexture } from "three";
+  import { Line2 } from "three/examples/jsm/lines/Line2.js";
+  import { CSS2DObject } from "three/examples/jsm/renderers/CSS2DRenderer";
+  import { CSS3DObject, CSS3DSprite } from "three/examples/jsm/renderers/CSS3DRenderer";
+  import { E } from "run-scene-v2/src/Types/Engine";
+  export const getWorldLocal: (obj: E.Model, scene: E.Scene) => Vector3;
+  export const vector: {
+      parse(v: any): Vector3 | Vector2;
+      toJSON(v: Vector2 | Vector3): {
+          x: any;
+          y: any;
+          z?: undefined;
+      } | {
+          x: any;
+          y: any;
+          z: any;
+      };
+  };
+  export const getDistance: (position1: Vector3, position2: Vector3) => number;
+  export const domTo3Dui: (dom: HTMLElement) => CSS3DObject;
+  export const domTo2Dui: (dom: HTMLElement) => CSS2DObject;
+  export const domTo3DSprite: (dom: HTMLElement) => CSS3DSprite;
+  export const changeModelOpc: (model: any, opc?: number, toOld?: boolean) => void;
+  export const changeModelOpcs: (model: any, opc: number, toOld: boolean) => void;
+  export const textureToThreeD: (texture: Texture) => Texture;
+  export const removeUnLess: (model: any) => any;
+  export const getVideoTexture: (src: string, dom: HTMLElement) => VideoTexture;
+  export const getCurve: (positions: Vector3[], showLine?: boolean) => {
+      line: Line<BufferGeometry, LineBasicMaterial>;
+      curve: CatmullRomCurve3;
+  };
+  export const arrayToVector3: (data: number[]) => Vector3[];
+  export const getLine2: (map: {
+      pointArray: number[];
+      material?: any;
+      lineWidth?: number;
+      colorArray?: number[];
+  }) => Line2;
+  export const angleToNum: (val: number) => number;
+  export const getModelMap: (model: E.unknowModel, flag?: "name" | "id", eachFn?: (model: E.unknowModel) => void) => {
+      [name: string]: any;
+  };
+  /**
+   * 作用：
+   * @param {*} now true 的话 返回当前的相机的位置和控制器的target，是个对象
+   * @param {*} 2-4是相机的位置
+   * @param {*} 5-7是control 的camera
+   * @returns 相机动画需要的数据
+   */
+  export const getCamAnimaData: (cx: number, cy: number, cz: number, tx: number, ty: number, tz: number) => {
+      cx: number;
+      cy: number;
+      cz: number;
+      tx: number;
+      ty: number;
+      tz: number;
+  };
+
+}
+declare module 'run-scene-v2' {
+  import main = require('run-scene-v2/index');
+  export = main;
+}