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

package/five/model/materials/pbmPointCloudMaterial.d.ts

@@ -0,0 +1,70 @@
+import * as THREE from 'three';
+import { PBMMaterial, PBMPointCloudShaderType, PBMClipperParameter, PBMCustomShader, PBMPointSize, PBMPointShape, PBMPointBack, PBMColorStyle, PBMFloorStyle } from "./pbmMaterial";
+export interface PBMPointCloudMaterialParameters extends THREE.MaterialParameters {
+    vertexMarks?: boolean;
+    pointScale?: number;
+    pointMinPixel?: number;
+    pointMaxPixel?: number;
+    pointSize?: PBMPointSize;
+    pointShape?: PBMPointShape;
+    pointBack?: PBMPointBack;
+    modelAlpha?: number;
+    colorStyle?: PBMColorStyle;
+    constantColor?: THREE.Vector3;
+    floorIndex?: number;
+    shownFloorIndex?: number;
+    floorStyle?: PBMFloorStyle;
+    gradientTexture?: THREE.Texture | null;
+    brightness?: number;
+    colorSaturation?: number;
+    colorBrightness?: number;
+    outlineGain?: number;
+    distanceGain?: number;
+    useHQWeight?: boolean;
+    useHQDepth?: boolean;
+    modelBoundingMin?: THREE.Vector3;
+    modelBoundingMax?: THREE.Vector3;
+    clippers?: PBMClipperParameter[];
+    customShaders?: PBMCustomShader[];
+}
+declare class PBMPointCloudMaterial extends PBMMaterial {
+    readonly isPBMPointCloudMaterial: true;
+    readonly isShaderMaterial: true;
+    readonly shaderType: PBMPointCloudShaderType;
+    vertexMarks: boolean;
+    pointScale: number;
+    pointMinPixel: number;
+    pointMaxPixel: number;
+    pointSize: PBMPointSize;
+    pointShape: PBMPointShape;
+    pointBack: PBMPointBack;
+    modelAlpha: number;
+    colorStyle: PBMColorStyle;
+    constantColor: THREE.Vector3;
+    floorIndex: number;
+    shownFloorIndex: number;
+    floorStyle: PBMFloorStyle;
+    gradientTexture: THREE.Texture | null;
+    brightness: number;
+    colorSaturation: number;
+    colorBrightness: number;
+    outlineGain: number;
+    distanceGain: number;
+    useHQWeight: boolean;
+    useHQDepth: boolean;
+    modelBoundingMin: THREE.Vector3;
+    modelBoundingMax: THREE.Vector3;
+    clipping: boolean;
+    clippers: readonly PBMClipperParameter[];
+    customShaders: readonly PBMCustomShader[];
+    onBeforeRender?: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry | THREE.Geometry, object: THREE.Object3D, group: THREE.Group) => void;
+    constructor(parameters?: PBMPointCloudMaterialParameters);
+    copy(source: PBMPointCloudMaterial): this;
+    clone(): this;
+    /**
+     * @deprecated
+     * 已经不需要再被调用了
+     */
+    refreshUniforms(): void;
+}
+export { PBMPointCloudMaterial };

package/five/model/model-scene.d.ts

@@ -0,0 +1,172 @@
+import * as THREE from 'three';
+import { Parameter, ParameterValue } from './parameter';
+import { Model } from './model';
+import { type ViewLayer } from './view-layer';
+import { type ParameterTilesetValue } from './parameter';
+import { type TextureOptions } from "../types/imageOptions";
+import { type Works } from '../work';
+import { type Camera } from '../core/camera';
+import { type Intersection } from './intersection';
+import { type BoundingVolume, type BoundingVolumeJson } from '../utils/volume';
+import { BoundingMesh } from "../meshes/boundingMesh";
+export interface ModelOptions {
+    /** 模型是否感光 */
+    light?: boolean;
+    /** 模型 3d-tile 参数 */
+    "3d-tiles"?: (Partial<ParameterTilesetValue> & {
+        viewerRequestVolume?: BoundingVolume | BoundingVolumeJson;
+        showLayers?: boolean | string[];
+    }) | ((viewLayer: ViewLayer, model: Model) => void | (Partial<ParameterTilesetValue> & {
+        viewerRequestVolume?: BoundingVolume | BoundingVolumeJson;
+        showLayers?: boolean | string[];
+    }));
+    /**
+     * 模型贴图的配置参数
+     * @description
+     * 可以动态对配置在 `work` 数据中的模型贴图在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
+     */
+    textureOptions?: TextureOptions;
+    /** 强制显示模型，不等待加载完 */
+    forceReplaceImmediately?: boolean;
+}
+export type Models = Model[] & {
+    /**
+     * @deprecated
+     * use `modelScene.autoRefine` instead
+     */
+    autoUpdate: boolean;
+    /**
+     * @deprecated
+     * use `modelScene.boundingBox` instead
+     */
+    bounding: THREE.Box3;
+    /**
+     * @deprecated
+     * use `modelScene.loaded` instead
+     */
+    loaded: boolean;
+    /**
+     * @deprecated
+     * use `modelScene.refined` instead
+     */
+    refined: boolean;
+    /**
+     * @deprecated
+     * use `modelScene.refineProgress` instead
+     */
+    refineProgress: [number, number];
+    /**
+     * @deprecated
+     * use `modelScene.parameter.cacheCameras` `modelScene.parameter.set('cacheCameras', cacheCameras)` instead
+     */
+    cacheCameras: readonly (THREE.PerspectiveCamera | Camera)[];
+    /**
+     * @deprecated
+     * use `modelScene.intersectRaycaster` instead
+     */
+    intersectRaycaster(raycaster: THREE.Raycaster): Intersection[];
+    /**
+     * @deprecated
+     * Use `.parameter.set` instead
+     */
+    setMaterial(values: Partial<ParameterValue>): void;
+    /**
+     * @deprecated
+     * Use `.parameter.get` instead
+     */
+    getMaterial(): ParameterValue;
+    /**
+     * @deprecated
+     * Use `.parameter.reset('brightness')` instead
+     */
+    resetBrightness(): void;
+};
+export interface ModelScene {
+    dispatchEvent(event: {
+        type: 'model.create';
+        model: Model;
+    }): void;
+    dispatchEvent(event: {
+        type: 'model.dispose';
+        model: Model;
+    }): void;
+    dispatchEvent(event: {
+        type: string;
+        [attachment: string]: any;
+    }): void;
+    addEventListener(type: 'model.create', listener: (event: THREE.Event & {
+        type: 'model.create';
+        model: Model;
+    }) => void): void;
+    addEventListener(type: 'model.dispose', listener: (event: THREE.Event & {
+        type: 'model.dispose';
+        model: Model;
+    }) => void): void;
+    addEventListener(type: string, listener: (event: THREE.Event) => void): void;
+    removeEventListener(type: 'model.create', listener: (event: THREE.Event & {
+        type: 'model.create';
+        model: Model;
+    }) => void): void;
+    removeEventListener(type: 'model.dispose', listener: (event: THREE.Event & {
+        type: 'model.dispose';
+        model: Model;
+    }) => void): void;
+    removeEventListener(type: string, listener: (event: THREE.Event) => void): void;
+}
+export declare class ModelScene extends THREE.Scene {
+    fiveId: string;
+    needsRender: boolean;
+    /** 自动细化 */
+    autoRefine: boolean;
+    /** 包围盒 */
+    boundingBox: THREE.Box3;
+    /** 包围盒 Mesh */
+    boundingMesh: BoundingMesh;
+    /** 加载完成 */
+    loaded: boolean;
+    /** 细化完成 */
+    refined: boolean;
+    /** 细化进度 */
+    refineProgress: [number, number];
+    /** 参数 */
+    parameter: Parameter;
+    /** 模型列表 */
+    readonly models: Models;
+    private readonly shownModels;
+    private updateModelMap;
+    constructor(options: {
+        fiveId: string;
+    });
+    setModels(works: Works, options: ModelOptions): Model[];
+    get empty(): boolean;
+    /**
+     * 计算模型射线碰撞检测
+     * @param raycaster - THREE 射线对象
+     * @param target - 返回碰撞点
+     * @returns 返回碰撞点
+     */
+    intersectRaycaster(raycaster: THREE.Raycaster, target?: Intersection[]): Intersection[];
+    update(renderer: THREE.WebGLRenderer, camera: Camera): boolean;
+    /**
+     * @deprecated
+     * Use `.boundingBox` instead
+     */
+    get bounding(): THREE.Box3;
+    /**
+     * @deprecated
+     * Use `.parameter.set` instead
+     */
+    setMaterial(parameter: Partial<ParameterValue>): void;
+    /**
+     * @deprecated
+     * Use `.parameter.get` instead
+     */
+    getMaterial(): ParameterValue;
+    /**
+     * @deprecated
+     * Use `.parameter.reset('brightness')` instead
+     */
+    resetBrightness(): void;
+    dispose(): void;
+}

package/five/model/model.d.ts

@@ -0,0 +1,209 @@
+import * as THREE from "three";
+import { type ViewLayer } from './view-layer';
+import { type Work } from "../work";
+import { type TextureOptions } from "../types/imageOptions";
+import { type Intersection } from "./intersection";
+import { type Camera } from "../core/camera";
+import { Parameter, type ParameterValue } from './parameter';
+import { type ModelScene } from './model-scene';
+import { type Tile } from './tile3d/tile';
+export interface Model {
+    dispatchEvent(event: {
+        type: 'error';
+        error: Error;
+    }): void;
+    dispatchEvent(event: {
+        type: 'load';
+    }): void;
+    dispatchEvent(event: {
+        type: 'dispose';
+    }): void;
+    dispatchEvent(event: {
+        type: 'changeShownFloor';
+        floorIndex: number | null;
+    }): void;
+    dispatchEvent(event: {
+        type: 'tileLoad';
+        tile: Tile;
+    }): void;
+    dispatchEvent(event: {
+        type: 'tileUnload';
+        tile: Tile;
+    }): void;
+    dispatchEvent(event: {
+        type: string;
+        [attachment: string]: any;
+    }): void;
+    addEventListener(type: 'error', listener: (event: THREE.Event & {
+        type: 'error';
+        error: Error;
+    }) => void): void;
+    addEventListener(type: 'load', listener: (event: THREE.Event & {
+        type: 'load';
+    }) => void): void;
+    addEventListener(type: 'dispose', listener: (event: THREE.Event & {
+        type: 'dispose';
+    }) => void): void;
+    addEventListener(type: 'changeShownFloor', listener: (event: THREE.Event & {
+        type: 'changeShownFloor';
+        floorIndex: number | null;
+    }) => void): void;
+    addEventListener(type: 'tileLoad', listener: (event: THREE.Event & {
+        type: 'tileLoad';
+        tile: Tile;
+    }) => void): void;
+    addEventListener(type: 'tileUnload', listener: (event: THREE.Event & {
+        type: 'tileUnload';
+        tile: Tile;
+    }) => void): void;
+    addEventListener(type: string, listener: (event: THREE.Event) => void): void;
+    removeEventListener(type: 'error', listener: (event: THREE.Event & {
+        type: 'error';
+        error: Error;
+    }) => void): void;
+    removeEventListener(type: 'load', listener: (event: THREE.Event & {
+        type: 'load';
+    }) => void): void;
+    removeEventListener(type: 'dispose', listener: (event: THREE.Event & {
+        type: 'dispose';
+    }) => void): void;
+    removeEventListener(type: 'changeShownFloor', listener: (event: THREE.Event & {
+        type: 'changeShownFloor';
+        floorIndex: number | null;
+    }) => void): void;
+    removeEventListener(type: 'tileLoad', listener: (event: THREE.Event & {
+        type: 'tileLoad';
+        tile: Tile;
+    }) => void): void;
+    removeEventListener(type: 'tileUnload', listener: (event: THREE.Event & {
+        type: 'tileUnload';
+        tile: Tile;
+    }) => void): void;
+    removeEventListener(type: string, listener: (event: THREE.Event) => void): void;
+}
+/**
+ * Five 模型
+ * @description
+ * 通过 work 数据加载, 适配 at3d、pbm、dome、domez 格式的文件
+ * 可以通过 jsonp 解析 base64 的 dataURL 内容，
+ * 需要满足 your/path/filename.at3d.json_xxxxxx,
+ * 通过 json_xxxxxx(<dataURL>) 方式返回。
+ */
+export declare class Model extends THREE.Object3D {
+    fiveId: string;
+    parent: ModelScene | null;
+    needsRender: boolean;
+    children: ViewLayer[];
+    add: (...object: ViewLayer[]) => this;
+    private disposed;
+    parameter: Parameter;
+    /** work */
+    work: Work;
+    /** 是否过期 */
+    outdated: boolean;
+    /** 是否自动细化 */
+    autoRefine: boolean;
+    /** 是否在加载元信息 */
+    metaPending: boolean;
+    /** 模型已经加载 */
+    loaded: boolean;
+    /** 模型是否已经细化 */
+    refined: boolean;
+    /** 模型细化进度 */
+    refineProgress: [number, number];
+    /** 初始化完成 */
+    initReady: Promise<Model>;
+    /** 初次加载完成 */
+    loadedReady: Promise<Model>;
+    /** 外接盒子的大小 */
+    boundingBox: THREE.Box3;
+    /** 所有楼层 */
+    floorLength: number;
+    constructor(fiveId: string, work: Work, options?: {
+        light?: boolean;
+        textureOptions?: TextureOptions;
+    });
+    /** 析构函数 一旦析构，则不能使用 */
+    dispose(): void;
+    /** 模型内容是否为空 */
+    get empty(): boolean;
+    /** 模型的不同图层 */
+    get viewLayers(): ViewLayer[];
+    /**
+     * 获取模型边界线
+     * @param sphere - 获取区域
+     * @param threshold - 面片间夹角阈值
+     * @returns 所有模型边界线
+     */
+    getEdgesBySphere(sphere: THREE.Sphere, threshold?: number): THREE.Line3[];
+    /**
+     * 计算模型射线碰撞检测
+     * @param raycaster - THREE 射线对象
+     * @param target - 返回碰撞
+     * @returns 返回碰撞
+     */
+    intersectRaycaster(raycaster: THREE.Raycaster, target?: Intersection[]): Intersection[];
+    update(renderer: THREE.WebGLRenderer, camera: Camera, modelScene: ModelScene): boolean;
+    localToEnu(vector: THREE.Vector3): THREE.Vector3;
+    enuToLocal(vector: THREE.Vector3): THREE.Vector3;
+    worldToEnu(vector: THREE.Vector3): THREE.Vector3;
+    enuToWorld(vector: THREE.Vector3): THREE.Vector3;
+    /**
+     * 当前显示的楼层
+     */
+    get shownFloor(): number | null;
+    set shownFloor(floor: number | null);
+    /**
+     * 显示某楼层
+     * @example
+     * ```
+     * model.show() //显示全部楼层
+     * model.show(1) //显示第一楼层
+     * ```
+     */
+    show(floor?: number | null): void;
+    /**
+     * @deprecated
+     * Use `.boundingBox` instead
+     */
+    get bounding(): THREE.Box3;
+    /**
+     * @deprecated
+     * Use `.parameter.set` instead
+     */
+    setMaterial(parameter: Partial<ParameterValue>): void;
+    /**
+     * @deprecated
+     * Use `.parameter.get` instead
+     */
+    getMaterial(): ParameterValue;
+    /**
+     * @deprecated
+     * Use `.parameter.shownFloorIndex` `.parameter.set('brightness', brightness)` instead
+     */
+    get shownFloorIndex(): ParameterValue['shownFloorIndex'];
+    set shownFloorIndex(floorIndex: ParameterValue['shownFloorIndex']);
+    /**
+     * @deprecated
+     * Use `.parameter.brightness` `.parameter.set('brightness', brightness)` instead
+     */
+    get brightness(): ParameterValue['brightness'];
+    set brightness(brightness: ParameterValue['brightness']);
+    /**
+     * @deprecated
+     * Use `.parameter.clippers` `.parameter.set('clippers', clippers)` instead
+     */
+    get clippers(): ParameterValue['clippers'];
+    set clippers(clippers: ParameterValue['clippers']);
+    /**
+     * @deprecated
+     * Use `.parameter.customShaders` `.parameter.set('customShaders', customShaders)` instead
+     */
+    get customShaders(): ParameterValue['customShaders'];
+    set customShaders(customShaders: ParameterValue['customShaders']);
+    /**
+     * @deprecated
+     * Use `.parameter.reset('brightness')` instead
+     */
+    resetBrightness(): void;
+}

package/five/model/objects/pbmContainer.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from "three";
+import { Parameter, ParameterValue } from "../parameter";
+/**
+ * PBM 模型组
+ * @deprecated 弃用, 直接使用 THREE.Group
+ */
+declare class PBMContainer extends THREE.Group {
+    /** 当前样式参数 */
+    parameter: Parameter;
+    /** 是否需要更新按需渲染 */
+    needsRender: boolean;
+    /**
+     *  更新版本
+     *  @deprecated
+     *  use this.parameter.resolveValue()
+     */
+    get materialParameters(): ParameterValue;
+    /**
+     *  更新版本
+     *  @deprecated
+     *  use this.parameter.resolveValue().versions instead
+     */
+    get pbmMaterialParametersVersion(): string;
+    setMaterial(value: Partial<ParameterValue>): void;
+    getMaterial(): ParameterValue;
+    update(): void;
+}
+export { PBMContainer };

package/five/model/objects/pbmGaussianSplattingObject.d.ts

@@ -0,0 +1,43 @@
+import * as THREE from "three";
+import type { PBMClipperParameter } from "../materials/pbmMaterial";
+export interface SplatData {
+    numPoints: number;
+    positions: Float32Array;
+    colors: Uint8Array;
+    scales: Float32Array;
+    rotations: Float32Array;
+    sh1?: Float32Array;
+    sh2?: Float32Array;
+    sh3?: Float32Array;
+    shDegree?: number;
+}
+export declare class PBMGaussianSplattingObject extends THREE.Points<THREE.BufferGeometry, THREE.ShaderMaterial> {
+    static RowLength: number;
+    transformChanged: boolean;
+    selectedChanged: boolean;
+    transferDetached: boolean;
+    numPoints: number;
+    maxSHDegree: number;
+    usedSHDegree: number;
+    gsViewLayerKey: string;
+    gsClippers: readonly PBMClipperParameter[];
+    private _selected;
+    private _boundingBox;
+    lastMatrixWorld: THREE.Matrix4 | null;
+    get positions(): Float32Array;
+    get rotations(): Float32Array;
+    get scales(): Float32Array;
+    get colors(): Uint8Array;
+    get selection(): Uint8Array;
+    get sh1(): Float32Array | undefined;
+    get sh2(): Float32Array | undefined;
+    get sh3(): Float32Array | undefined;
+    constructor(splatData?: SplatData);
+    serialize(): Uint8Array<ArrayBuffer>;
+    reattach(positions: ArrayBufferLike, rotations: ArrayBufferLike, scales: ArrayBufferLike, colors: ArrayBufferLike, selection: ArrayBufferLike): void;
+    get selected(): boolean;
+    set selected(selected: boolean);
+    get boundingBox(): THREE.Box3;
+    dispose(): void;
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}

package/five/model/objects/pbmGaussianSplattingRenderMesh.d.ts

@@ -0,0 +1,55 @@
+import * as THREE from 'three';
+import { RenderData } from '../../gaussian-splatting/util/renderData';
+declare class PBMGaussianSplattingRenderMesh extends THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial> {
+    private gsSceneState;
+    renderData: RenderData | null;
+    needsRender: boolean;
+    private sortWorker;
+    private depthIndex;
+    private splatIndexCapacity;
+    private activeSlot;
+    private pendingSlot;
+    private rebuildGeneration;
+    private forceClipperUniformRefresh;
+    private incrementalUpdateInFlight;
+    private dataTexture;
+    private transformsTexture;
+    private transformIndicesTexture;
+    private layerIndicesTexture;
+    private shTexture;
+    private usedSHDegree;
+    constructor();
+    private ensureSplatIndexCapacity;
+    private getExpandedCapacity;
+    private createGeometry;
+    private createMaterial;
+    private createDefaultLayerClipperRanges;
+    private createDefaultClipperMatrices;
+    private createTextures;
+    private createSHTexture;
+    /**
+     * 设置球谐阶数
+     * @param degree SH 阶数 (0, 1, 或 2)，0 表示禁用 SH
+     */
+    private setMaxShDegree;
+    private bindSlotTextures;
+    private disposeSlot;
+    private disposeTextures;
+    private applyDepthIndex;
+    private swapPendingToActive;
+    private createSlot;
+    private updateSlotTextures;
+    private postSortData;
+    private requestSort;
+    private syncTransformsForSlot;
+    private collectObjects;
+    private isSceneNeedsRebuild;
+    private getClipperHash;
+    private updateClipperCounts;
+    private updateClipperUniforms;
+    private startPendingRebuild;
+    private tryStartIncrementalUpdate;
+    onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera) => void;
+    dispose(): void;
+}
+export { PBMGaussianSplattingRenderMesh };

package/five/model/objects/pbmGaussianSplattingTestMesh.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from 'three';
+declare class PBMGaussianSplattingTestMesh extends THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial> {
+    constructor();
+    private collectObjects;
+    onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera) => void;
+}
+export { PBMGaussianSplattingTestMesh };

package/five/model/objects/pbmGroup.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from "three";
+/**
+ * PBM 模型组
+ * @deprecated 弃用, 直接使用 THREE.Group
+ */
+declare class PBMGroup extends THREE.Group {
+}
+export { PBMGroup };

package/five/model/objects/pbmMesh.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+import { PBMMeshMaterial } from "../materials/pbmMeshMaterial";
+export declare class PBMMesh extends THREE.Mesh<THREE.BufferGeometry, PBMMeshMaterial[]> {
+    constructor(geometry: THREE.BufferGeometry, materials: PBMMeshMaterial[]);
+}
+export declare class PBMSkinnedMesh extends THREE.SkinnedMesh<THREE.BufferGeometry, PBMMeshMaterial[]> {
+    geometry: THREE.BufferGeometry;
+    material: PBMMeshMaterial[];
+    constructor(geometry: THREE.BufferGeometry, materials: PBMMeshMaterial[], useVertexTexture?: boolean);
+}

package/five/model/objects/pbmPointCloud.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from "three";
+import { PBMPointCloudMaterial } from '../materials/pbmPointCloudMaterial';
+/** PBM 对象 */
+declare class PBMPointCloud extends THREE.Points<THREE.BufferGeometry, PBMPointCloudMaterial> {
+    constructor(geometry: THREE.BufferGeometry, materials: PBMPointCloudMaterial);
+}
+export { PBMPointCloud };