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

package/five/controllers/xrPanorama.d.ts

@@ -0,0 +1,81 @@
+import * as THREE from "three";
+import { State } from "../types/state";
+import { Pose } from "../types/pose";
+import { BaseControllerInitArgs } from "./base";
+import { PanoramaController, PanoramaControllerCustomInitArgs, PanoramaControllerInitArgs, LocationMotion } from "./panorama";
+import { Pano, PanoId } from '../utils/pano';
+import { PBMPanoPicture } from "../model";
+import { MovePanoOptions } from "../types/movePanoOptions";
+import { NetworkResponse, NetWorkMeta } from "../utils/ajax";
+interface XRPanoramaControllerCustomInitArgs extends Omit<PanoramaControllerCustomInitArgs, "maxLatitude" | "minLatitude"> {
+}
+type XRPanoramaControllerInitArgs = BaseControllerInitArgs & XRPanoramaControllerCustomInitArgs;
+declare const defaultXRPanoramaControllerInitArgs: Required<XRPanoramaControllerCustomInitArgs>;
+interface PanoResourceXR {
+    panoId: PanoId;
+    effect: Exclude<MovePanoOptions["effect"], undefined>;
+    effectEasing: Exclude<MovePanoOptions["effectEasing"], undefined>;
+    leftPanoPicture: PBMPanoPicture | null;
+    position: THREE.Vector3;
+    fixCameraTransform: THREE.Matrix4;
+}
+declare class XRPanoramaController extends PanoramaController implements Required<XRPanoramaControllerInitArgs> {
+    panoResources: {
+        [key: string]: PanoResourceXR;
+    };
+    /** XR管理器*/
+    private xrManager;
+    /** 控制器选取方向线*/
+    private xrControllerRay;
+    private gazeRay;
+    /** 控制器选取方向模型*/
+    private pointerLines;
+    /** 视差相机矩阵*/
+    private parallaxCameraMatrixs;
+    /** xr手柄事件监测*/
+    private xrHandleState;
+    private xrHandState;
+    private controllerWrappers;
+    protected pendingTextureTask?: {
+        panoId: PanoId;
+        hash: string;
+        onLoad(colorLeftResponse: NetworkResponse<THREE.Texture, NetWorkMeta[]>): void;
+        onError(error: Error): void;
+    };
+    static parseArgs(args: XRPanoramaControllerInitArgs): Required<PanoramaControllerInitArgs>;
+    static initAnimationEndState(args: XRPanoramaControllerInitArgs): State;
+    constructor(args: XRPanoramaControllerInitArgs);
+    updateConfiguration(args: XRPanoramaControllerCustomInitArgs): boolean;
+    /** 移动点位 */
+    moveToPano(pano: Pano, options: MovePanoOptions, userAction: boolean): void;
+    /** 移动相机 */
+    protected doMoveToPano(pano: Pano, panoResource: PanoResourceXR, options?: MovePanoOptions): void;
+    /** 触摸 点击屏幕 */
+    checkSelectedPano(raycaster: THREE.Raycaster): Pano | null;
+    /** 析构函数 */
+    destroy(): void;
+    /** 是否准备好，即不在用户操作中，并且不再动画中 */
+    isReady(): 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>;
+    /** 时间迭代 */
+    updateTime(time: number, deltaTime: number, ...args: any[]): void;
+    /** 生命周期 渲染 */
+    render(): boolean;
+    protected onPanGesture(): void;
+    protected onTapGesture(): void;
+    protected onPinchGesture(): void;
+    protected onMouseMove(): void;
+    protected onMouseOut(): void;
+    protected panoResourceFromLocationMotionKeyframe(keyframe: LocationMotion["keyframes"][number]): PanoResourceXR;
+    private updateControllerHelper;
+    private emitHandleEvent;
+    private initHandEvent;
+}
+export { XRPanoramaController, XRPanoramaControllerInitArgs, XRPanoramaControllerCustomInitArgs, defaultXRPanoramaControllerInitArgs, };

package/five/core/camera.d.ts

@@ -0,0 +1,65 @@
+import * as THREE from "three";
+import type { Mode } from "../application/mode";
+interface CameraPose {
+    longitude: number;
+    latitude: number;
+    fov: number;
+    distance: number;
+    offset: THREE.Vector3;
+}
+/** Five 相机 */
+declare class Camera extends THREE.Camera {
+    fov: number;
+    aspect: number;
+    near: number;
+    far: number;
+    perspToOrtho: THREE.Vector2;
+    resolution: THREE.Vector2;
+    pixelRatio: number;
+    /** 相机姿态 */
+    pose: CameraPose;
+    private perspectiveCamera;
+    private orthographicCamera;
+    autoNearFar: boolean;
+    needsRender: boolean;
+    refineModel: boolean;
+    time: number;
+    controllerMode: Mode | null;
+    private lastValues;
+    constructor(fov: number, aspect?: number, near?: number, far?: number, perspToOrtho?: THREE.Vector2, resolution?: THREE.Vector2, pixelRatio?: number);
+    get orthoDistance(): number;
+    get zoom(): number;
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+    getDirection(target: THREE.Vector3): THREE.Vector3;
+    /** 通过相机参数反算姿态 */
+    computePose(distance?: number): this;
+    /** 设置相机姿态 */
+    setFromPose(pose: Partial<CameraPose>): this;
+    /** 拷贝相机姿态 */
+    copyPose(): CameraPose;
+    private computeProjectionMatrix;
+    setViewOffset(fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number): void;
+    get view(): {
+        enabled: boolean;
+        fullWidth: number;
+        fullHeight: number;
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    clearViewOffset(): void;
+    updateProjectionMatrix(): void;
+    get perspectiveProjectionMatrix(): THREE.Matrix4;
+    get perspectiveProjectionMatrixInverse(): THREE.Matrix4;
+    get orthographicProjectionMatrix(): THREE.Matrix4;
+    get orthographicProjectionMatrixInverse(): THREE.Matrix4;
+    updateTime(time: number): void;
+    get isPerspectiveCamera(): boolean;
+    get isOrthographicCamera(): boolean;
+    copy(source: this, recursive?: boolean): this;
+}
+export { Camera, CameraPose };

package/five/core/internalWebGLRenderer.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+declare class InternalWebGLRenderer extends THREE.WebGLRenderer {
+    constructor({ preserveDrawingBuffer, premultipliedAlpha, stencil, antialias, webgl2, logarithmicDepthBuffer, precision, powerPreference, }: {
+        preserveDrawingBuffer?: boolean;
+        premultipliedAlpha?: boolean;
+        stencil?: boolean;
+        antialias?: boolean;
+        webgl2?: boolean;
+        logarithmicDepthBuffer?: boolean;
+        precision?: 'highp' | 'mediump' | 'lowp';
+        powerPreference?: 'high-performance' | 'low-power' | 'default';
+    });
+}
+export { InternalWebGLRenderer };

package/five/core/panoVideo.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from "three";
+interface PanoVideoProps {
+    size: THREE.Vector2;
+    matrix: THREE.Matrix4;
+    panoMatrix: THREE.Matrix4;
+    alpha: number;
+    map: THREE.Texture;
+}
+declare class PanoVideo {
+    private material;
+    object: THREE.Mesh<THREE.BufferGeometry, THREE.ShaderMaterial>;
+    private alphaMotion;
+    constructor();
+    setMaterial(value: PanoVideoProps | null): void;
+    updateTime(time: number): void;
+    dispose(): void;
+}
+export { PanoVideo };

package/five/core/scene.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+import { AddableObject } from "../types/addableObject";
+/** Five 场景*/
+declare class Scene extends THREE.Scene {
+    needsRender: boolean;
+    add(...objects: AddableObject[]): this;
+    remove(...objects: AddableObject[]): this;
+    update(renderer: THREE.WebGLRenderer, camera: THREE.Camera): boolean;
+}
+export { Scene };

package/five/core/tiling.d.ts

@@ -0,0 +1,43 @@
+import * as THREE from "three";
+import { WorkObserver } from "../work";
+import { ImageOptions } from "../types/imageOptions";
+export interface TilingFrameState {
+    time: number;
+    resolution: THREE.Vector2;
+    pixelRatio: number;
+    renderer: THREE.WebGLRenderer;
+    cameraMatrix: THREE.Matrix4;
+    cameraProjectionMatrix: THREE.Matrix4;
+    panoMap: THREE.CubeTexture | null;
+    panoMatrix: THREE.Matrix4;
+    panoZoom: number;
+    minLevel: number;
+    level: number;
+}
+export declare class Tiling {
+    private disposed;
+    fiveId: string;
+    level: number;
+    pedding: number;
+    maxRequest: number;
+    appearDuration: number;
+    maxCacheTile: number;
+    imageOptions: ImageOptions;
+    private boundingMesh;
+    private tileTree;
+    private tileMeshes;
+    private textureLoader;
+    observer: WorkObserver | null;
+    frustum: THREE.Frustum;
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    renderTarget: THREE.WebGLRenderTarget;
+    private forceRenderWhenNextUpdate;
+    constructor(options: {
+        fiveId: string;
+    });
+    dispose(): void;
+    cleanup(): void;
+    setObserver(observer: WorkObserver | null): void;
+    update(frameState: TilingFrameState): boolean;
+}

package/five/declare.d.ts

@@ -1,4 +1,5 @@
 import * as THREE from 'three';
+import type { Model, ViewLayer, Tile } from './model';
 
 declare module 'three' {
 
@@ -11,7 +12,7 @@ declare module 'three' {
     /**
      * 对焦点进行筛选
      */
-    hitFilter?: (intersect: THREE.Intersection) => boolean;
+    hitFilter?: (intersect: THREE.Intersection & { model?: Model; viewLayer?: ViewLayer; tile?: Tile; }) => boolean;
 
     /**
      * 是否由近及远排序， 默认 true

package/five/gaussian-splatting/util/renderData.d.ts

@@ -0,0 +1,52 @@
+import { PBMGaussianSplattingObject } from "../../model/objects/pbmGaussianSplattingObject";
+declare class RenderData {
+    dataChanged: boolean;
+    transformsChanged: boolean;
+    readonly generation: number;
+    splatIndices: Map<PBMGaussianSplattingObject, number>;
+    offsets: Map<PBMGaussianSplattingObject, number>;
+    data: Uint32Array;
+    width: number;
+    height: number;
+    transforms: Float32Array;
+    transformsWidth: number;
+    transformsHeight: number;
+    transformIndices: Uint32Array;
+    transformIndicesWidth: number;
+    transformIndicesHeight: number;
+    layerIndices: Uint32Array;
+    layerIndicesWidth: number;
+    layerIndicesHeight: number;
+    layerKeys: string[];
+    layerKeyToIndex: Map<string, number>;
+    objectLayerIndices: Map<PBMGaussianSplattingObject, number>;
+    positions: Float32Array;
+    rotations: Float32Array;
+    scales: Float32Array;
+    numPoints: number;
+    worker: Worker;
+    sh1?: Float32Array;
+    sh2?: Float32Array;
+    sh3?: Float32Array;
+    maxShDegree: number;
+    initialBuildComplete: boolean;
+    pendingInitialBuildCount: number;
+    readonly readyPromise: Promise<void>;
+    disposed: boolean;
+    private resolveReadyPromise;
+    private objectsInOrder;
+    static warmupWasm(): void;
+    constructor(pbmGSObjects: PBMGaussianSplattingObject[], generation?: number);
+    updateTransform(pbmGSObject: PBMGaussianSplattingObject): void;
+    getObjectsInOrder(): readonly PBMGaussianSplattingObject[];
+    canIncrementalAppend(nextObjects: PBMGaussianSplattingObject[]): boolean;
+    appendObjects(objectsToAppend: PBMGaussianSplattingObject[]): Promise<boolean>;
+    buildImmediate(wasmModule: any, splat: PBMGaussianSplattingObject): void;
+    private expandFloat32Array;
+    private expandUint32Array;
+    getSplat(index: number): any;
+    getLocalIndex(splat: PBMGaussianSplattingObject, index: number): number;
+    dispose(): void;
+    private completeInitialBuild;
+}
+export { RenderData };

package/five/gaussian-splatting/wasm/data.d.ts

@@ -0,0 +1,20 @@
+interface WasmModule {
+    _malloc(size: number): number;
+    _free(ptr: number): void;
+    _pack(
+        selected: boolean,
+        vertexCount: number,
+        positions: number,
+        rotations: number,
+        scales: number,
+        colors: number,
+        selection: number,
+        data: number,
+        worldPositions: number,
+        worldRotations: number,
+        worldScales: number,
+    ): void;
+}
+
+declare const loadWasm: () => Promise<WasmModule>;
+export default loadWasm;

package/five/gaussian-splatting/wasm/sort.d.ts

@@ -0,0 +1,18 @@
+interface WasmModule {
+    _malloc(size: number): number;
+    _free(ptr: number): void;
+    _sort(
+        viewProj: number,
+        transforms: number,
+        transformIndices: number,
+        vertexCount: number,
+        positions: number,
+        depthBuffer: number,
+        depthIndex: number,
+        starts: number,
+        counts: number,
+    ): void;
+}
+
+declare const loadWasm: () => Promise<WasmModule>;
+export default loadWasm;

package/five/gaussian-splatting/worker/dataWorker.d.ts

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

package/five/gaussian-splatting/worker/sortWorker.d.ts

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