@realsee/five 6.8.0-alpha.2 → 6.8.0-alpha.21

package/five/work/work.d.ts

@@ -0,0 +1,236 @@
+import * as THREE from "three";
+import type { Mode } from "../application/mode";
+import type { TilesetHeader } from "../model/tile3d/header";
+import type { LooseWork, LoosePanoWork } from "./looseWorkType";
+import { CubeFace } from "../types/cube";
+import type { PanoId } from "../utils/pano";
+/** 全景视频贴片 */
+export interface WorkVideo {
+    work: Work;
+    /** 视频源 url */
+    source: string;
+    /** 视频源变化矩阵 */
+    matrix: THREE.Matrix4;
+    /** 视频源长宽尺寸 */
+    size: THREE.Vector2;
+}
+export interface WorkCubeImage extends Record<CubeFace, string> {
+    work: Work;
+}
+export interface WorkTile extends WorkCubeImage {
+    /** 层级 */
+    level: number;
+    /** 尺寸 */
+    size: number;
+    /** 缩放比例 */
+    scale: number;
+}
+/** 全景图 */
+export interface WorkImage extends WorkCubeImage {
+    /** 分辨率表 */
+    sizeList: readonly number[];
+    /** 瓦片信息 */
+    tiles: readonly WorkTile[];
+    /** 点位视频 */
+    video?: WorkVideo;
+}
+/** 初始化位姿参数 */
+export interface WorkInitial {
+    work: Work;
+    /** 模态 */
+    mode?: Mode;
+    /** 点位序号 */
+    panoIndex?: number;
+    /** 相机水平角 */
+    longitude?: number;
+    /** 相机俯仰角 */
+    latitude?: number;
+    /** 相机可视角度（垂直）*/
+    fov?: number;
+    /** 相机观察点位置 [x, y, z] */
+    offset?: THREE.Vector3;
+    /** 相机距离观察点距离 */
+    distance?: number;
+}
+/** 每个点位的数据 */
+export interface WorkObserver {
+    /** work */
+    work: Work;
+    /** 序号 */
+    index: number;
+    /** 序号 */
+    panoIndex: number;
+    /**
+     * 序号
+     * @example
+     * `${workCode}[${panoIndex}]`
+     */
+    panoId: PanoId;
+    /** 点位所在楼层 */
+    floorIndex: number;
+    /** 点位 derived_id */
+    derivedId: number;
+    /** 点位 derived_id_str */
+    derivedIdStr: string;
+    /** 点位是否激活可用 */
+    active: boolean;
+    /** 点位是否可加载 */
+    loadable: boolean;
+    /** 点位全景图 */
+    images: WorkImage;
+    /**
+     * @deprecated
+     * 可以看到的相关点位序号
+     * 数据和 accessibleNodes 一致，使用 accessibleNodes
+     */
+    visibleNodes: readonly number[];
+    /** 可以连通的相关点位序号 */
+    accessibleNodes: readonly number[];
+    /** 点位和模型的地面坐标 */
+    standingPosition: THREE.Vector3;
+    /** 点位和模型的观察点坐标 */
+    position: THREE.Vector3;
+    /** 点位和模型的旋转对齐关系四元数 */
+    quaternion: THREE.Quaternion;
+    /** 点位和模型的旋转对齐关系矩阵 */
+    matrix: THREE.Matrix4;
+    /**
+     * 将方向向量转化为全景图 uv。
+     * @param vector - 全局的方向向量。单位向量。
+     * @param uvOrigin - top-left 原点在左上角，x轴向右，y轴向下[默认]。bottom-left 原点左下角，x轴向右，y轴向上。
+     * @returns uv坐标 取值范围 [0,1]。
+     */
+    vectorToEquirectangularUv(this: WorkObserver, vector: THREE.Vector3, uvOrigin?: 'top-left' | 'bottom-left'): THREE.Vector2;
+    /**
+     * 将全景图 uv 转化为方向向量。
+     * @param uv - uv坐标 取值范围 [0,1]。
+     * @param uvOrigin - top-left 原点在左上角，x轴向右，y轴向下[默认]。bottom-left 原点左下角，x轴向右，y轴向上。
+     * @returns 全局的方向向量。单位向量。
+     */
+    equirectangularUvToVector(this: WorkObserver, uv: THREE.Vector2, uvOrigin?: 'top-left' | 'bottom-left'): THREE.Vector3;
+    /**
+     * 将方向向量转化为获六视图 uv
+     * @param vector - 全局的方向向量。单位向量。
+     * @param uvOrigin - top-left 原点在左上角，x轴向右，y轴向下[默认]。bottom-left 原点左下角，x轴向右，y轴向上。
+     * @returns uv 坐标，取值范围 [0,1]
+     */
+    vectorToCubemapUv(this: WorkObserver, vector: THREE.Vector3, uvOrigin?: 'top-left' | 'bottom-left'): [cubeFace: CubeFace, cubemapUv: THREE.Vector2];
+    /**
+     * 将六视图 uv 转化为方向向量
+     * @param cubeFace - 六视图的某一面。
+     * @param uv - uv坐标 取值范围 [0,1]。
+     * @param uvOrigin - top-left 原点在左上角，x轴向右，y轴向下[默认]。bottom-left 原点左下角，x轴向右，y轴向上。
+     * @returns 全局的方向向量。单位向量。
+     */
+    cubemapUvToVector(this: WorkObserver, cubeFace: CubeFace, uv: THREE.Vector2, uvOrigin?: 'top-left' | 'bottom-left'): THREE.Vector3;
+    /** 获取点位的全局坐标 */
+    getWorldPosition(this: WorkObserver): THREE.Vector3;
+    /** 获取点位的全局地面坐标 */
+    getWorldStandingPosition(this: WorkObserver): THREE.Vector3;
+}
+export interface WorkModelLayer {
+    /** work */
+    work: Work;
+    /** 模型类型 point_cloud | mesh | gaussian_splatting */
+    type: 'point_cloud' | 'mesh' | 'gaussian_splatting';
+    /** 模型名称 */
+    name: string;
+    /** 指定上方向 */
+    upAxis: string;
+    /** 如果 tileset.json 地址 */
+    tileset: string;
+}
+/** 模型数据 */
+export interface WorkModel {
+    /** work */
+    work: Work;
+    /** 模型文件地址 at3d / domez */
+    file?: string;
+    /** 模型贴图文件地址 */
+    textures?: readonly string[];
+    /** 模型贴图文件地址的父目录 */
+    textureBase?: string;
+    /** 指定上方向，对于 obj， ply 等定义不明确的需要指定上方向 */
+    upAxis?: string;
+    /** 模型的地理坐标数据 */
+    coordinate?: NonNullable<TilesetHeader['rootMeta']>['coordinate'];
+    /** 3d tile */
+    layers: readonly WorkModelLayer[];
+}
+export interface Work {
+    /** 数据签发人 */
+    issuer: string;
+    /** 编号 */
+    workCode: string;
+    /** 内部项目 id */
+    projectId?: string;
+    /** 允许访问的安全域名 */
+    allowHosts: readonly string[];
+    /** 过期时间 */
+    expire: Date;
+    /** 名称 */
+    name: string;
+    /** 根地址 */
+    baseURL: string;
+    /** 初始化参数 */
+    initial: WorkInitial;
+    /** 相对位姿 */
+    transform: THREE.Matrix4;
+    /** 模型参数 */
+    model?: WorkModel;
+    /** 全景点位信息 */
+    observers: readonly WorkObserver[];
+}
+export declare class Work {
+    jsonp: boolean;
+    shortPath: boolean;
+    observerBox: THREE.Box3;
+    /**
+     * 控制参数
+     * @deprecated 通过 work.transform 替换
+     */
+    options: {
+        /**
+         * 位姿修正
+        * @deprecated 通过 work.transform 替换
+         */
+        transform: THREE.Matrix4;
+    };
+    /**
+     * 原始数据
+     * @deprecated 通过 work.toJSON 替换
+     */
+    raw: {
+        works: string[];
+    };
+    /**
+     * 解析 Work 数据
+     * @param obj - work 数据，从如数开发者平台获取
+     * @param options - 配置参数， 可以在此二次设置 baseURL 等参数
+     * @returns - 签署过的 Work 数据结构
+     */
+    static parse: typeof parseWork;
+    constructor(obj: Work | LoosePanoWork | LooseWork | (Work | LooseWork)[] | any, options: ParseOptions);
+    getURL(source: string): string;
+    verifyURL(source: string): boolean;
+    toJSON(): any;
+}
+export type ParseOptions = {
+    /** 位姿 */
+    transform?: THREE.Matrix4 | number[];
+    /** 重置 WorkCode */
+    workCode?: string | ((input: any) => string);
+    /** 重写资源前缀 */
+    baseURL?: string;
+    /** 资源地址使用短地址 */
+    shortPath?: boolean;
+    /** 资源使用 jsonp 方式发布 */
+    jsonp?: boolean;
+};
+/**
+ * 解析 Work 数据
+ * @param obj - work 数据，从如数开发者平台获取
+ * @param options - 配置参数， 可以在此二次设置 baseURL 等参数
+ * @returns - 签署过的 Work 数据结构
+ */
+export declare function parseWork(obj: Work | LoosePanoWork | LooseWork | string | any, options?: ParseOptions): Work;

package/five/work/workFetcher.d.ts

@@ -0,0 +1,4 @@
+import type { Work } from './work';
+import type { Fetcher } from '../utils/ajax';
+export declare function getFetcher(fiveId: string, work: Work): Fetcher;
+export declare function registerFetcher(fiveId: string, work: Work, fetcher: Fetcher): void;

package/five/work/workJson.d.ts

@@ -0,0 +1,3 @@
+import type { Work } from './work';
+import type { WorkJson } from './workJsonType';
+export declare function workToJson(work: Work): WorkJson;

package/five/work/workJsonType.d.ts

@@ -0,0 +1,73 @@
+export interface WorkJson {
+    allow_hosts: string[];
+    expire_at: string;
+    code: string;
+    name?: string;
+    project_id?: string;
+    base_url: string;
+    initial?: WorkInitialJson;
+    model?: WorkModelJson;
+    observers?: WorkObserverJson[];
+    panorama?: WorkPanoramasJson;
+}
+export interface WorkInitialJson {
+    mode?: string;
+    pano_index?: number;
+    longitude?: number;
+    latitude?: number;
+    fov?: number;
+    offset?: number[];
+    distance?: number;
+}
+export interface WorkModelJson {
+    file_url?: string;
+    material_textures?: string[];
+    material_base_url?: string;
+    up_axis?: string;
+    layers?: WorkModelLayerJson[];
+}
+export interface WorkModelLayerJson {
+    name?: string;
+    type?: string;
+    up_axis: string;
+    tileset_url: string;
+}
+export interface WorkObserverJson {
+    index: number;
+    floor_index: number;
+    derived_id: number;
+    derived_id_str: string;
+    position: number[];
+    standing_position: number[];
+    quaternion: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    visible_nodes: number[];
+    accessible_nodes: number[];
+}
+export interface WorkPanoramasJson {
+    count: number;
+    list: WorkPanoramaJson[];
+}
+export interface WorkPanoramaJson {
+    index: number;
+    active?: boolean;
+    loadable?: boolean;
+    derived_id?: number;
+    derived_id_str?: string;
+    size_list: number[];
+    up: string;
+    down: string;
+    right: string;
+    left: string;
+    front: string;
+    back: string;
+    video?: {
+        source: string;
+        matrix: number[];
+        size: number[];
+    };
+}

package/five/work/workObserverUtils.d.ts

@@ -0,0 +1,36 @@
+import * as THREE from 'three';
+import { type WorkObserver } from './work';
+import { type CubeFace } from '../types/cube';
+/**
+ * 将方向向量转化为全景图 uv。
+ * @param vector - 全局的方向向量。单位向量。
+ * @param uvOrigin - top-left 原点在左上角，x轴向右，y轴向下[默认]。bottom-left 原点左下角，x轴向右，y轴向上。
+ * @returns uv坐标 取值范围 [0,1]。
+ */
+export declare function vectorToEquirectangularUv(this: WorkObserver, vector: THREE.Vector3, uvOrigin?: 'top-left' | 'bottom-left'): THREE.Vector2;
+/**
+ * 将全景图 uv 转化为方向向量。
+ * @param uv - uv坐标 取值范围 [0,1]。
+ * @param uvOrigin - top-left 原点在左上角，x轴向右，y轴向下[默认]。bottom-left 原点左下角，x轴向右，y轴向上。
+ * @returns 全局的方向向量。单位向量。
+ */
+export declare function equirectangularUvToVector(this: WorkObserver, uv: THREE.Vector2, uvOrigin?: 'top-left' | 'bottom-left'): THREE.Vector3;
+/**
+ * 将方向向量转化为获六视图 uv
+ * @param vector - 全局的方向向量。单位向量。
+ * @param uvOrigin - top-left 原点在左上角，x轴向右，y轴向下[默认]。bottom-left 原点左下角，x轴向右，y轴向上。
+ * @returns uv 坐标，取值范围 [0,1]
+ */
+export declare function vectorToCubemapUv(this: WorkObserver, vector: THREE.Vector3, uvOrigin?: 'top-left' | 'bottom-left'): [cubeFace: CubeFace, cubemapUv: THREE.Vector2];
+/**
+ * 将六视图 uv 转化为方向向量
+ * @param cubeFace - 六视图的某一面。
+ * @param uv - uv坐标 取值范围 [0,1]。
+ * @param uvOrigin - top-left 原点在左上角，x轴向右，y轴向下[默认]。bottom-left 原点左下角，x轴向右，y轴向上。
+ * @returns 全局的方向向量。单位向量。
+ */
+export declare function cubemapUvToVector(this: WorkObserver, cubeFace: CubeFace, uv: THREE.Vector2, uvOrigin?: 'top-left' | 'bottom-left'): THREE.Vector3;
+/** 获取点位的全局坐标 */
+export declare function getWorldPosition(this: WorkObserver): THREE.Vector3;
+/** 获取点位的全局地面坐标 */
+export declare function getWorldStandingPosition(this: WorkObserver): THREE.Vector3;

package/five/work/workParser.d.ts

@@ -0,0 +1,6 @@
+import type { Work } from "./work";
+import type { LooseWork, LoosePanoWork } from "./looseWorkType";
+import type { WorkJson } from "./workJsonType";
+export declare function parse(inputs: Work | LooseWork | WorkJson | (Work | LooseWork | WorkJson)[] | any, work: Work): Work | Error;
+export declare function parseNull(input: null, work: Work): Work | Error;
+export declare function parsePano(input: LoosePanoWork, work: Work): Work | Error;

package/five/work/workResolvedObserver.d.ts

@@ -0,0 +1,12 @@
+import { Pano, PanoId } from '../utils/pano';
+import type { WorkObserver } from './work';
+export interface WorkResolvedObserver extends WorkObserver {
+    isResolved: true;
+    panoId: PanoId;
+    pano: Pano;
+    accessibleIds: readonly PanoId[];
+    visibleIds: readonly PanoId[];
+}
+export declare class WorkResolvedObserver {
+    constructor(observer: WorkObserver);
+}

package/five/work/workVerify.d.ts

@@ -0,0 +1,2 @@
+import type { Work } from './work';
+export declare const workVerifySet: WeakSet<Work>;

package/five/work/works.d.ts

@@ -0,0 +1,10 @@
+import { Work, WorkInitial, WorkObserver } from "./work";
+import { WorkResolvedObserver } from "./workResolvedObserver";
+import { Pano, PanoId } from '../utils/pano';
+export type Works = ReadonlyArray<Work> & {
+    initial: WorkInitial;
+    getWork(workCode: string): Work | undefined;
+    getObserver(pano: PanoId | Pano | number): WorkObserver | undefined;
+    getResolvedObserver(pano: PanoId | Pano | number): WorkResolvedObserver | undefined;
+};
+export declare function createWorks(workArray: Work[]): Works;

package/gltf-loader/gltf-object.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from "three";
+/**
+ * GLTF 对象
+ */
+declare class GLTFObject extends THREE.Group {
+    needsRender: boolean;
+    /**
+     * mixer 为对应当前对象的动画混合器
+     * @description
+     * 通过 `gltf.animations` 可以获取动画帧。
+     * 通过 `gltf.scene.mixer.clipAction(gltf.animations[0]).play()` 即可播放动画。
+     */
+    mixer: THREE.AnimationMixer;
+    constructor(rootObject?: THREE.Object3D);
+    clone(): this;
+}
+export { GLTFObject };

package/gltf-loader/index.d.ts

@@ -1,160 +1,60 @@
-import { AnimationClip } from 'three';
-import { BufferGeometry } from 'three';
-import { Camera } from 'three';
-import { CompressedPixelFormat } from 'three';
-import { CompressedTextureLoader } from 'three';
-import { Group } from 'three';
-import { Loader } from 'three';
-import { LoadingManager } from 'three';
-import { Material } from 'three';
-import { Object3D } from 'three';
-import { PixelFormat } from 'three';
-import { Texture } from 'three';
-import * as THREE_2 from 'three';
-
-export declare interface DDS {
-    	mipmaps: object[];
-    	width: number;
-    	height: number;
-    	format: PixelFormat | CompressedPixelFormat;
-    	mipmapCount: number;
-    	isCubemap: boolean;
-}
-
-export declare class DDSLoader extends CompressedTextureLoader {
-
-    	constructor( manager?: LoadingManager );
-
-    	parse( buffer: ArrayBuffer, loadMipmaps: boolean ) : DDS;
-
-}
-
-export declare class DRACOLoader extends Loader {
-
-    	constructor( manager?: LoadingManager );
-
-    	load( url: string, onLoad: ( geometry: BufferGeometry ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
-    	setDecoderPath( path: string ): DRACOLoader;
-    	setDecoderConfig( config: object ): DRACOLoader;
-    	setWorkerLimit( workerLimit: number ): DRACOLoader;
-    	preload(): DRACOLoader;
-    	dispose(): DRACOLoader;
-
-}
-
-/**
- * GLTFLoader 返回数据
- * @description
- * 一般情况下，gltf.scene 为模型对象，直接通过 `five.scene.add(gltf.scene)` 即可添加到场景
- * Five 的模型单位 1 为 1米，载入的模型单位标准不一，请自行 scale。
- * 如果涉及模型内置动画，GLTF 已经帮你封装了，通过 `gltf.animations` 可以获取动画帧。gltf.scene.mixer 为对应的 动画混合器。
- * 通过 `gltf.scene.mixer.clipAction(gltf.animations[0]).play()` 即可播放动画。
- */
-export declare interface GLTF {
-    animations: THREE_2.AnimationClip[];
-    scene: GLTFObject;
-    scenes: GLTFObject[];
-    cameras: THREE_2.Camera[];
-    asset: {
-        copyright?: string;
-        generator?: string;
-        version?: string;
-        minVersion?: string;
-        extensions?: any;
-        extras?: any;
-    };
-    parser: GLTFParser;
-    userData: any;
-}
-
-/**
- * GLTF 模型加载器
- */
-export declare class GLTFLoader extends THREEGLTFLoader {
-    static get version(): string;
-    /**
-     * GLTF 模型加载器
-     *
-     * @example
-     * ```
-     * const gltfLoader = new GLTFLoader();
-     * gltfLoader.load("https://vr-public.realsee-cdn.cn/release/static/image/release/five/demo/gltf/plants/scene.gltf", ({ scene }) => {
-     *   five.scene.add(scene);
-     * });
-     * ```
-     */
-    constructor(manager?: THREE_2.LoadingManager);
-    /**
-     * 加载模型
-     * @param url - 模型 URL
-     * @param onLoad - 加载完成回调
-     * @param onProgress - 加载进度回调
-     * @param onError - 加载错误回调
-     */
-    load(url: string, onLoad: (gltf: GLTF) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-    parse(data: ArrayBuffer | string, path: string, onLoad: (gltf: GLTF) => void, onError?: (event: ErrorEvent) => void): void;
-}
-
-/**
- * GLTF 对象
- */
-export declare class GLTFObject extends THREE_2.Group {
-    needsRender: boolean;
-    /**
-     * mixer 为对应当前对象的动画混合器
-     * @description
-     * 通过 `gltf.animations` 可以获取动画帧。
-     * 通过 `gltf.scene.mixer.clipAction(gltf.animations[0]).play()` 即可播放动画。
-     */
-    mixer: THREE_2.AnimationMixer;
-    constructor(rootObject?: THREE_2.Object3D);
-    clone(): this;
-}
-
-export declare class GLTFParser {
-
-    	json: any;
-
-    	associations: Map<Object3D|Material|Texture, GLTFReference>;
-
-    	getDependency: ( type: string, index: number ) => Promise<any>;
-    	getDependencies: ( type: string ) => Promise<any[]>;
-
-}
-
-export declare interface GLTFReference {
-    	type: 'materials'|'nodes'|'textures';
-    	index: number;
-}
-
-export declare interface THREEGLTF {
-    	animations: AnimationClip[];
-    	scene: Group;
-    	scenes: Group[];
-    	cameras: Camera[];
-    	asset: {
-        		copyright?: string;
-        		generator?: string;
-        		version?: string;
-        		minVersion?: string;
-        		extensions?: any;
-        		extras?: any;
-        	};
-    	parser: GLTFParser;
-    	userData: any;
-}
-
-export declare class THREEGLTFLoader extends Loader {
-
-    	constructor( manager?: LoadingManager );
-    	dracoLoader: DRACOLoader | null;
-    	ddsLoader: DDSLoader | null;
-
-    	load( url: string, onLoad: ( gltf: THREEGLTF ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
-    	setDRACOLoader( dracoLoader: DRACOLoader ): THREEGLTFLoader;
-    	setDDSLoader( ddsLoader: DDSLoader ): THREEGLTFLoader;
-    	parse( data: ArrayBuffer | string, path: string, onLoad: ( gltf: THREEGLTF ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
-
-}
-
-export { }
+import * as THREE from "three";
+import { GLTFLoader as THREEGLTFLoader } from "./thirdparty/GLTFLoader";
+import type { GLTF as THREEGLTF } from "./thirdparty/GLTFLoader";
+import type { GLTFParser, GLTFReference } from "./thirdparty/GLTFLoader";
+import { DRACOLoader } from './thirdparty/DRACOLoader';
+import { DDSLoader } from './thirdparty/DDSLoader';
+import type { DDS } from './thirdparty/DDSLoader';
+import { GLTFObject } from "./gltf-object";
+/**
+ * GLTFLoader 返回数据
+ * @description
+ * 一般情况下，gltf.scene 为模型对象，直接通过 `five.scene.add(gltf.scene)` 即可添加到场景
+ * Five 的模型单位 1 为 1米，载入的模型单位标准不一，请自行 scale。
+ * 如果涉及模型内置动画，GLTF 已经帮你封装了，通过 `gltf.animations` 可以获取动画帧。gltf.scene.mixer 为对应的 动画混合器。
+ * 通过 `gltf.scene.mixer.clipAction(gltf.animations[0]).play()` 即可播放动画。
+ */
+interface GLTF {
+    animations: THREE.AnimationClip[];
+    scene: GLTFObject;
+    scenes: GLTFObject[];
+    cameras: THREE.Camera[];
+    asset: {
+        copyright?: string;
+        generator?: string;
+        version?: string;
+        minVersion?: string;
+        extensions?: any;
+        extras?: any;
+    };
+    parser: GLTFParser;
+    userData: any;
+}
+/**
+ * GLTF 模型加载器
+ */
+declare class GLTFLoader extends THREEGLTFLoader {
+    static get version(): string;
+    /**
+     * GLTF 模型加载器
+     *
+     * @example
+     * ```
+     * const gltfLoader = new GLTFLoader();
+     * gltfLoader.load("https://vr-public.realsee-cdn.cn/release/static/image/release/five/demo/gltf/plants/scene.gltf", ({ scene }) => {
+     *   five.scene.add(scene);
+     * });
+     * ```
+     */
+    constructor(manager?: THREE.LoadingManager);
+    /**
+     * 加载模型
+     * @param url - 模型 URL
+     * @param onLoad - 加载完成回调
+     * @param onProgress - 加载进度回调
+     * @param onError - 加载错误回调
+     */
+    load(url: string, onLoad: (gltf: GLTF) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+    parse(data: ArrayBuffer | string, path: string, onLoad: (gltf: GLTF) => void, onError?: (event: ErrorEvent) => void): void;
+}
+export { GLTFObject, GLTFLoader, GLTFParser, GLTFReference, GLTF, DRACOLoader, DDSLoader, DDS, THREEGLTFLoader, THREEGLTF };