@realsee/five 6.8.0-alpha.3 → 6.8.0-alpha.31

package/five/application/fiveInitArgs.d.ts

@@ -0,0 +1,176 @@
+import * as THREE from "three";
+import { ImageOptions, TextureOptions } from "../types/imageOptions";
+import { Viewport } from "../types/viewport";
+import { ControllerCustomInitTypes } from "./controllers";
+import { FivePlugin, FivePluginInit } from "../types/plugin";
+/** Five 初始化参数 */
+interface FiveInitArgs {
+    /**
+     * 外部传入的 `THREE.WebGLRenderer`。
+     * @description
+     * 如果需要使用 `scissor` 分割画布功能，则必须使用外部传入 renderer，
+     * 并且设置为 `preserveDrawingBuffer: false`。
+     * 如果设置了 `renderer`, 则 `preserveDrawingBuffer`
+     * `backgroundColor` `backgroundAlpha` `antialias`
+     * 均不再生效。
+     */
+    renderer?: THREE.WebGLRenderer;
+    /**
+     * 内部 `THREE.WebGLRenderer` 是否通过像素拷贝的方式绘制。
+     * @description
+     * 当你想做屏幕截图等要确定取得屏幕像素时，请设置为 `true`。
+     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
+     * @default `false`
+     */
+    preserveDrawingBuffer?: boolean;
+    /**
+     * 输出画面的背景颜色。
+     * @description
+     * 通过数字类型传入。
+     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
+     * @default `0x181A1C`
+     * @example
+     * ```
+     * backgroundColor: 0xffffff // 白色
+     * backgroundColor: 0xff0000 // 红色
+     * ```
+     */
+    backgroundColor?: number | THREE.Color;
+    /**
+     * 输出画面的背景透明度
+     * @description
+     * 通过数字类型传入。取值范围 [0-1]
+     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
+     * @default `1`
+     */
+    backgroundAlpha?: number;
+    /**
+     * 是否开启 `THREE.WebGLRenderer` 的抗锯齿功能
+     * @description
+     * 这个抗锯齿功能是 `WEBGL` 自带的抗锯齿，并不是类似 fxaa taa 等后处理方式，比较吃性能。
+     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
+     * @default `false`
+     */
+    antialias?: boolean;
+    /**
+     * 屏幕渲染区域
+     * @description
+     * 请确保设置了 `renderer` 参数，`viewport` 参数才可生效
+     * `viewport` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
+     * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
+     * @example
+     * ```
+     * viewport: { left: 0.75, bottom: 0, width: 0.25, height: 1 }
+     * ```
+     */
+    viewport?: Viewport;
+    /**
+     * 是否自动播放。
+     * @description
+     * 播放即把内存中计算的内容渲染到画面上。play则是进行每帧播放。
+     * 如果 `play: false` 则不自动播放。屏幕不显示。
+     * 你还可以通过 `five.play()` `five.pause()` 的方式来控制播放。
+     * @default `true`
+     */
+    play?: boolean;
+    /**
+     * 全景图的配置参数
+     * @description
+     * 可以动态对配置在 `work` 数据中的全景图片在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
+     */
+    imageOptions?: ImageOptions;
+    /**
+     * 模型贴图的配置参数
+     * @description
+     * 可以动态对配置在 `work` 数据中的模型贴图在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
+     */
+    textureOptions?: TextureOptions;
+    /**
+     * 是否按需渲染
+     * @description
+     * 按需渲染时，如果页面中的渲染有 `needsRender: true` 属性。或者 `five.needsRender: true` 时
+     * 才会重新渲染屏幕，降低无用渲染产生的消耗。
+     * @default `true`
+     */
+    onlyRenderIfNeeds?: boolean;
+    /**
+     * 最高 fps 限制
+     * @description
+     * 如果为 `false`, 则不限制。最好也就是屏幕刷新率，不会再高了。
+     * @default `false`
+     */
+    maxFps?: number | false;
+    /**
+     * 外挂视频对象。
+     * @description
+     * 当点位中有视频元素，则会使用。如果不传入也会外部新建，
+     * 加入传入的原因是，视频自动播放在不同浏览器或者 webview 中有不同的特性。
+     * 给予更多外部操作的空间。
+     */
+    videoInstance?: HTMLVideoElement;
+    /** 全景图游走模式下的特定参数 */
+    panorama?: ControllerCustomInitTypes["Panorama"];
+    /** 模型游走模式下的特定参数 */
+    model?: ControllerCustomInitTypes["Model"];
+    /** 模型查看模式下的特定参数 */
+    floorplan?: ControllerCustomInitTypes["Floorplan"];
+    /** 户型图模式下的特定参数 */
+    topview?: ControllerCustomInitTypes["Topview"];
+    /** 地图模式下的特定参数 */
+    mapview?: ControllerCustomInitTypes["Mapview"];
+    /** VR眼镜模式下的特定参数 */
+    vrPanorama?: ControllerCustomInitTypes["VRPanorama"];
+    /** XR眼镜模式下的特定参数 */
+    xrPanorama?: ControllerCustomInitTypes["XRPanorama"];
+    /**
+     * 模式间切换时的过度动画时间
+     * @description
+     * 单位毫秒
+     * @default `800`
+     */
+    modeChangeDuration?: number;
+    /**
+     * 是否支持滚轮
+     */
+    enableWheel?: boolean;
+    /**
+     * 插件定义
+     * @description
+     * 详见插件部分。
+     */
+    plugins?: (FivePlugin<void> | FivePluginInit<FivePlugin<any, any>> | FivePluginInit<FivePlugin<void, any>>)[];
+    /**
+     * 是否展示 powered by 如视
+     */
+    poweredByRealsee?: boolean;
+    /**
+     * 是否使用对数深度缓存。如果要在单个场景中处理巨大的比例差异，就有必要使用
+     */
+    logarithmicDepthBuffer?: boolean;
+    /**
+     * 着色器精度. 可以是 "highp", "mediump" 或者 "lowp". 如果设备支持
+     */
+    precision?: 'highp' | 'mediump' | 'lowp';
+    /**
+     * 性能参数
+     */
+    powerPreference?: 'high-performance' | 'low-power' | 'default';
+    /**
+     * 是否使用webgl2渲染执行环境, 默认值 false
+     */
+    webgl2?: boolean;
+    /**
+     * 请求代理
+     * @param url - 发起的请求
+     * @returns 返回的请求
+     */
+    requestProxy?(url: string): string | Promise<string>;
+    /**
+     * @deprecated
+     * 无效
+     */
+    enableLayeringRendering?: boolean;
+}
+export type { FiveInitArgs };

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-png-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 | undefined;
+    rootNodePacked?: ArrayBuffer;
+    offsetArray?: ArrayLike<number>;
+    constructor(position: BVHAttr, indices?: BVHAttr | undefined);
+    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 {};