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

package/five/model/loaders/protobuf/pbm.d.ts

@@ -0,0 +1,203 @@
+import * as $protobuf from "protobufjs";
+import Long = require("long");
+/** Properties of a Model. */
+export interface IModel {
+
+    /** Model chunks */
+    chunks?: (IChunk[]|null);
+
+    /** Model createAt */
+    createAt?: (number|null);
+
+    /** Model description */
+    description?: (string|null);
+}
+
+/** Represents a Model. */
+export class Model implements IModel {
+
+    /**
+     * Constructs a new Model.
+     * @param [properties] Properties to set
+     */
+    constructor(properties?: IModel);
+
+    /** Model chunks. */
+    public chunks: IChunk[];
+
+    /** Model createAt. */
+    public createAt: number;
+
+    /** Model description. */
+    public description: string;
+
+    /**
+     * Decodes a Model message from the specified reader or buffer.
+     * @param reader Reader or buffer to decode from
+     * @param [length] Message length if known beforehand
+     * @returns Model
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Model;
+
+    /**
+     * Gets the default type url for Model
+     * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns The default type url
+     */
+    public static getTypeUrl(typeUrlPrefix?: string): string;
+}
+
+/** Properties of a Chunk. */
+export interface IChunk {
+
+    /** Chunk vertices */
+    vertices: IVertices;
+
+    /** Chunk faces */
+    faces: IFaces;
+
+    /** Chunk name */
+    name: string;
+
+    /** Chunk texture */
+    texture?: (string|null);
+}
+
+/** Represents a Chunk. */
+export class Chunk implements IChunk {
+
+    /**
+     * Constructs a new Chunk.
+     * @param [properties] Properties to set
+     */
+    constructor(properties?: IChunk);
+
+    /** Chunk vertices. */
+    public vertices: IVertices;
+
+    /** Chunk faces. */
+    public faces: IFaces;
+
+    /** Chunk name. */
+    public name: string;
+
+    /** Chunk texture. */
+    public texture: string;
+
+    /**
+     * Decodes a Chunk message from the specified reader or buffer.
+     * @param reader Reader or buffer to decode from
+     * @param [length] Message length if known beforehand
+     * @returns Chunk
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Chunk;
+
+    /**
+     * Gets the default type url for Chunk
+     * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns The default type url
+     */
+    public static getTypeUrl(typeUrlPrefix?: string): string;
+}
+
+/** Properties of a Vertices. */
+export interface IVertices {
+
+    /** Vertices xyz */
+    xyz?: (number[]|null);
+
+    /** Vertices uvs */
+    uvs?: (number[]|null);
+
+    /** Vertices marks */
+    marks?: (VertexMark[]|null);
+}
+
+/** Represents a Vertices. */
+export class Vertices implements IVertices {
+
+    /**
+     * Constructs a new Vertices.
+     * @param [properties] Properties to set
+     */
+    constructor(properties?: IVertices);
+
+    /** Vertices xyz. */
+    public xyz: number[];
+
+    /** Vertices uvs. */
+    public uvs: number[];
+
+    /** Vertices marks. */
+    public marks: VertexMark[];
+
+    /**
+     * Decodes a Vertices message from the specified reader or buffer.
+     * @param reader Reader or buffer to decode from
+     * @param [length] Message length if known beforehand
+     * @returns Vertices
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Vertices;
+
+    /**
+     * Gets the default type url for Vertices
+     * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns The default type url
+     */
+    public static getTypeUrl(typeUrlPrefix?: string): string;
+}
+
+/** Properties of a Faces. */
+export interface IFaces {
+
+    /** Faces indices */
+    indices?: (number[]|null);
+
+    /** Faces normals */
+    normals?: (number[]|null);
+}
+
+/** Represents a Faces. */
+export class Faces implements IFaces {
+
+    /**
+     * Constructs a new Faces.
+     * @param [properties] Properties to set
+     */
+    constructor(properties?: IFaces);
+
+    /** Faces indices. */
+    public indices: number[];
+
+    /** Faces normals. */
+    public normals: number[];
+
+    /**
+     * Decodes a Faces message from the specified reader or buffer.
+     * @param reader Reader or buffer to decode from
+     * @param [length] Message length if known beforehand
+     * @returns Faces
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Faces;
+
+    /**
+     * Gets the default type url for Faces
+     * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns The default type url
+     */
+    public static getTypeUrl(typeUrlPrefix?: string): string;
+}
+
+/** VertexMark enum. */
+export enum VertexMark {
+    VERTEX_MARK_UNSPECIFIED = 0,
+    VERTEX_MARK_ROOF = 1
+}

package/five/model/loaders/shared.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from 'three';
+export type LoadResultType<Scene = THREE.Object3D> = {
+    type: 'unknown' | 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'gltf' | 'ply' | 'obj' | 'fbx' | 'x3p' | 'spz' | 'splat';
+    modelUpAxis: 'Y' | 'Z';
+    upAxis: 'Y' | 'Z';
+    byteLength: number;
+    memoryUsage: number;
+    uri: string;
+    scene: Scene;
+    textures: THREE.Texture[];
+    animations: THREE.AnimationClip[];
+    rtcCenter?: THREE.Vector3;
+    dispose: () => void;
+};
+export declare const ROTATE_X_MATRIX: THREE.Matrix4;
+export declare const ROTATE_X_MATRIX_INVERSE: THREE.Matrix4;

package/five/model/loaders/splat.d.ts

@@ -0,0 +1,8 @@
+import { Fetcher } from "../../utils/ajax";
+import { LoadResultType } from './shared';
+export declare function loadSplat(url: string, options?: {
+    modelUpAxis?: 'Y' | 'Z';
+    upAxis?: 'Y' | 'Z';
+    fetcher?: Fetcher;
+    onDownloadProgress?: (percent: number, loaded?: number, total?: number) => void;
+}): Promise<LoadResultType>;

package/five/model/loaders/spz.d.ts

@@ -0,0 +1,14 @@
+import { Fetcher } from "../../utils/ajax";
+import { PBMGSObject } from '../objects/pbmGSObject';
+import { LoadResultType } from './shared';
+/**
+ * 加载spz格式的数据
+ * @returns Promise<PBMGSObject>
+ */
+export declare function parseSpz(fileBytes: Uint8Array | ArrayBuffer): Promise<PBMGSObject>;
+export declare function loadSpz(url: string, options?: {
+    modelUpAxis?: 'Y' | 'Z';
+    upAxis?: 'Y' | 'Z';
+    fetcher?: Fetcher;
+    onDownloadProgress?: (percent: number, loaded?: number, total?: number) => void;
+}): Promise<LoadResultType>;

package/five/model/loaders/tile3d-helpers/feature-table.d.ts

@@ -0,0 +1,15 @@
+import { GL_TYPE, TypedArray } from './gl-type';
+export declare class FeatureTable {
+    json: Record<string, any>;
+    buffer: Uint8Array;
+    featuresLength: number;
+    private cachedTypedArrays;
+    constructor(featureTableJson: Record<string, any>, featureTableBinary: Uint8Array);
+    getExtension(extensionName: string): any;
+    hasProperty(propertyName: string): boolean;
+    getGlobalProperty<T extends GL_TYPE>(propertyName: string, componentType: T, componentLength: number): TypedArray<T> | null;
+    getPropertyArray<T extends GL_TYPE>(propertyName: string, componentType: T, componentLength: number): TypedArray<T>;
+    getProperty<T extends GL_TYPE>(propertyName: string, componentType: T, componentLength: number, featureId: number, result: TypedArray<T>): TypedArray<T> | null;
+    private getTypedArrayFromBinary;
+    private getTypedArrayFromArray;
+}

package/five/model/loaders/tile3d-helpers/gl-type.d.ts

@@ -0,0 +1,20 @@
+export declare enum GL_TYPE {
+    BYTE = 5120,
+    UNSIGNED_BYTE = 5121,
+    SHORT = 5122,
+    UNSIGNED_SHORT = 5123,
+    INT = 5124,
+    UNSIGNED_INT = 5125,
+    FLOAT = 5126,
+    DOUBLE = 5130
+}
+export type AnyTypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
+export type TypedArray<T extends GL_TYPE> = T extends GL_TYPE.DOUBLE ? Float64Array : T extends GL_TYPE.FLOAT ? Float32Array : T extends GL_TYPE.UNSIGNED_SHORT ? Uint16Array : T extends GL_TYPE.UNSIGNED_INT ? Uint32Array : T extends GL_TYPE.UNSIGNED_BYTE ? Uint8Array : T extends GL_TYPE.BYTE ? Int8Array : T extends GL_TYPE.SHORT ? Int16Array : T extends GL_TYPE.INT ? Int32Array : never;
+export type TypedArrayConstructor<T extends GL_TYPE> = T extends GL_TYPE.DOUBLE ? typeof Float64Array : T extends GL_TYPE.FLOAT ? typeof Float32Array : T extends GL_TYPE.UNSIGNED_SHORT ? typeof Uint16Array : T extends GL_TYPE.UNSIGNED_INT ? typeof Uint32Array : T extends GL_TYPE.UNSIGNED_BYTE ? typeof Uint8Array : T extends GL_TYPE.BYTE ? typeof Int8Array : T extends GL_TYPE.SHORT ? typeof Int16Array : T extends GL_TYPE.INT ? typeof Int32Array : never;
+export declare const GL_TYPE_TO_ARRAY_TYPE: {
+    [key in GL_TYPE]: TypedArrayConstructor<key>;
+};
+export declare function getArrayType<T extends GL_TYPE>(glType: T): TypedArrayConstructor<T>;
+export declare function getByteSize(glType: number): number;
+export declare function createTypedArray<T extends GL_TYPE>(glType: T, buffer: ArrayBuffer, byteOffset?: number, length?: number): TypedArray<T>;
+export declare function glTypeFromName(name: string): GL_TYPE;

package/five/model/loaders/tile3d-helpers/parse-gltf-array-buffer.d.ts

@@ -0,0 +1,2 @@
+import { Tile3DB3dmData } from './tile3d-type';
+export declare function parseGlTFArrayBuffer(data: Tile3DB3dmData, arrayBuffer: ArrayBuffer, byteOffset: number): number;

package/five/model/loaders/tile3d-helpers/parse-header.d.ts

@@ -0,0 +1,2 @@
+import { Tile3DContentData } from './tile3d-type';
+export declare function parseHeader(data: Tile3DContentData, arrayBuffer: ArrayBuffer, byteOffset: number): number;

package/five/model/loaders/tile3d-helpers/parse-point-cloud-attributes.d.ts

@@ -0,0 +1,2 @@
+import { type Tile3DPntsData } from './tile3d-type';
+export declare function parsePointCloud(data: Tile3DPntsData, _arrayBuffer: ArrayBuffer, byteOffset: number): Promise<number>;

package/five/model/loaders/tile3d-helpers/parse-point-cloud-attributes.worker.d.ts

@@ -0,0 +1,6 @@
+import { WorkerType } from '../../../utils/worker';
+import type { Tile3DPntsDataAttributes } from './tile3d-type';
+export type AttrbuteWorkType = WorkerType<{
+    featureTableJson: Record<string, any>;
+    featureTableBinary: Uint8Array;
+}, Tile3DPntsDataAttributes>;

package/five/model/loaders/tile3d-helpers/parse-table.d.ts

@@ -0,0 +1,3 @@
+import { Tile3DContentData } from './tile3d-type';
+export declare function getStringFromArrayBuffer(arrayBuffer: ArrayBuffer, byteOffset: number, byteLength: number): string;
+export declare function parseTable(data: Tile3DContentData, arrayBuffer: ArrayBuffer, byteOffset: number): number;

package/five/model/loaders/tile3d-helpers/tile3d-type.d.ts

@@ -0,0 +1,35 @@
+export interface Tile3DContentData {
+    type: string;
+    uri: string;
+    version: number;
+    magic: number;
+    byteLength: number;
+    header: {
+        featureTableJsonByteLength: number;
+        featureTableBinaryByteLength: number;
+        batchTableJsonByteLength: number;
+        batchTableBinaryByteLength: number;
+        batchLength: number;
+    };
+    featureTableJson: Record<string, any>;
+    featureTableBinary: Uint8Array;
+    batchTableJson: Record<string, any>;
+    batchTableBinary: Uint8Array;
+    rtcCenter?: [number, number, number];
+}
+export interface Tile3DB3dmData extends Tile3DContentData {
+    gltfArrayBuffer: ArrayBuffer;
+}
+export interface Tile3DPntsData extends Tile3DContentData {
+    attributes: Tile3DPntsDataAttributes;
+}
+export interface Tile3DPntsDataAttributes {
+    position: Attribute | null;
+    color: Attribute | null;
+    normal: Attribute | null;
+}
+export interface Attribute<T extends ArrayLike<number> = ArrayLike<number>> {
+    array: T;
+    itemSize: number;
+    normalized: boolean;
+}

package/five/model/loaders/x3p.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from "three";
+import { LoadResultType } from './shared';
+import { Fetcher } from "../../utils/ajax";
+import { PBMMesh } from "../objects/pbmMesh";
+export declare function loadX3p(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
+    color?: THREE.Color;
+    light?: boolean;
+    fetcher?: Fetcher;
+    onDownloadProgress?: (percent: number, loaded?: number, total?: number) => void;
+}): Promise<LoadResultType>;
+declare function parse(arrayBuffer: Uint8Array, options: {
+    light?: boolean;
+    color?: THREE.Color;
+    resourcePath?: string;
+    search?: string;
+    fetcher: Fetcher;
+}): {
+    object: PBMMesh;
+    dispose: () => void;
+};
+export { parse };

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

@@ -0,0 +1,87 @@
+import * as THREE from "three";
+import { PanoId } from '../../utils/pano';
+export type PBMMeshShaderType = 'none' | 'basic' | 'phong' | 'standard';
+export type PBMPointCloudShaderType = 'pointcloud';
+export type PBMAlphaMode = 'OPAQUE' | 'MASK' | 'BLEND';
+export type PBMTransition = 'BLACK' | 'SPREAD' | 'FADE';
+export type PBMFloorStyle = 'VISIBILITY' | 'OPACITY';
+export type PBMColorStyle = 'RGB' | 'ALTITUDE' | 'CONSTANT';
+export type PBMPointShape = 'SQUARE' | 'CIRCLE';
+export type PBMPointSize = 'FIXED' | 'ATTENUATION';
+export type PBMPointBack = 'VISIBLE' | 'HIDDEN' | 'DARK';
+export interface PBMCustomShaderSlots {
+    vertex: {
+        mainBefore: string;
+        mainStart: string;
+        mainEnd: string;
+    };
+    fragment: {
+        mainBefore: string;
+        mainStart: string;
+        mainModelColor: string;
+        mainEnd: string;
+    };
+}
+export interface PBMCustomShaderInitArgs {
+    type: Array<'none' | 'basic' | 'phong' | 'standard' | 'pointcloud'>;
+    vertex?: Partial<PBMCustomShaderSlots['vertex']>;
+    fragment?: Partial<PBMCustomShaderSlots['fragment']>;
+    uniforms?: {
+        [key: string]: THREE.Uniform;
+    };
+    defines?: {
+        [key: string]: any;
+    };
+}
+export declare class PBMCustomShader {
+    id: string;
+    version: number;
+    uniforms: {
+        [key: string]: THREE.Uniform;
+    };
+    defines: {
+        [key: string]: any;
+    };
+    type: PBMCustomShaderInitArgs['type'];
+    vertex: PBMCustomShaderSlots['vertex'];
+    fragment: PBMCustomShaderSlots['fragment'];
+    constructor(initArgs: PBMCustomShaderInitArgs);
+    get needsUpdate(): boolean;
+    set needsUpdate(value: boolean);
+    onBeforeCompile(shader: THREE.Shader, renderer: THREE.WebGLRenderer): void;
+}
+export interface PBMClipperParameter {
+    clippingBoxMatrix: THREE.Matrix4;
+    floorIndex?: number;
+}
+export interface PBMPanoPicture {
+    /** 点位 Id */
+    panoId: PanoId;
+    /** 全景图 */
+    map: THREE.CubeTexture;
+    /** 图片尺寸 */
+    mapSize: number;
+    /** 全景图变换矩阵 4x4 */
+    matrix: THREE.Matrix4;
+    /** 缩放 */
+    zoom: number;
+}
+export interface PBMPanoDepth {
+    /** 点位 Id */
+    panoId: PanoId;
+    /** 深度图 */
+    map: THREE.CubeTexture;
+    /** 图片尺寸 */
+    mapSize: number;
+    /** 图片最大深度 */
+    maxDepth: number;
+}
+export interface PBMRefinedScreen {
+    projectionMatrix: THREE.Matrix4;
+    matrixInverse: THREE.Matrix4;
+    map: THREE.Texture | null;
+    pano: number;
+    opacity: number;
+}
+export declare class PBMMaterial extends THREE.Material {
+}

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

@@ -0,0 +1,124 @@
+import * as THREE from "three";
+import { PBMMaterial, PBMMeshShaderType, PBMPanoPicture, PBMPanoDepth, PBMRefinedScreen, PBMClipperParameter, PBMCustomShader, PBMAlphaMode, PBMTransition, PBMColorStyle, PBMFloorStyle } from "./pbmMaterial";
+export interface PBMMeshMaterialParameters extends THREE.MaterialParameters, THREE.MaterialParameters, THREE.MeshBasicMaterialParameters, THREE.MeshPhongMaterialParameters, THREE.MeshStandardMaterialParameters {
+    shaderType?: PBMMeshShaderType;
+    vertexMarks?: boolean;
+    colorAlpha?: number;
+    alphaMode?: PBMAlphaMode;
+    pano0?: PBMPanoPicture | null;
+    pano1?: PBMPanoPicture | null;
+    refinedScreen?: PBMRefinedScreen | null;
+    modelAlpha?: number;
+    progress?: number;
+    transition?: PBMTransition;
+    colorStyle?: PBMColorStyle;
+    constantColor?: THREE.Vector3;
+    floorIndex?: number;
+    shownFloorIndex?: number;
+    floorStyle?: PBMFloorStyle;
+    gradientTexture?: THREE.Texture | null;
+    brightness?: number;
+    colorSaturation?: number;
+    colorBrightness?: number;
+    useEDL?: boolean;
+    useHQWeight?: boolean;
+    useHQDepth?: boolean;
+    modelBoundingMin?: THREE.Vector3;
+    modelBoundingMax?: THREE.Vector3;
+    clippers?: PBMClipperParameter[];
+    customShaders?: PBMCustomShader[];
+}
+declare class PBMMeshMaterial extends PBMMaterial implements THREE.MeshBasicMaterial, THREE.MeshPhongMaterial, THREE.MeshStandardMaterial {
+    readonly isPBMMeshMaterial: true;
+    readonly isShaderMaterial: true;
+    readonly isMeshBasicMaterial: boolean;
+    readonly isMeshPhongMaterial: boolean;
+    readonly isMeshStandardMaterial: boolean;
+    readonly isMeshPhysicalMaterial: boolean;
+    shaderType: PBMMeshShaderType;
+    vertexTangents: boolean;
+    color: THREE.Color;
+    map: THREE.Texture | null;
+    lightMap: THREE.Texture | null;
+    lightMapIntensity: number;
+    aoMap: THREE.Texture | null;
+    aoMapIntensity: number;
+    specularMap: THREE.Texture | null;
+    specular: THREE.Color;
+    shininess: number;
+    roughnessMap: THREE.Texture | null;
+    roughness: number;
+    metalnessMap: THREE.Texture | null;
+    metalness: number;
+    alphaMap: THREE.Texture | null;
+    combine: THREE.Combine;
+    envMap: THREE.Texture | THREE.CubeTexture | null;
+    envMapIntensity: number;
+    reflectivity: number;
+    refractionRatio: number;
+    emissiveMap: THREE.Texture | null;
+    emissive: THREE.Color;
+    emissiveIntensity: number;
+    bumpMap: THREE.Texture | null;
+    bumpScale: number;
+    normalMap: THREE.Texture | null;
+    normalMapType: THREE.NormalMapTypes;
+    normalScale: THREE.Vector2;
+    displacementMap: THREE.Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    clearcoat: number;
+    clearcoatMap: THREE.Texture | null;
+    clearcoatRoughness: number;
+    clearcoatRoughnessMap: THREE.Texture | null;
+    clearcoatNormalScale: THREE.Vector2;
+    clearcoatNormalMap: THREE.Texture | null;
+    sheen: THREE.Color | null;
+    transparency: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    skinning: boolean;
+    morphTargets: boolean;
+    morphNormals: boolean;
+    metal: boolean;
+    vertexMarks: boolean;
+    alphaMode: PBMAlphaMode;
+    colorAlpha: number;
+    pano0: PBMPanoPicture | null;
+    pano1: PBMPanoPicture | null;
+    pano0Depth: PBMPanoDepth | null;
+    pano1Depth: PBMPanoDepth | null;
+    refinedScreen: PBMRefinedScreen | null;
+    modelAlpha: number;
+    progress: number;
+    transition: PBMTransition;
+    colorStyle: PBMColorStyle;
+    constantColor: THREE.Vector3;
+    floorIndex: number;
+    shownFloorIndex: number;
+    floorStyle: PBMFloorStyle;
+    gradientTexture: THREE.Texture | null;
+    brightness: number;
+    colorSaturation: number;
+    colorBrightness: number;
+    useEDL: boolean;
+    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?: PBMMeshMaterialParameters | PBMMeshShaderType);
+    copy(source: PBMMeshMaterial): this;
+    clone(): this;
+    /**
+     * @deprecated
+     * 已经不需要再被调用了
+     */
+    refreshUniforms(): void;
+}
+export { PBMMeshMaterial };

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

@@ -0,0 +1,72 @@
+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;
+    useEDL?: boolean;
+    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;
+    useEDL: boolean;
+    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 };