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

package/five/utils/uniform.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+export interface IUniform<T> {
+    value: T;
+}
+export type Uniforms = Record<string, IUniform<any>>;
+export declare class Uniform<T> extends THREE.Uniform implements IUniform<T> {
+    value: T;
+    constructor(value: T);
+}
+export declare function setUniform<T>(uniform: IUniform<T>, value: T): void;
+export declare function cloneUniforms<T extends Uniforms>(uniforms: T): T;
+export declare function mergeUniforms<A extends Uniforms>(a: A): A;
+export declare function mergeUniforms<A extends Uniforms, B extends Uniforms>(a: A, b: B): A & B;
+export declare function mergeUniforms<A extends Uniforms, B extends Uniforms, C extends Uniforms>(a: A, b: B, c: C): A & B & C;
+export declare function mergeUniforms<A extends Uniforms, B extends Uniforms, C extends Uniforms, D extends Uniforms>(a: A, b: B, c: C, d: D): A & B & C & D;

package/five/utils/url.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 判断是否是url的绝对地址
+ * @param url - url地址
+ */
+export declare function isAbsoluteURL(url: string): boolean;
+/**
+ * 获取完整 URL 地址
+ * @param url - url地址
+ */
+export declare function getFullURL(url: string): string;
+/**
+ * 路径拼接
+ * @param segments 路径片段
+ * @returns
+ */
+export declare function pathJoin(...segments: string[]): string;
+/**
+ * 添加 URL 参数
+ * @param url
+ * @param search
+ * @returns
+ */
+export declare function appendSearch(url: string, search?: string): string;
+/**
+ * 标准化 url
+ * @param url
+ * @returns
+ */
+export declare function normalizeURL(url: string): string;
+/**
+ * 获取文件后缀名, 返回 .png .jpeg 等形式
+ * @param url
+ * @returns
+ */
+export declare function getExtname(url: string): string;

package/five/utils/uuid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 计算一个唯一 id
+ */
+declare function createUuid(): string;
+export { createUuid as uuid };

package/five/utils/values.d.ts

@@ -0,0 +1,2 @@
+declare function values<T>(object: Record<any, T>): T[];
+export { values };

package/five/utils/vectorCoordinates.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from "three";
+/** 坐标转换成单位向量 */
+export declare function coordinatesToVector(coordinates: {
+    longitude: number;
+    latitude: number;
+}, target?: THREE.Vector3): THREE.Vector3;
+/** 单位向量转换成坐标 */
+export declare function vectorToCoordinates(vector: THREE.Vector3): {
+    longitude: number;
+    latitude: number;
+};
+/**
+ * 通过经度计算 Heading, Heading 是个古老的参数，新的工程中请不要使用了
+ *
+ * @deprecated
+ * 不再使用 heading 这种计算方式。
+ *
+ * @param longitude - 经度
+ */
+export declare function longitudeToHeading(longitude: number): number;
+/**
+ * 通过 heading 计算 longitude
+ *
+ *  @deprecated
+ * 不再使用 heading 这种计算方式。
+ *
+ * @param heading - 方向
+ */
+export declare function headingToLongitude(heading: number): number;

package/five/utils/volume.d.ts

@@ -0,0 +1,111 @@
+import * as THREE from 'three';
+export type RegionBoundingVolumeJson = {
+    region: number[];
+};
+export type BoxBoundingVolumeJson = {
+    box: number[];
+};
+export type SphereBoundingVolumeJson = {
+    sphere: number[];
+};
+export type BoundingVolumeJson = RegionBoundingVolumeJson | BoxBoundingVolumeJson | SphereBoundingVolumeJson;
+export declare enum VolumePlaneIntersect {
+    Outside = -1,
+    Intersecting = 0,
+    Inside = 1
+}
+export declare class CullingVolume {
+    static get MASK_OUTSIDE(): number;
+    static get MASK_INSIDE(): number;
+    static get MASK_INDETERMINATE(): number;
+    planes: THREE.Plane[];
+    constructor(planes?: THREE.Plane[]);
+    setFromFrustum(frustum: THREE.Frustum): this;
+    setFromCamera(camera: THREE.Camera): this;
+    applyMatrix4(matrix: THREE.Matrix4): void;
+    copy(cullingVolume: CullingVolume): this;
+    clone(): CullingVolume;
+    computeVisibility(boundingVolume: BoundingVolume): VolumePlaneIntersect;
+    computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
+}
+export interface BoundingVolume {
+    type: 'box' | 'sphere' | 'regin';
+    applyMatrix4(matrix: THREE.Matrix4): this;
+    getBoundingBox(target: THREE.Box3): THREE.Box3;
+    toGeometry(): THREE.BufferGeometry;
+    getCenter(result: THREE.Vector3): THREE.Vector3;
+    distanceSquaredToPoint(point: THREE.Vector3): number;
+    distanceToPoint(point: THREE.Vector3): number;
+    distanceToPlane(plane: THREE.Plane): number;
+    intersectPlane(plane: THREE.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE.Ray, threshold?: number, far?: number): boolean;
+    clone(): BoundingVolume;
+    copy(boundingVolume: this): this;
+    fromJson(json: any): this;
+    toJson(): BoundingVolumeJson;
+}
+export declare class BoxBoundingVolume implements BoundingVolume {
+    type: "box";
+    center: THREE.Vector3;
+    halfSize: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    constructor();
+    fromJson({ box }: BoxBoundingVolumeJson): this;
+    toJson(): BoxBoundingVolumeJson;
+    copy(boxBoundingVolume: BoxBoundingVolume): this;
+    clone(): BoxBoundingVolume;
+    applyMatrix4(matrix: THREE.Matrix4): this;
+    getCenter(result: THREE.Vector3): THREE.Vector3;
+    distanceSquaredToPoint(point: THREE.Vector3): number;
+    distanceToPoint(point: THREE.Vector3): number;
+    distanceToPlane(plane: THREE.Plane): number;
+    getBoundingBox(target: THREE.Box3): THREE.Box3;
+    toGeometry(): THREE.BufferGeometry;
+    intersectPlane(plane: THREE.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE.Ray, threshold?: number, far?: number): boolean;
+}
+export declare class SphereBoundingVolume implements BoundingVolume {
+    type: "sphere";
+    center: THREE.Vector3;
+    radius: number;
+    constructor();
+    fromJson({ sphere }: SphereBoundingVolumeJson): this;
+    toJson(): SphereBoundingVolumeJson;
+    copy(sphereBoundingVolume: SphereBoundingVolume): this;
+    clone(): SphereBoundingVolume;
+    getBoundingBox(target: THREE.Box3): THREE.Box3;
+    toGeometry(): THREE.BufferGeometry;
+    applyMatrix4(matrix: THREE.Matrix4): this;
+    getCenter(result: THREE.Vector3): THREE.Vector3;
+    distanceSquaredToPoint(point: THREE.Vector3): number;
+    distanceToPoint(point: THREE.Vector3): number;
+    distanceToPlane(plane: THREE.Plane): number;
+    intersectPlane(plane: THREE.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE.Ray, threshold?: number, far?: number): boolean;
+}
+export declare class RegionBoundingVolume implements BoundingVolume {
+    type: "regin";
+    west: number;
+    south: number;
+    east: number;
+    north: number;
+    minHeight: number;
+    maxHeight: number;
+    constructor();
+    fromJson({ region }: RegionBoundingVolumeJson): this;
+    toJson(): RegionBoundingVolumeJson;
+    copy(regionBoundingVolume: RegionBoundingVolume): this;
+    clone(): RegionBoundingVolume;
+    getBoundingBox(target: THREE.Box3): THREE.Box3;
+    toGeometry(): THREE.BufferGeometry;
+    applyMatrix4(matrix: THREE.Matrix4): this;
+    getCenter(result: THREE.Vector3): THREE.Vector3;
+    distanceToPoint(point: THREE.Vector3): number;
+    distanceSquaredToPoint(point: THREE.Vector3): number;
+    distanceToPlane(plane: THREE.Plane): number;
+    intersectPlane(plane: THREE.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE.Ray, threshold?: number, far?: number): boolean;
+}
+export declare function isBoundingVolume(obj: any): obj is BoundingVolume;
+export declare function makeBoundingVolume(header: BoundingVolumeJson | BoundingVolume): BoundingVolume;
+export declare function createDebugBoundingMesh(boundingVolume: BoundingVolume, level?: number): THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial> | null;

package/five/utils/webglError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 解析 webgl 错误信息
+ * @param gl - webgl 具柄
+ * @returns 可读错误对象
+ */
+declare function webglError(gl: WebGLRenderingContext): Error | null;
+export { webglError };

package/five/utils/worker.d.ts

@@ -0,0 +1,26 @@
+export type WorkerType<Input, Output> = {
+    Input: Input;
+    Output: Output;
+};
+export type WorkerCallback<T extends WorkerType<any, any>> = (input: T['Input']) => Promise<{
+    output: T['Output'];
+    transfer: Transferable[];
+}>;
+export declare function defineWorker<T extends WorkerType<any, any>>(callback: WorkerCallback<T>): void;
+export type WorkerCreator = (workId: number) => Worker;
+export declare class WorkerPool<T extends WorkerType<any, any>> {
+    private disposed;
+    private pool;
+    private queue;
+    private workers;
+    private workerResolvers;
+    private workerStatus;
+    private workerCreator;
+    constructor(workerCreator: WorkerCreator | null, pool: number);
+    setWorkerCreator(workerCreator: WorkerCreator): void;
+    private initWorker;
+    private getIdleWorker;
+    private onMessage;
+    postMessage(input: T['Input'], transfer?: Transferable[]): Promise<T['Output']>;
+    dispose(): void;
+}

package/five/webxr/XRControllerModelFactory.d.ts

@@ -0,0 +1,28 @@
+import { Object3D } from 'three';
+import * as THREE from 'three';
+import { MotionController } from './motionHelper';
+declare class XRControllerModel extends Object3D {
+    motionController: MotionController | null;
+    envMap: THREE.Texture | null;
+    constructor();
+    setEnvironmentMap(envMap: THREE.Texture): this;
+    /**
+     * Polls data from the XRInputSource and updates the model's components to match
+     * the real world data
+     */
+    updateMatrixWorld(force: boolean): void;
+}
+declare class XRControllerModelFactory {
+    path: string;
+    _assetCache: any;
+    gltfLoader: {
+        load: (url: string, callback: (result: {
+            scene: THREE.Object3D;
+        }) => void) => any;
+    } | null;
+    constructor(gltfLoader?: {
+        load: () => any;
+    } | null);
+    createControllerModel(controller: any): XRControllerModel;
+}
+export { XRControllerModelFactory };

package/five/webxr/motionHelper.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @webxr-input-profiles/motion-controllers 1.0.0 https://github.com/immersive-web/webxr-input-profiles
+ */
+declare const Constants: {
+    Handedness: Readonly<{
+        NONE: "none";
+        LEFT: "left";
+        RIGHT: "right";
+    }>;
+    ComponentState: Readonly<{
+        DEFAULT: "default";
+        TOUCHED: "touched";
+        PRESSED: "pressed";
+    }>;
+    ComponentProperty: Readonly<{
+        BUTTON: "button";
+        X_AXIS: "xAxis";
+        Y_AXIS: "yAxis";
+        STATE: "state";
+    }>;
+    ComponentType: Readonly<{
+        TRIGGER: "trigger";
+        SQUEEZE: "squeeze";
+        TOUCHPAD: "touchpad";
+        THUMBSTICK: "thumbstick";
+        BUTTON: "button";
+    }>;
+    ButtonTouchThreshold: number;
+    AxisTouchThreshold: number;
+    VisualResponseProperty: Readonly<{
+        TRANSFORM: "transform";
+        VISIBILITY: "visibility";
+    }>;
+};
+declare function fetchProfilesList(basePath: string): Promise<any>;
+declare function fetchProfile(xrInputSource: XRInputSource, basePath: string, defaultProfile?: string | null, getAssetPath?: boolean): Promise<{
+    profile: any;
+    assetPath: any;
+}>;
+/**
+  * @description Builds a motion controller with components and visual responses based on the
+  * supplied profile description. Data is polled from the xrInputSource's gamepad.
+  * @author Nell Waliczek / https://github.com/NellWaliczek
+*/
+declare class MotionController {
+    /**
+     * @param {Object} xrInputSource - The XRInputSource to build the MotionController around
+     * @param {Object} profile - The best matched profile description for the supplied xrInputSource
+     * @param {Object} assetUrl
+     */
+    xrInputSource: XRInputSource;
+    assetUrl: string;
+    id: any;
+    layoutDescription: any;
+    components: any;
+    constructor(xrInputSource: XRInputSource, profile: any, assetUrl: string);
+    get gripSpace(): XRSpace;
+    get targetRaySpace(): XRSpace;
+    /**
+     * @description Returns a subset of component data for simplified debugging
+     */
+    get data(): any[];
+    /**
+     * @description Poll for updated data based on current gamepad state
+     */
+    updateFromGamepad(): void;
+}
+export { Constants, MotionController, fetchProfile, fetchProfilesList };

package/five/webxr/xrButton.d.ts

@@ -0,0 +1,4 @@
+declare class XRButton {
+    static createButton(onClickHook: () => void): HTMLAnchorElement | HTMLButtonElement;
+}
+export { XRButton };

package/five/webxr/xrController.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+type XRControllerRay = {
+    angularVelocity: THREE.Vector3;
+    linearVelocity: THREE.Vector3;
+    up: THREE.Vector3;
+    matrix: THREE.Matrix4;
+    position: THREE.Vector3;
+    rotation: THREE.Euler;
+};
+declare class XRController {
+    _targetRay: any;
+    _grip: any;
+    _hand: any;
+    _axes: number[];
+    constructor();
+    getHandSpace(): any;
+    getTargetRaySpace(): any;
+    getGripSpace(): any;
+    dispatchEvent(event: any): this;
+    disconnect(inputSource: XRInputSource): this;
+    getAxes(): number[];
+    update(inputSource: any, frame: any, referenceSpace: any): this;
+}
+export { XRController, XRControllerRay };

package/five/webxr/xrManager.d.ts

@@ -0,0 +1,84 @@
+import { XRController } from './xrController';
+import { Camera } from '../core/camera';
+import * as THREE from "three";
+type XRMachineType = 'Pico' | 'Oculus' | 'VP';
+interface XRInitOption {
+    /** 使用WEBXR的当前设备*/
+    machineType: XRMachineType;
+    /** 全景模式还是视差模式*/
+    isPanorama: boolean;
+    /** 使用的参考空间类型*/
+    referenceSpaceType: XRReferenceSpaceType;
+    onSessionStart?(session: XRSession): void;
+    onSessionEnd?(): void;
+}
+declare class XRManager {
+    /** 是否使用全景模式*/
+    isPanorama: boolean;
+    /** 当前的设备*/
+    machineType: XRMachineType;
+    /** 场景渲染器*/
+    renderer: THREE.WebGLRenderer;
+    /** opengles句柄*/
+    gl: WebGLRenderingContext;
+    /** 是否开启XR模式 */
+    enabled: boolean;
+    /** WebXR模式Context */
+    session: XRSession | null;
+    /** XR参考空间类型*/
+    referenceSpaceType: XRReferenceSpaceType;
+    /** XR参考空间 */
+    referenceSpace: XRReferenceSpace | null;
+    /** XR控制器 */
+    controllers: XRController[];
+    /** XR控制器控制数据 */
+    inputSourcesMap: Map<XRInputSource, XRController>;
+    /** XR双相机 */
+    cameraVR: THREE.ArrayCamera;
+    /** XR左眼相机*/
+    cameraL: THREE.PerspectiveCamera;
+    /** XR右眼相机*/
+    cameraR: THREE.PerspectiveCamera;
+    /** 是否在获取*/
+    isPresenting: boolean;
+    /** 视锥近面*/
+    private currentDepthNear;
+    /** 视锥远面*/
+    private currentDepthFar;
+    /** 左眼相机位姿*/
+    private cameraLPos;
+    /** 右眼相机位姿*/
+    private cameraRPos;
+    /** XRSession 开始 */
+    private onSessionStartCallback;
+    /** XRSession 结束 */
+    private onSessionEndCallback;
+    constructor(renderer: THREE.WebGLRenderer, gl: WebGLRenderingContext, options?: Partial<XRInitOption>);
+    getController(index: number): any;
+    getRightController(): any;
+    getLeftController(): any;
+    getControllerGrip(index: number): any;
+    getCameras(): any;
+    private updateCamera;
+    /**
+     * @author jsantell / https://www.jsantell.com/
+     *
+     * Assumes 2 cameras that are parallel and share an X-axis, and that
+     * the cameras' projection and world matrices have already been set.
+     * And that near and far planes are identical for both cameras.
+     * Visualization of this technique: https://computergraphics.stackexchange.com/a/4765
+     */
+    setProjectionFromUnion(camera: THREE.PerspectiveCamera, cameraL: THREE.PerspectiveCamera, cameraR: THREE.PerspectiveCamera): void;
+    /**
+     * 获取THREEJS用于渲染XR场景的双眼相机
+     * @param camera - 传统模式下渲染场景的THREEJS相机
+     * @returns - 用于渲染XR场景的双眼相机
+     */
+    getCamera(camera: Camera): any;
+    private updateInputSources;
+    private onSessionEvent;
+    private onSessionEnd;
+    private onRequestReferenceSpace;
+    setSession(value: XRSession | null): void;
+}
+export { XRManager, XRInitOption, XRMachineType };

package/five/work/_ALLOW_HOST.d.ts

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

package/five/work/index.d.ts

@@ -0,0 +1,6 @@
+export { parseWork, type ParseOptions, Work, type WorkCubeImage, type WorkImage, type WorkInitial, type WorkModel, type WorkModelLayer, type WorkObserver, type WorkTile, type WorkVideo, } from './work';
+export { type WorkInitialJson, type WorkJson, type WorkModelJson, type WorkModelLayerJson, type WorkObserverJson, type WorkPanoramaJson, type WorkPanoramasJson, } from './workJsonType';
+export { workToJson, } from './workJson';
+export { type LoosePanoWork, type LooseWork, type LooseWorkInitial, type LooseWorkModel, type LooseWorkObserver, type LooseWorkPanorama, type LooseWorkVideo, type LooseWorkWithExtrinsics, } from './looseWorkType';
+export { type Works, createWorks, } from './works';
+export { WorkResolvedObserver, } from './workResolvedObserver';

package/five/work/keychain.d.ts

@@ -0,0 +1,5 @@
+import { X509 } from "../thirdparty/jsrsasign";
+declare function verifyCertificate(certificate: X509): boolean;
+declare function addCertificate(certificate: X509 | string): boolean;
+declare function verifyMessage(message: string, signature: string, certificate: X509 | string): boolean;
+export { verifyCertificate, addCertificate, verifyMessage };

package/five/work/looseWorkType.d.ts

@@ -0,0 +1,121 @@
+import type { ParseOptions } from './work';
+import type { TilesetHeader } from "../model/tile3d/header";
+export interface LooseWorkVideo {
+    source: string;
+    matrix: number[];
+    size: number[];
+}
+export interface LooseWorkPanorama {
+    active?: boolean;
+    loadable?: boolean;
+    index?: number;
+    right?: string;
+    left?: string;
+    up?: string;
+    down?: string;
+    front?: string;
+    back?: string;
+    video?: LooseWorkVideo;
+    tiles?: number[];
+    size_list?: number[];
+    derived_id?: number;
+    derived_id_str?: string;
+}
+export interface LooseWorkInitial {
+    mode?: string;
+    pano_index?: number;
+    panoIndex?: number;
+    pano?: number;
+    longitude?: number;
+    latitude?: number;
+    fov?: number;
+    distance?: number;
+    offset?: number[] | {
+        x: number;
+        y: number;
+        z: number;
+    };
+    heading?: number;
+}
+export interface LooseWorkModel {
+    file_url?: string;
+    material_textures?: string[];
+    material_base_url?: string;
+    up_axis?: string;
+    coordinate?: NonNullable<TilesetHeader['rootMeta']>['coordinate'];
+    tiles?: {
+        type?: 'point_cloud' | 'mesh' | 'gaussian_splatting' | string;
+        name?: string;
+        up_axis?: string;
+        tileset_url: string;
+    };
+    layers?: [
+        {
+            type?: 'point_cloud' | 'mesh' | 'gaussian_splatting' | string;
+            name?: string;
+            up_axis?: string;
+            tileset_url: string;
+        }
+    ];
+}
+export interface LooseWorkObserver {
+    active?: boolean;
+    loadable?: boolean;
+    index?: number;
+    visible_nodes?: number[];
+    visibleNodes?: number[];
+    accessible_nodes?: number[];
+    accessibleNodes?: number[];
+    quaternion?: {
+        y: number;
+        x: number;
+        z: number;
+        w: number;
+    };
+    standing_position?: number[];
+    standingPosition?: number[];
+    position?: number[];
+    floor?: number;
+    floor_index?: number;
+    floorIndex?: number;
+    derived_id?: number;
+    derived_id_str?: string;
+}
+export interface LooseWork {
+    work_code?: string;
+    code?: string;
+    resource_code?: string;
+    basic_code?: string;
+    vr_code?: string;
+    workCode?: string;
+    project_id?: string;
+    name?: string;
+    modelAsync?: boolean;
+    initial?: LooseWorkInitial;
+    base_url?: string;
+    model?: LooseWorkModel;
+    panorama?: {
+        base_url?: string;
+        pano_high_cube_base_url?: string;
+        pano_cube_base_url?: string;
+        pattern?: LooseWorkPanorama;
+        info?: LooseWorkPanorama[];
+        list?: LooseWorkPanorama[];
+    };
+    observers?: LooseWorkObserver[];
+}
+export interface LooseWorkWithExtrinsics extends ParseOptions {
+    /** work 数据 */
+    work: LooseWork;
+}
+export interface LoosePanoWork {
+    name?: string;
+    code?: string;
+    up: string;
+    down: string;
+    right: string;
+    left: string;
+    front: string;
+    back: string;
+    size: number;
+}

package/five/work/verify.d.ts

@@ -0,0 +1,7 @@
+export interface VerifyResult {
+    issuer: string;
+    expire: Date;
+    allowHosts: readonly string[];
+}
+export declare function verify(inputObject: any | any[]): VerifyResult | Error;
+export declare function verifyURL(source: string, allowHosts: readonly string[]): string | Error;