@realsee/five 6.8.0-alpha.1 → 6.8.0-alpha.10

package/five/application/fiveLoadOptions.d.ts

@@ -0,0 +1,21 @@
+import type { ModelOptions } from "../model";
+import { MovePanoEffect } from '../types/movePanoEffect';
+export interface FiveLoadOptions {
+    /** 替换 / 追加 */
+    mode?: 'replace' | "add";
+    /** 切换运动时间 */
+    duration?: number;
+    /** 切换运动全景图效果 */
+    effect?: MovePanoEffect;
+    model?: ModelOptions;
+    /**
+     * @deprecated
+     * 请通过 model.textureOptions 设置
+     */
+    textureOptions?: ModelOptions['textureOptions'];
+    /**
+     * @deprecated
+     * 请通过 model.textureOptions 设置
+     */
+    "3d-tiles"?: ModelOptions['3d-tiles'];
+}

package/five/application/generateDefaultVideoElement.d.ts

@@ -0,0 +1,2 @@
+declare function generateDefaultVideoElement(): HTMLVideoElement;
+export { generateDefaultVideoElement };

package/five/application/getViewportScale.d.ts

@@ -0,0 +1,2 @@
+declare function getViewportScale(): number;
+export { getViewportScale };

package/five/application/initLights.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from "three";
+declare function initLights(): THREE.Object3D;
+export { initLights };

package/five/application/mode.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Five 的显示模式，可以通过 `five.changeMode` `five.setState` 来切换
+ * - **Panorama**: 全景图游走模式
+ * - **Model**: 模型游走模式
+ * - **Floorplan**: 模型查看模式
+ * - **Topview**: 户型图模式
+ * - **Mapview**: 地图模式
+ * - **VRPanorama**: VR眼镜模式
+ */
+type Mode = 
+/** 模型查看模式 */
+"Floorplan" | 
+/** 户型图模式 */
+"Topview" | 
+/** 地图模式 */
+"Mapview" | 
+/** 全景图游走模式 */
+"Panorama" | 
+/** VR眼镜模式 */
+"VRPanorama" | 
+/** 模型游走模式 */
+"Model" | 
+/** XR眼镜模式*/
+"XRPanorama";
+declare function isThirdPersonMode(mode: Mode): boolean;
+declare function isFristPersonMode(mode: Mode): boolean;
+export { isFristPersonMode, isThirdPersonMode };
+export type { Mode };

package/five/application/renderPoweredByRealsee.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from "three";
+declare function renderPoweredByRealsee(renderer: THREE.WebGLRenderer): void;
+export { renderPoweredByRealsee };

package/five/assets/cardboard-png-data-url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/five/assets/gradient-png-data-url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/five/assets/loading-png-data-url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/five/assets/phone-png-data-url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/five/assets/realsee-pmg-data-url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/five/bvh/bvhMath.d.ts

@@ -0,0 +1,33 @@
+export declare class BVHVector3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z: number);
+    copy(v: BVHVector3): this;
+    set(x: number, y: number, z: number): this;
+    fromArray(array: number[], firstElementPos?: number): this;
+    toArray(array?: number[], offset?: number): number[];
+    add(v: BVHVector3): this;
+    multiplyScalar(scalar: number): this;
+    subVectors(a: BVHVector3, b: BVHVector3): this;
+    addScaledVector(v: BVHVector3, s: number): this;
+    dot(v: BVHVector3): number;
+    cross(v: BVHVector3): this;
+    crossVectors(a: BVHVector3, b: BVHVector3): this;
+    distanceTo(v: BVHVector3): number;
+    distanceToSquared(v: BVHVector3): number;
+    clone(): BVHVector3;
+}
+export declare class BVHIntersect {
+    pointA: BVHVector3;
+    pointB: BVHVector3;
+    pointC: BVHVector3;
+    index: number;
+    intersectionPoint: BVHVector3;
+    constructor(pointA: BVHVector3, pointB: BVHVector3, pointC: BVHVector3, index: number, intersectionPoint: BVHVector3);
+}
+export declare class BVHBox3 {
+    min: BVHVector3;
+    max: BVHVector3;
+    constructor(min: BVHVector3, max: BVHVector3);
+}

package/five/bvh/bvhMesh.d.ts

@@ -0,0 +1,7 @@
+import { BVHObject } from './bvhObject';
+import { BVHVector3, BVHIntersect } from './bvhMath';
+export declare class BVHMesh extends BVHObject {
+    createTree(maxTrianglesPerNode: number, maxDepth: number, extents?: number[]): this;
+    trianglesInSphere(center: BVHVector3, radius: number): Float32Array;
+    intersectRay(rayOrigin: BVHVector3, rayDirection: BVHVector3, threshold?: number, onlyFirst?: boolean, filter?: (intersect: BVHIntersect) => boolean): BVHIntersect[];
+}

package/five/bvh/bvhNode.d.ts

@@ -0,0 +1,29 @@
+import type { BVHVector3, BVHBox3 } from "./bvhMath";
+/**
+ * A node in the BVH structure
+ * @param extents - the min coords of this node's bounding box
+ * @param startIndex - an index in the bbox array, where the first element of this node is located
+ * @param endIndex - an index in the bbox array, where the last of this node is located, plus 1 (meaning that its non-inclusive).
+ * @param level - distance of this node from the root for the bvh tree. root node has level=0, its children have level=1 etc.
+ */
+export declare class BVHNode {
+    id: number;
+    extents: number[];
+    startIndex: number;
+    endIndex: number;
+    deepth: number;
+    node0?: BVHNode;
+    node1?: BVHNode;
+    constructor(id: number, extents: number[], startIndex: number, endIndex: number, deepth: number);
+}
+export declare const BYTES_PER_NODE: number;
+export declare function packBVHNode(root: BVHNode, length: number): ArrayBuffer;
+export declare function containsNodeBox(point: BVHVector3, box: BVHBox3, threshold?: number): boolean;
+/**
+ * 计算射线和 BVHNode 的相交
+ * @param rayOrigin - 射线原点
+ * @param invRayDirection - 1 / 射线方向
+ * @param node - BVHNode
+ * @param threshold - 扩大
+ */
+export declare function intersectNodeBox(rayOrigin: BVHVector3, invRayDirection: BVHVector3, box: BVHBox3, threshold?: number): number | null;

package/five/bvh/bvhObject.d.ts

@@ -0,0 +1,18 @@
+import type { BVHVector3, BVHIntersect } from './bvhMath';
+export type BVHAttr = {
+    array: ArrayLike<number>;
+    stride?: number;
+    offset?: number;
+};
+export declare class BVHObject {
+    position: BVHAttr;
+    indices?: BVHAttr;
+    rootNodePacked?: ArrayBuffer;
+    offsetArray?: ArrayLike<number>;
+    constructor(position: BVHAttr, indices?: BVHAttr);
+    getPositionCount(): number;
+    getPositionByIndex(index: number, target: BVHVector3): BVHVector3;
+    createTree(maxTrianglesPerNode: number, maxDepth: number, extents?: number[]): this;
+    trianglesInSphere(center: BVHVector3, radius: number): Float32Array;
+    intersectRay(rayOrigin: BVHVector3, rayDirection: BVHVector3, threshold?: number, onlyFirst?: boolean, filter?: (intersect: BVHIntersect) => boolean): BVHIntersect[];
+}

package/five/bvh/bvhPoints.d.ts

@@ -0,0 +1,6 @@
+import { BVHObject } from './bvhObject';
+import { BVHVector3, BVHIntersect } from './bvhMath';
+export declare class BVHPoints extends BVHObject {
+    createTree(maxPointsPerNode: number, maxDepth: number, extents?: number[]): this;
+    intersectRay(rayOrigin: BVHVector3, rayDirection: BVHVector3, threshold?: number, onlyFirst?: boolean, filter?: (intersect: BVHIntersect) => boolean): BVHIntersect[];
+}

package/five/bvh/index.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three';
+import { BVHMesh } from './bvhMesh';
+import { BVHPoints } from './bvhPoints';
+export declare function getBvhTreeForMesh(mesh: THREE.Mesh): BVHMesh | null;
+export declare function bindBvhTreeForMesh(mesh: THREE.Mesh, bvh: BVHMesh): void;
+export declare function unbindBvhTreeForMesh(mesh: THREE.Mesh, bvh: BVHMesh): void;
+export declare function getBvhTreeForPoints(mesh: THREE.Points): BVHPoints | null;
+export declare function bindBvhTreeForPoints(points: THREE.Points, bvh: BVHPoints): void;
+export declare function unbindBvhTreeForPoints(mesh: THREE.Points): void;
+export declare function generateBvhTree<T extends THREE.Object3D>(obj: T, useWorker?: boolean, maxItemPerNode?: number, maxTreeDepth?: number): Promise<T>;

package/five/bvh/worker.d.ts

@@ -0,0 +1,35 @@
+import { WorkerType } from '../utils/worker';
+export type BVHWorkerType = WorkerType<{
+    type: 'mesh' | 'points';
+    attributes: {
+        [key: string]: {
+            array: ArrayLike<number>;
+            stride?: number;
+            offset?: number;
+        };
+    };
+    indices?: {
+        array: ArrayLike<number>;
+        stride?: number;
+        offset?: number;
+    };
+    maxItemPerNode: number;
+    maxTreeDepth: number;
+    extents?: number[];
+}[], {
+    type: 'mesh' | 'points';
+    attributes: {
+        [key: string]: {
+            array: ArrayLike<number>;
+            stride?: number;
+            offset?: number;
+        };
+    };
+    indices?: {
+        array: ArrayLike<number>;
+        stride?: number;
+        offset?: number;
+    };
+    rootNodePacked: ArrayBuffer;
+    offsetArray: ArrayLike<number>;
+}[]>;

package/five/cardboard/helper.d.ts

@@ -0,0 +1,2 @@
+declare function createHelper(): HTMLDivElement;
+export { createHelper };

package/five/cardboard/index.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import { Sensor } from "./sensor";
+declare class Cardboard {
+    renderer: THREE.WebGLRenderer;
+    sensor: Sensor;
+    scale: number;
+    private cameraL;
+    private cameraR;
+    constructor(renderer: THREE.WebGLRenderer);
+    render(scene: THREE.Scene, camera: THREE.Camera): void;
+    dispose(): void;
+}
+export { Cardboard };

package/five/cardboard/sensor.d.ts

@@ -0,0 +1,158 @@
+import * as THREE from "three";
+declare class SensorSample {
+    sample: THREE.Vector3;
+    timestampS: number;
+    constructor(sample?: THREE.Vector3, timestampS?: number);
+    set(sample: THREE.Vector3, timestampS: number): void;
+    copy(sensorSample: SensorSample): void;
+}
+/**
+ * An implementation of a simple complementary filter, which fuses gyroscope and
+ * accelerometer data from the 'devicemotion' event.
+ *
+ * Accelerometer data is very noisy, but stable over the long term.
+ * Gyroscope data is smooth, but tends to drift over the long term.
+ *
+ * This fusion is relatively simple:
+ * 1. Get orientation estimates from accelerometer by applying a low-pass filter
+ *    on that data.
+ * 2. Get orientation estimates from gyroscope by integrating over time.
+ * 3. Combine the two estimates, weighing (1) in the long term, but (2) for the
+ *    short term.
+ */
+declare class ComplementaryFilter {
+    kFilter: number;
+    isDebug: boolean;
+    currentAccelMeasurement: SensorSample;
+    currentGyroMeasurement: SensorSample;
+    previousGyroMeasurement: SensorSample;
+    filterQ: THREE.Quaternion;
+    previousFilterQ: THREE.Quaternion;
+    accelQ: THREE.Quaternion;
+    isOrientationInitialized: boolean;
+    estimatedGravity: THREE.Vector3;
+    measuredGravity: THREE.Vector3;
+    gyroIntegralQ: THREE.Quaternion;
+    constructor(kFilter: number, isDebug: boolean);
+    addAccelMeasurement(vector: THREE.Vector3, timestampS: number): void;
+    addGyroMeasurement(vector: THREE.Vector3, timestampS: number): void;
+    getOrientation(): THREE.Quaternion;
+    private run_;
+    private accelToQuaternion_;
+    private gyroToQuaternionDelta_;
+}
+/**
+ * Given an orientation and the gyroscope data, predicts the future orientation
+ * of the head. This makes rendering appear faster.
+ *
+ * Also see: http://msl.cs.uiuc.edu/~lavalle/papers/LavYerKatAnt14.pdf
+ *
+ * @param predictionTimeS - time from head movement to the appearance of
+ * the corresponding image.
+ */
+declare class PosePredictor {
+    predictionTimeS: number;
+    isDebug: boolean;
+    previousQ: THREE.Quaternion;
+    previousTimestampS: number | null;
+    deltaQ: THREE.Quaternion;
+    outQ: THREE.Quaternion;
+    constructor(predictionTimeS: number, isDebug: boolean);
+    getPrediction(currentQ: THREE.Quaternion, gyro: THREE.Vector3, timestampS: number): THREE.Quaternion;
+}
+declare class Pose {
+    angularAcceleration: Float32Array | null;
+    angularVelocity: Float32Array | null;
+    linearAcceleration: Float32Array | null;
+    linearVelocity: Float32Array | null;
+    orientation: Float32Array | null;
+    position: Float32Array | null;
+    constructor();
+}
+declare class FrameData {
+    leftProjectionMatrix: Float32Array;
+    leftViewMatrix: Float32Array;
+    pose: Pose;
+    rightProjectionMatrix: Float32Array;
+    rightViewMatrix: Float32Array;
+    timestamp: number;
+    constructor();
+}
+declare class FieldOfView {
+    leftDegrees: number;
+    rightDegrees: number;
+    upDegrees: number;
+    downDegrees: number;
+    constructor();
+}
+/**
+ * The pose sensor, implemented using DeviceMotion APIs.
+ */
+declare class Sensor {
+    viewer: {
+        id?: string;
+        label?: string;
+        fov: number;
+        interLensDistance: number;
+        baselineLensDistance: number;
+        screenLensDistance: number;
+        distortionCoefficients: [number, number];
+        inverseCoefficients: number[];
+    };
+    device: {
+        widthMeters: number;
+        heightMeters: number;
+        bevelMeters: number;
+    };
+    depthNear: number;
+    depthFar: number;
+    yawOnly: boolean;
+    accelerometer: THREE.Vector3;
+    gyroscope: THREE.Vector3;
+    filter: ComplementaryFilter;
+    posePredictor: PosePredictor;
+    isFirefoxAndroid: boolean;
+    isIOS: boolean;
+    isDeviceMotionInRadians: boolean;
+    isWithoutDeviceMotion: boolean;
+    filterToWorldQ: THREE.Quaternion;
+    inverseWorldToScreenQ: THREE.Quaternion;
+    worldToScreenQ: THREE.Quaternion;
+    originalPoseAdjustQ: THREE.Quaternion;
+    resetQ: THREE.Quaternion;
+    private previousTimestampS;
+    private orientationOut_;
+    private _deviceOrientationQ?;
+    private deviceOrientationFixQ?;
+    private deviceOrientationFilterToWorldQ?;
+    constructor(kFilter: number, predictionTime: number, yawOnly: boolean, isDebug: boolean);
+    getPosition(): any;
+    getOrientation(): Float32Array<ArrayBufferLike>;
+    getPose(): Pose;
+    resetPose(): void;
+    getFrameData(frameData: FrameData): FrameData;
+    start(): () => void;
+    getEyeOffset(): {
+        left: number[];
+        right: number[];
+    };
+    getEyeProjectionMatrix(): {
+        left: number[];
+        right: number[];
+    };
+    getEyeFieldOfView(): {
+        left: FieldOfView;
+        right: FieldOfView;
+    };
+    private onDeviceOrientation_;
+    private onDeviceMotion_;
+    private updateDeviceMotion_;
+    private onOrientationChange_;
+    /**
+     * This is only needed if we are in an cross origin iframe on iOS to work around
+     * this issue: https://bugs.webkit.org/show_bug.cgi?id=152299.
+     */
+    private onMessage_;
+    private setScreenTransform_;
+}
+export { Sensor, Pose, FrameData, FieldOfView };

package/five/certificates/hardware.d.ts

@@ -0,0 +1 @@
+export {};

package/five/controllers/base.d.ts

@@ -0,0 +1,166 @@
+import * as THREE from "three";
+import { Camera, CameraPose } from "../core/camera";
+import { Scene } from "../core/scene";
+import { ModelScene } from "../model";
+import { Mode } from "../application/mode";
+import { Pano } from "../utils/pano";
+import { GestureEvent } from '../utils/event';
+import { Works } from "../work";
+import { State } from "../types/state";
+import { Pose } from "../types/pose";
+import { Viewport } from "../types/viewport";
+import { ImageOptions } from "../types/imageOptions";
+import { MovePanoEffect } from "../types/movePanoEffect";
+import { Subscribe } from "../utils/subscribe";
+import { ControllerEventTypes } from "./events";
+import { Motion } from "../utils/motion";
+type CameraMotion = Motion<"longitude" | "latitude" | "fov">;
+type PostProcessingType = 'edl' | 'hq' | 'luminance' | null;
+interface BaseControllerInitArgs {
+    fiveId: string;
+    works: Works;
+    scene: Scene;
+    modelScene: ModelScene;
+    xrCustomObjectsScene: THREE.Scene;
+    helper: THREE.Group;
+    camera: Camera;
+    renderer: THREE.WebGLRenderer;
+    viewport: Viewport;
+    element: HTMLElement;
+    extraElements: HTMLElement[];
+    imageOptions: ImageOptions;
+    enableWheel: boolean;
+    videoTexture: THREE.VideoTexture;
+    initial: {
+        /** 初始化状态 */
+        state: Partial<State>;
+        currentState: State;
+        /** 状态切换动画时长 */
+        duration: number;
+        /** 动画模式 */
+        effect: MovePanoEffect;
+        /** 是否是用户触发的 */
+        userAction: boolean;
+    };
+}
+declare class BaseController extends Subscribe<ControllerEventTypes> implements BaseControllerInitArgs {
+    mode: Mode;
+    fiveId: string;
+    needsRender: boolean;
+    destroyed: boolean;
+    cameraMotion: CameraMotion;
+    userAction: boolean;
+    /** 资源等待中 */
+    pending: Set<string>;
+    scene: Scene;
+    modelScene: ModelScene;
+    xrCustomObjectsScene: THREE.Scene;
+    helper: THREE.Group;
+    camera: Camera;
+    renderer: THREE.WebGLRenderer;
+    viewport: Viewport;
+    element: HTMLElement;
+    works: Works;
+    imageOptions: ImageOptions;
+    videoTexture: THREE.VideoTexture;
+    extraElements: HTMLElement[];
+    enableWheel: boolean;
+    initial: {
+        state: Partial<State>;
+        currentState: State;
+        duration: number;
+        effect: MovePanoEffect;
+        userAction: boolean;
+    };
+    currentPano: Pano;
+    protected panState?: {
+        x: number;
+        y: number;
+        pointerLength: number;
+    };
+    protected pressState?: {
+        event: GestureEvent;
+        timeStamp: number;
+        stop: () => void;
+    };
+    protected pinchState?: {
+        x: number;
+        y: number;
+    };
+    protected mouseWheelState?: {
+        timer: any;
+    };
+    protected mouseMoveState?: {
+        event: GestureEvent;
+        timeStamp: number;
+    };
+    /** 相机旋转是否在惯性运动 */
+    protected inMomentumMovement: {
+        uuid: string;
+        event?: GestureEvent;
+    } | null;
+    protected initAnimationReady: Promise<void>;
+    protected initAnimationIsReady: boolean;
+    private eventUnbinds;
+    static parseArgs(args: BaseControllerInitArgs): Required<BaseControllerInitArgs>;
+    static initAnimationEndState(args: BaseControllerInitArgs): State;
+    constructor(args: BaseControllerInitArgs);
+    /** 动态更新配置 */
+    updateConfiguration(args: {}): boolean;
+    /** 析构函数 */
+    destroy(): void;
+    /** 是否准备好，即不在用户操作中，并且不再动画中 */
+    isReady(): boolean;
+    bindExtraElement(element: HTMLElement): void;
+    unbindExtraElement(element: HTMLElement): void;
+    /** 生命周期： 更新模型 */
+    updateModel(modelScene: ModelScene): void;
+    /** 生命周期： 更新 Work */
+    updateWork(works: Works, state: Partial<State>, options: {
+        duration: number;
+        effect: MovePanoEffect;
+    }, userAction: boolean): boolean;
+    /** 生命周期： 更新当前时间  */
+    updateTime(time: number, deltaTime: number, ...args: any[]): void;
+    /** 生命周期： 更新渲染  */
+    render(): boolean;
+    /** 转动摄像头 */
+    updateCamera(pose: Partial<Pose>, duration: number, userAction: boolean): Promise<void>;
+    /** 通过帧动画转动摄像头 */
+    updateCameraWithKeyframes(keyframes: {
+        progress: number;
+        value: Pose;
+        key?: string;
+    }[], duration: number, userAction: boolean): Promise<void>;
+    /** 获取目标姿态 */
+    getTargetState(): State;
+    /** 初始化动画 */
+    protected initAnimation(): Promise<void>;
+    /** 改变相机 */
+    protected setCamera(cameraPose?: Partial<CameraPose>): void;
+    stopMomentumMovement(): void;
+    /** 用户 Pan 事件 */
+    protected onPanGesture(event: GestureEvent): void;
+    /** 用户 Tap 事件 */
+    protected onTapGesture(event: GestureEvent): void;
+    /** 用户 DblTap 事件 */
+    protected onDblTapGesture(event: GestureEvent): void;
+    /** 用户 Tap 事件 */
+    protected onPressGesture(event: GestureEvent): void;
+    /** 用户 Pinch 事件 */
+    protected onPinchGesture(event: GestureEvent): void;
+    /** 用户 MouseWheel 事件 */
+    protected onMouseWheel(event: GestureEvent): void;
+    /** 用户 MouseMove 事件 */
+    protected onMouseMove(event: GestureEvent): void;
+    /** 计算屏幕坐标位置到屏幕标准空间 x: [-1, 1], y: [-1, 1] */
+    protected relativeClientPosition(mouseXY: {
+        x: number;
+        y: number;
+    }): THREE.Vector2;
+    /** 从屏幕标准空间 得到 射线 */
+    protected createRaycasterFromCamera(coords: THREE.Vector2, camera: Camera): THREE.Raycaster;
+    /** 用户事件绑定 */
+    private bindEvents;
+}
+export { BaseController, CameraMotion, PostProcessingType, BaseControllerInitArgs };

package/five/controllers/events.d.ts

@@ -0,0 +1,69 @@
+import { GestureEvent, BaseEvent, StateEvent, IntersectEvent, PanoEvent, PanoTextureEvent, XRSessionEvent, XRGestureEvent, XRControllerEvent } from "../utils/event";
+type ControllerEventTypes = {
+    /** 手势 滑动屏幕 */
+    "gesture.pan"(event: GestureEvent): void;
+    /** 手势 点击屏幕 */
+    "gesture.tap"(event: GestureEvent): void;
+    /** 手势 双击屏幕 */
+    "gesture.dbltap"(event: GestureEvent): void;
+    /** 手势 长按屏幕 */
+    "gesture.press"(event: GestureEvent): void;
+    /** 手势 双指缩放 */
+    "gesture.pinch"(event: GestureEvent): void;
+    /** 手势 鼠标滚轮 */
+    "gesture.mousewheel"(event: GestureEvent): void;
+    /** 手势 鼠标移动 */
+    "gesture.mousemove"(event: GestureEvent): void;
+    /** 手势 惯性 */
+    "gesture.momentum"(event: GestureEvent): void;
+    /** 模态切换动画 开始 */
+    "initAnimation.start"(event: StateEvent): void;
+    /** 模态切换动画 结束 */
+    "initAnimation.end"(event: StateEvent): void;
+    /** 相机改变 */
+    "camera.update"(event: StateEvent): void;
+    "intersect.update"(event: IntersectEvent): void;
+    /** 选择 */
+    "pano.select"(event: PanoEvent): void;
+    /** 请求点位 */
+    "pano.request"(event: PanoEvent): void;
+    /** 运动去点位 */
+    "pano.moveTo"(event: PanoEvent): void;
+    /** 运动点位过程 */
+    "pano.moving"(event: PanoEvent): void;
+    /** 运动到达点位 */
+    "pano.arrived"(event: PanoEvent): void;
+    /** 取消运动点位 */
+    "pano.cancel"(event: PanoEvent): void;
+    /** 运动点位出错 */
+    "pano.error"(event: PanoEvent): void;
+    /** 加载全景材质 */
+    "pano.texture.load"(event: PanoTextureEvent): void;
+    /** 加载全景材质进度 */
+    "pano.texture.progress"(event: PanoTextureEvent): void;
+    /** 加载全景材质成功 */
+    "pano.texture.success"(event: PanoTextureEvent): void;
+    /** 加载全景材质失败 */
+    "pano.texture.error"(event: PanoTextureEvent): void;
+    /** 加载全景材质中止 */
+    "pano.texture.abort"(event: PanoTextureEvent): void;
+    /** VRPanorama 请求退出 */
+    "vr.requestExit"(event: BaseEvent): void;
+    /** XR 退出 */
+    "xr.session.end"(event: XRSessionEvent): void;
+    /** XR 进入 */
+    "xr.session.start"(event: XRSessionEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.tap"(event: XRGestureEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.press"(event: XRGestureEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.buttonUp"(event: XRGestureEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.buttonDown"(event: XRGestureEvent): void;
+    /** XR手柄更新*/
+    "xr.controller.update"(event: XRControllerEvent): void;
+    /** 抛出错误 */
+    "error"(error: Error): void;
+};
+export { ControllerEventTypes };