@realsee/five 6.8.0-alpha.9 → 6.8.0

package/five/meshes/boundingMesh.d.ts

@@ -3,6 +3,7 @@ import { PBMMesh } from "../model";
 import { type Camera } from '../core/camera';
 import { type ModelScene } from '../model';
 declare class BoundingMesh extends PBMMesh {
+    private currentResolvedParameterValue;
     constructor(options?: {
         name?: string;
     });

package/five/model/index.d.ts

@@ -2,8 +2,8 @@ export { PBMGroup } from "./objects/pbmGroup";
 export { PBMContainer } from "./objects/pbmContainer";
 export { PBMMesh, PBMSkinnedMesh } from "./objects/pbmMesh";
 export { PBMPointCloud } from "./objects/pbmPointCloud";
-export { PBMGSObject, type SplatData, } from "./objects/pbmGSObject";
-export { PBMCustomShader, 
+export { PBMGaussianSplattingObject as PBMGSObject, type SplatData, } from "./objects/pbmGaussianSplattingObject";
+export { PBMUpdateable, PBMPanoFilter, type PBMPanoFilterValue, PBMCustomShader, 
 /**
  * @deprecated
  * use PBMCustomShader instead

package/five/model/loaders/glTF-helpers/extensions/KHR_binary_glTF.d.ts

@@ -20,6 +20,6 @@ export declare class KHR_binary_glTF extends BaseExtension {
     body: ArrayBuffer | null;
     constructor();
     loadGlbBinary(data: ArrayBuffer): void;
-    loadBuffer(index: number, parser: Parser): Promise<ArrayBuffer>;
+    loadBuffer(index: number, parser: Parser): Promise<ArrayBuffer> | null;
     clear(): void;
 }

package/five/model/loaders/glTF-helpers/extensions/KHR_gaussian_splatting.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { Mesh, MeshPrimitive } from '../glTF';
+import type { GaussianSplattingExtensionSpz2 } from './KHR_gaussian_splatting_compression_spz_2';
+export interface GaussianSplattingExtensionOld {
+    antialiased: boolean;
+    bufferView: number;
+    compression: {
+        extension: "KHR_gaussian_splatting_compression_spz";
+    };
+    count: number;
+}
+export interface GaussianSplattingExtension {
+    colorSpace: "srgb_rec709_display" | "lin_rec709_display";
+    kernel: "ellipse";
+    sortingMethod: "cameraDistance";
+    projection: "perspective";
+    extensions: {
+        KHR_gaussian_splatting_compression_spz_2?: GaussianSplattingExtensionSpz2;
+    };
+}
+export declare class KHR_gaussian_splatting extends BaseExtension {
+    loadMeshPrimitive(meshDef: Mesh, primitiveDef: MeshPrimitive, parser: Parser): null | Promise<THREE.Points | THREE.Line | THREE.Mesh>;
+    private loadGaussianSplating;
+}

package/five/model/loaders/glTF-helpers/extensions/KHR_gaussian_splatting_compression_spz.d.ts

@@ -1,9 +1,11 @@
+import * as THREE from 'three';
 import { BaseExtension } from './base';
 import type { Parser } from '../parser';
-import { PBMGSObject } from '../../../objects/pbmGSObject';
+import { PBMGaussianSplattingObject } from '../../../objects/pbmGaussianSplattingObject';
+export declare const EXTENSION_NAME = "KHR_gaussian_splatting_compression_spz";
 export declare class KHR_gaussian_splatting_compression_spz extends BaseExtension {
-    name: string;
-    parentName: string;
-    loadMesh(index: number, parser: Parser): null | Promise<PBMGSObject>;
-    private loadSpz;
+    load(gaussianSplattingExtension: {
+        bufferView: number;
+    }, parser: Parser): Promise<THREE.Points>;
+    loadSpz(buffer: Uint8Array): Promise<PBMGaussianSplattingObject>;
 }

package/five/model/loaders/glTF-helpers/extensions/KHR_gaussian_splatting_compression_spz_2.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { PBMGaussianSplattingObject } from '../../../objects/pbmGaussianSplattingObject';
+export interface GaussianSplattingExtensionSpz2 {
+    bufferView: number;
+}
+export declare const EXTENSION_NAME = "KHR_gaussian_splatting_compression_spz_2";
+export declare class KHR_gaussian_splatting_compression_spz_2 extends BaseExtension {
+    constructor();
+    load(gaussianSplattingExtension: GaussianSplattingExtensionSpz2, parser: Parser): Promise<THREE.Points>;
+    loadSpz(buffer: Uint8Array): Promise<PBMGaussianSplattingObject>;
+}

package/five/model/loaders/glTF-helpers/extensions/base.d.ts

@@ -1,5 +1,5 @@
 import * as THREE from 'three';
-import type { MeshPrimitive, TextureInfo, Node } from '../glTF';
+import type { Mesh, MeshPrimitive, TextureInfo, Node } from '../glTF';
 import type { Parser } from '../parser';
 import type { GlTFResult } from '../type';
 import type { ImageBitmapLike } from '../../../../texture/imageBitmap';
@@ -15,6 +15,7 @@ export declare class BaseExtension {
     loadTexture(index: number, parser: Parser): null | Promise<THREE.Texture>;
     loadGeometry(primitiveDef: MeshPrimitive, parser: Parser): null | Promise<THREE.BufferGeometry>;
     loadMaterial(primitiveDef: MeshPrimitive, parser: Parser): null | Promise<THREE.Material>;
+    loadMeshPrimitive(meshDef: Mesh, primitiveDef: MeshPrimitive, parser: Parser): null | Promise<THREE.Points | THREE.Line | THREE.Mesh>;
     extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
     loadMesh(index: number, parser: Parser): null | Promise<THREE.Object3D>;
     extendNode(node: THREE.Object3D, nodeDef: Node, parser: Parser): Promise<void>;

package/five/model/loaders/glTF-helpers/index.d.ts

@@ -17,7 +17,9 @@ import { EXT_meshopt_compression } from './extensions/EXT_meshopt_compression';
 import { EXT_texture_webp } from './extensions/EXT_texture_webp';
 import { CESIUM_RTC } from './extensions/CESIUM_RTC';
 import { REALSEE_materials_lightmap } from './extensions/REALSEE_materials_lightmap';
+import { KHR_gaussian_splatting } from './extensions/KHR_gaussian_splatting';
 import { KHR_gaussian_splatting_compression_spz } from './extensions/KHR_gaussian_splatting_compression_spz';
+import { KHR_gaussian_splatting_compression_spz_2 } from './extensions/KHR_gaussian_splatting_compression_spz_2';
 export declare const EXTENSIONS: {
     KHR_binary_glTF: typeof KHR_binary_glTF;
     KHR_draco_mesh_compression: typeof KHR_draco_mesh_compression;
@@ -35,7 +37,9 @@ export declare const EXTENSIONS: {
     EXT_texture_webp: typeof EXT_texture_webp;
     CESIUM_RTC: typeof CESIUM_RTC;
     REALSEE_materials_lightmap: typeof REALSEE_materials_lightmap;
+    KHR_gaussian_splatting: typeof KHR_gaussian_splatting;
     KHR_gaussian_splatting_compression_spz: typeof KHR_gaussian_splatting_compression_spz;
+    KHR_gaussian_splatting_compression_spz_2: typeof KHR_gaussian_splatting_compression_spz_2;
 };
 export { GlTFResult };
 export declare function parseGltf(data: ArrayBuffer | string, options: {

package/five/model/loaders/glTF-helpers/parser.d.ts

@@ -1,5 +1,5 @@
 import * as THREE from 'three';
-import { GlTF, TextureInfo, MeshPrimitive } from './glTF';
+import { GlTF, TextureInfo, Mesh, MeshPrimitive } from './glTF';
 import type { GlTFResult } from './type';
 import { BaseExtension } from './extensions/base';
 import { Fetcher } from '../../../utils/ajax';
@@ -72,6 +72,7 @@ export declare class Parser {
      */
     loadGeometry(primitiveDef: MeshPrimitive): Promise<THREE.BufferGeometry>;
     loadImage(index: number): Promise<ImageBitmapLike>;
+    loadMeshPrimitive(meshDef: Mesh, primitiveDef: MeshPrimitive): Promise<THREE.Points | THREE.Line | THREE.Mesh>;
     /**
      * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
      * @param index

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

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

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

@@ -1,5 +1,6 @@
 import * as THREE from "three";
-import { PanoId } from '../../utils/pano';
+import { Subscribe } from '../../utils/subscribe';
+import type { PanoId } from '../../utils/pano';
 export type PBMMeshShaderType = 'none' | 'basic' | 'phong' | 'standard';
 export type PBMPointCloudShaderType = 'pointcloud';
 export type PBMAlphaMode = 'OPAQUE' | 'MASK' | 'BLEND';
@@ -9,6 +10,10 @@ export type PBMColorStyle = 'RGB' | 'ALTITUDE' | 'CONSTANT';
 export type PBMPointShape = 'SQUARE' | 'CIRCLE';
 export type PBMPointSize = 'FIXED' | 'ATTENUATION';
 export type PBMPointBack = 'VISIBLE' | 'HIDDEN' | 'DARK';
+export declare class PBMUpdateable extends Subscribe<{
+    "update": () => void;
+}> {
+}
 export interface PBMCustomShaderSlots {
     vertex: {
         mainBefore: string;
@@ -19,6 +24,7 @@ export interface PBMCustomShaderSlots {
         mainBefore: string;
         mainStart: string;
         mainModelColor: string;
+        mainPanoColor: string;
         mainEnd: string;
     };
 }
@@ -27,17 +33,17 @@ export interface PBMCustomShaderInitArgs {
     vertex?: Partial<PBMCustomShaderSlots['vertex']>;
     fragment?: Partial<PBMCustomShaderSlots['fragment']>;
     uniforms?: {
-        [key: string]: THREE.Uniform;
+        [key: string]: THREE.IUniform;
     };
     defines?: {
         [key: string]: any;
     };
 }
-export declare class PBMCustomShader {
+export declare class PBMCustomShader extends PBMUpdateable {
     id: string;
     version: number;
     uniforms: {
-        [key: string]: THREE.Uniform;
+        [key: string]: THREE.IUniform;
     };
     defines: {
         [key: string]: any;
@@ -50,6 +56,48 @@ export declare class PBMCustomShader {
     set needsUpdate(value: boolean);
     onBeforeCompile(shader: THREE.Shader, renderer: THREE.WebGLRenderer): void;
 }
+export interface PBMPanoFilterValue {
+    saturationSaturationBias: number;
+    contrastContrastBias: number;
+    highlightShadowLutMap: THREE.Texture;
+    colorTemperatureBias: number;
+    colorTintBias: number;
+}
+export declare class PBMPanoFilter extends PBMUpdateable {
+    readonly id: string;
+    /** 对比度 */
+    readonly contrast: {
+        /** 对比偏移 [-1, 1] */
+        contrastBias: number;
+    };
+    /** 饱和度 */
+    readonly saturation: {
+        /** 饱和偏移 [-1, 1] */
+        saturationBias: number;
+    };
+    /** 颜色 */
+    readonly color: {
+        /** 色温偏移 [-100, 100] */
+        temperatureBias: number;
+        /** 色調偏移 [-100, 100] */
+        tintBias: number;
+    };
+    /** 高光阴影 */
+    readonly highlightShadow: {
+        /** 高光偏移 [-255, 255] */
+        highlightBias: number;
+        /** 阴影偏移 [-255, 255] */
+        shadowBias: number;
+        /** 全局亮度偏移 [-255, 255] */
+        globalBias: number;
+        /** 高光阴影的颜色对照表 */
+        readonly lutMap: THREE.Texture;
+    };
+    /** 计算调色 LUT */
+    static computeLut(highlightBias: number, shadowBias: number, globalBias: number, width?: number, itemSize?: number, target?: Float32Array, offset?: number): Float32Array;
+    constructor();
+    toValue(): PBMPanoFilterValue;
+}
 export interface PBMClipperParameter {
     clippingBoxMatrix: THREE.Matrix4;
     floorIndex?: number;
@@ -59,6 +107,8 @@ export interface PBMPanoPicture {
     panoId: PanoId;
     /** 全景图 */
     map: THREE.CubeTexture;
+    /** 图片直方图 peak mean min max */
+    mapHistogram: THREE.Vector4;
     /** 图片尺寸 */
     mapSize: number;
     /** 全景图变换矩阵 4x4 */

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

@@ -1,5 +1,5 @@
 import * as THREE from "three";
-import { PBMMaterial, PBMMeshShaderType, PBMPanoPicture, PBMPanoDepth, PBMRefinedScreen, PBMClipperParameter, PBMCustomShader, PBMAlphaMode, PBMTransition, PBMColorStyle, PBMFloorStyle } from "./pbmMaterial";
+import { PBMMaterial, PBMMeshShaderType, PBMPanoPicture, PBMPanoFilterValue, 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;
@@ -7,6 +7,9 @@ export interface PBMMeshMaterialParameters extends THREE.MaterialParameters, THR
     alphaMode?: PBMAlphaMode;
     pano0?: PBMPanoPicture | null;
     pano1?: PBMPanoPicture | null;
+    pano0Depth?: PBMPanoDepth | null;
+    pano1Depth?: PBMPanoDepth | null;
+    panoFilter?: PBMPanoFilterValue | null;
     refinedScreen?: PBMRefinedScreen | null;
     modelAlpha?: number;
     progress?: number;
@@ -20,7 +23,6 @@ export interface PBMMeshMaterialParameters extends THREE.MaterialParameters, THR
     brightness?: number;
     colorSaturation?: number;
     colorBrightness?: number;
-    useEDL?: boolean;
     useHQWeight?: boolean;
     useHQDepth?: boolean;
     modelBoundingMin?: THREE.Vector3;
@@ -90,6 +92,7 @@ declare class PBMMeshMaterial extends PBMMaterial implements THREE.MeshBasicMate
     pano1: PBMPanoPicture | null;
     pano0Depth: PBMPanoDepth | null;
     pano1Depth: PBMPanoDepth | null;
+    panoFilter: PBMPanoFilterValue | null;
     refinedScreen: PBMRefinedScreen | null;
     modelAlpha: number;
     progress: number;
@@ -103,7 +106,6 @@ declare class PBMMeshMaterial extends PBMMaterial implements THREE.MeshBasicMate
     brightness: number;
     colorSaturation: number;
     colorBrightness: number;
-    useEDL: boolean;
     useHQWeight: boolean;
     useHQDepth: boolean;
     modelBoundingMin: THREE.Vector3;

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

@@ -20,7 +20,6 @@ export interface PBMPointCloudMaterialParameters extends THREE.MaterialParameter
     colorBrightness?: number;
     outlineGain?: number;
     distanceGain?: number;
-    useEDL?: boolean;
     useHQWeight?: boolean;
     useHQDepth?: boolean;
     modelBoundingMin?: THREE.Vector3;
@@ -51,7 +50,6 @@ declare class PBMPointCloudMaterial extends PBMMaterial {
     colorBrightness: number;
     outlineGain: number;
     distanceGain: number;
-    useEDL: boolean;
     useHQWeight: boolean;
     useHQDepth: boolean;
     modelBoundingMin: THREE.Vector3;

package/five/model/objects/{pbmGSObject.d.ts → pbmGaussianSplattingObject.d.ts}

@@ -1,4 +1,5 @@
 import * as THREE from "three";
+import type { PBMClipperParameter } from "../materials/pbmMaterial";
 export interface SplatData {
     numPoints: number;
     positions: Float32Array;
@@ -10,7 +11,7 @@ export interface SplatData {
     sh3?: Float32Array;
     shDegree?: number;
 }
-export declare class PBMGSObject extends THREE.Points<THREE.BufferGeometry, THREE.ShaderMaterial> {
+export declare class PBMGaussianSplattingObject extends THREE.Points<THREE.BufferGeometry, THREE.ShaderMaterial> {
     static RowLength: number;
     transformChanged: boolean;
     selectedChanged: boolean;
@@ -18,6 +19,8 @@ export declare class PBMGSObject extends THREE.Points<THREE.BufferGeometry, THRE
     numPoints: number;
     maxSHDegree: number;
     usedSHDegree: number;
+    gsViewLayerKey: string;
+    gsClippers: readonly PBMClipperParameter[];
     private _selected;
     private _boundingBox;
     lastMatrixWorld: THREE.Matrix4 | null;

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

@@ -0,0 +1,59 @@
+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 freeSlotPool;
+    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;
+    /** 回收 slot 到池中复用，而非直接销毁 */
+    private recycleSlot;
+    private disposeTextures;
+    private applyDepthIndex;
+    private swapPendingToActive;
+    private createSlot;
+    private updateSlotTextures;
+    private postSortData;
+    private sortDataRebuilding;
+    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/parameter.d.ts

@@ -1,5 +1,5 @@
 import * as THREE from 'three';
-import type { PBMCustomShader, PBMPanoPicture, PBMPanoDepth, PBMRefinedScreen, PBMTransition, PBMFloorStyle, PBMColorStyle, PBMClipperParameter, PBMPointShape, PBMPointSize, PBMPointBack } from './materials/pbmMaterial';
+import { type PBMCustomShader, type PBMPanoPicture, type PBMPanoDepth, type PBMRefinedScreen, type PBMTransition, type PBMFloorStyle, type PBMColorStyle, type PBMClipperParameter, type PBMPanoFilter, type PBMPointShape, type PBMPointSize, type PBMPointBack } from './materials/pbmMaterial';
 import type { TileRequestOrder } from './tile3d/types';
 import type { Camera } from '../core/camera';
 export interface ParameterMaterialValue {
@@ -19,6 +19,8 @@ export interface ParameterMaterialValue {
     pano0Depth: PBMPanoDepth | null;
     /** 结束点深度 */
     pano1Depth: PBMPanoDepth | null;
+    /** 全景图滤镜 */
+    panoFilter: PBMPanoFilter | null;
     /** 细化瓦片的屏幕渲染 */
     refinedScreen: PBMRefinedScreen | null;
     /** 模型贴图和全景图的混合程度 [0-1] */
@@ -78,7 +80,7 @@ export interface ParameterMaterialValue {
     /** 包围盒 */
     boundingBox: THREE.Box3;
     /** 3dgs球谐阶数*/
-    gsSHDegree: number;
+    gaussianSplattingSHDegree: number;
 }
 export interface ParameterTilesetValue {
     /** 模型显示最小细化层级 */
@@ -114,20 +116,23 @@ export interface ParameterTilesetValue {
 export interface ParameterValue extends ParameterMaterialValue, ParameterTilesetValue {
 }
 export interface ResolvedParameterValue extends ParameterValue {
-    versions: string[];
-    version: string;
+    versionNumber: number;
 }
 export interface Parameter extends Readonly<Partial<ParameterValue>> {
 }
 export declare class Parameter {
     static createDefault(): Required<ParameterValue>;
-    static resolveValue(...values: Partial<ParameterValue>[]): ResolvedParameterValue;
+    static resolveValueTo(target: Partial<ResolvedParameterValue>, ...parameterValues: Partial<ParameterValue>[]): ResolvedParameterValue;
+    static resolveValue<T extends keyof ParameterValue>(name: T, ...parameterValues: Partial<ParameterValue>[]): ParameterValue[T];
+    static resolveValue(...parameterValues: Partial<ParameterValue>[]): ResolvedParameterValue;
     id: string;
     versionNumber: number;
     private value;
+    private unbind;
     constructor(initialValue?: Partial<ParameterValue>);
-    get version(): string;
+    resolveValue<T extends keyof ParameterValue>(name: T, ...values: Partial<ParameterValue>[]): ParameterValue[T];
     resolveValue(...baseValues: Partial<ParameterValue>[]): ResolvedParameterValue;
+    private assignValue;
     set<T extends keyof ParameterValue>(name: T, value: ParameterValue[T]): this;
     set(values: Partial<ParameterValue>): this;
     reset(...names: (keyof ParameterValue)[]): this;

package/five/model/tile3d/index.d.ts

@@ -5,6 +5,7 @@ import { Tile } from './tile';
 import { Trajectory } from './trajectory';
 import { TilesetHeader } from './header';
 import { Intersection } from '../intersection';
+import { type BoundingVolume } from '../../utils/volume';
 import { Fetcher } from '../../utils/ajax';
 import { Parameter } from '../parameter';
 import type { ModelScene } from '../model-scene';
@@ -57,9 +58,10 @@ export declare class Tile3D extends THREE.Object3D {
     private renderObjects;
     private backfaceObjects;
     private tileObjects;
+    private currentResolvedParameterValue;
     constructor(tilesetHeader: TilesetHeader, options: Tile3DOptions);
-    get viewerRequestVolume(): import("../../utils/volume").BoundingVolume;
-    set viewerRequestVolume(value: import("../../utils/volume").BoundingVolume);
+    get viewerRequestVolume(): BoundingVolume | undefined;
+    set viewerRequestVolume(value: BoundingVolume | undefined);
     get tiles(): Tile[];
     get trajectories(): Trajectory[];
     getRecommendProps(options?: {
@@ -81,7 +83,7 @@ export declare class Tile3D extends THREE.Object3D {
      * @deprecated
      * use this.parent instead.
      */
-    get model(): Model;
+    get model(): Model | null;
     /**
      * @deprecated
      * it's self

package/five/model/tile3d/tile-node.d.ts

@@ -4,14 +4,14 @@ import type { Camera } from '../../core/camera';
 import type { Tile } from './tile';
 import { PBMMesh, PBMSkinnedMesh } from '../objects/pbmMesh';
 import { PBMPointCloud } from '../objects/pbmPointCloud';
-import { PBMGSObject } from '../objects/pbmGSObject';
+import { PBMGaussianSplattingObject } from '../objects/pbmGaussianSplattingObject';
 import type { ResolvedParameterValue } from '../parameter';
 import type { ModelScene } from '../model-scene';
 import type { Tile3D } from './index';
 export declare class TileNode extends THREE.Object3D {
     materials: THREE.Material[];
     animations: THREE.AnimationClip[];
-    pbmObjects: (PBMMesh | PBMSkinnedMesh | PBMPointCloud | PBMGSObject)[];
+    pbmObjects: (PBMMesh | PBMSkinnedMesh | PBMPointCloud | PBMGaussianSplattingObject)[];
     private contentObject;
     private appearMotion;
     private disposers;

package/five/model/tile3d/tileset.d.ts

@@ -35,6 +35,7 @@ export declare class Tileset {
     id: string;
     frameNumber: number;
     hasMixedContent: boolean;
+    maxAverageTileMemory: number;
     properties: NonNullable<TilesetHeader['properties']>;
     options: TilesetOptions;
     root: Tile;

package/five/renderer/postprocessing/passes/adaptive-luminance-pass.d.ts

@@ -1,13 +1,15 @@
 import * as THREE from 'three';
 import { FivePass } from './pass';
 export declare class AdaptiveLuminancePass extends FivePass {
-    luminanceScreenSampleScale: number;
-    luminanceScale: number;
-    luminanceStep: number;
-    private luminanceTargetBuffer?;
-    private luminancePrevBuffer?;
-    private luminanceNextBuffer?;
-    private progress;
+    maxMinValue: number;
+    minMaxValue: number;
+    valueStep: number;
+    sampleTestScale: number;
+    private histogram;
+    private minValue;
+    private maxValue;
+    private luminanceSampleTarget?;
+    private luminanceSampleBuffer?;
     constructor();
     render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget, deltaTime: number, maskActive?: boolean): void;
     clearBuffer(): void;

package/five/renderer/tools/render-cube-to-equirectangular.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from 'three';
+/**
+ * 将 立方体投影图 渲染成 圆柱投影图
+ * @param renderer - THREE.WebGLRenderer
+ * @param cubemap - 立方体投影图
+ */
+export declare function renderCubeToEquirectangular(renderer: THREE.WebGLRenderer, cubemap: THREE.CubeTexture, flipY: boolean): void;

package/five/renderer/tools/render-full-screen.d.ts

@@ -1,2 +1,2 @@
 import * as THREE from 'three';
-export declare function renderFullScreen(renderer: THREE.WebGLRenderer, source: THREE.Texture | THREE.Color, opacity?: number): void;
+export declare function renderFullScreen(renderer: THREE.WebGLRenderer, source: THREE.Texture | THREE.Color, flipY?: boolean, opacity?: number): void;

package/five/texture/histogram.d.ts

@@ -0,0 +1,54 @@
+import type { RgbaData } from './textureData';
+type HistogramData = {
+    /** 峰值 */
+    peak: number;
+    /** 平均值 */
+    mean: number;
+    /** 最小值 */
+    min: number;
+    /** 最大值 */
+    max: number;
+};
+export declare const sharedHistogramRgbaData: RgbaData;
+/**
+ * 计算直方图
+ * @param images - 图片的像素 / 像素长度（rgba: 4, rgb: 3）
+ * @param target - 输出对象
+ * @returns
+ */
+export declare function computeHistogram(images: {
+    data: Uint8Array | Uint8ClampedArray;
+    type?: 'rgba' | 'rgb';
+}[], target?: HistogramData): HistogramData;
+/** 直方图 */
+export declare class Histogram {
+    /** 峰值 */
+    peak: number;
+    /** 平均值 */
+    mean: number;
+    /** 最小值 */
+    min: number;
+    /** 最大值 */
+    max: number;
+    constructor(peak?: number, mean?: number, min?: number, max?: number);
+    /**
+     * 从图像获取直方图
+     * @param rgbaArray - 像素数组，像素 rgba 排列
+     */
+    formPixels(...rgbaArray: (Uint8Array | Uint8ClampedArray)[]): this;
+    toJSON(): {
+        peak: number;
+        mean: number;
+        min: number;
+        max: number;
+    };
+    /**
+     * 导出直方图参数为数组 [peak, mean, min, max]
+     */
+    toArray(): number[];
+    /**
+     * 导出直方图参数为字符串 peak mean min max
+     */
+    toString(): string;
+}
+export {};

package/five/texture/loader.d.ts

@@ -35,5 +35,5 @@ export declare class TextureLoader {
         viaAjax?: boolean;
         timeout?: number;
         fetcher: Fetcher;
-    }, onLoad: (response: NetworkResponse<THREE.CubeTexture, NetWorkMeta[]>) => void, onError: (error: Error) => void, onProgress: (percent: number) => void, renderer: THREE.WebGLRenderer): Promise<NetworkResponse<THREE.CubeTexture, NetWorkMeta[]>>;
+    }, onLoad: ((response: NetworkResponse<THREE.CubeTexture, NetWorkMeta[]>) => void) | undefined, onError: ((error: Error) => void) | undefined, onProgress: ((percent: number) => void) | undefined, renderer: THREE.WebGLRenderer): Promise<NetworkResponse<THREE.CubeTexture, NetWorkMeta[]>>;
 }

package/five/texture/textureData.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+export interface RgbaData {
+    /** 宽，单位px */
+    width: number;
+    /** 高，单位px */
+    height: number;
+    /** 像素值 */
+    data: Uint8ClampedArray<ArrayBuffer>;
+}
+export declare function getRgbaDataFromCubeTexture(renderer: THREE.WebGLRenderer, cubemap: THREE.CubeTexture, flipY: boolean, rgbaData: RgbaData): RgbaData;
+export declare function getRgbaDataFromTexture(renderer: THREE.WebGLRenderer, map: THREE.Texture, flipY: boolean, rgbaData: RgbaData): RgbaData;