@realsee/five 6.8.0-alpha.8 → 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/CESIUM_RTC.d.ts

@@ -1,5 +1,5 @@
 import { BaseExtension } from './base';
-import { Parser } from '../parser';
+import type { Parser } from '../parser';
 import type { GlTFResult } from '../type';
 /**
  * Specification https://github.com/KhronosGroup/glTF/blob/main/extensions/1.0/Vendor/CESIUM_RTC/README.md

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

@@ -1,5 +1,5 @@
 import { BaseExtension } from './base';
-import { Parser } from '../parser';
+import type { Parser } from '../parser';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_meshopt_compression
  */

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

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { BaseExtension } from './base';
-import { Parser } from '../parser';
+import type { Parser } from '../parser';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp
  */

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

@@ -1,5 +1,5 @@
 import { BaseExtension } from './base';
-import { Parser } from '../parser';
+import type { Parser } from '../parser';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/1.0/Khronos/KHR_binary_glTF
  */
@@ -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_draco_mesh_compression.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { BaseExtension } from './base';
-import { Parser } from '../parser';
+import type { Parser } from '../parser';
 import { MeshPrimitive } from '../glTF';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_draco_mesh_compression

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 { Parser } from '../parser';
-import { PBMGSObject } from '../../../objects/pbmGSObject';
+import type { Parser } from '../parser';
+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/KHR_materials_clearcoat.d.ts

@@ -1,6 +1,10 @@
+import * as THREE from 'three';
 import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
  */
 export declare class KHR_materials_clearcoat extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
 }

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

@@ -1,6 +1,10 @@
+import * as THREE from 'three';
 import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_emissive_strength
  */
 export declare class KHR_materials_emissive_strength extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
 }

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

@@ -1,6 +1,10 @@
+import * as THREE from 'three';
 import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_sheen
  */
 export declare class KHR_materials_sheen extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
 }

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

@@ -1,6 +1,10 @@
+import * as THREE from 'three';
 import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
  */
 export declare class KHR_materials_transmission extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
 }

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

@@ -1,6 +1,10 @@
+import * as THREE from 'three';
 import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { MeshPrimitive } from '../glTF';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_unlit
  */
 export declare class KHR_materials_unlit extends BaseExtension {
+    extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;
 }

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

@@ -1,6 +1,10 @@
+import * as THREE from 'three';
 import { BaseExtension } from './base';
+import type { Parser } from '../parser';
+import { Node } from '../glTF';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_node_visibility
  */
 export declare class KHR_node_visibility extends BaseExtension {
+    extendNode(node: THREE.Object3D, nodeDef: Node, parser: Parser): Promise<void>;
 }

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

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { BaseExtension } from './base';
-import { Parser } from '../parser';
+import type { Parser } from '../parser';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_basisu
  */

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

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { BaseExtension } from './base';
-import { Parser } from '../parser';
+import type { Parser } from '../parser';
 import { TextureInfo } from '../glTF';
 /**
  * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_transform

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

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { BaseExtension } from './base';
-import { Parser } from '../parser';
+import type { Parser } from '../parser';
 import { MeshPrimitive } from '../glTF';
 export declare class REALSEE_materials_lightmap extends BaseExtension {
     extendMaterial(material: THREE.Material, primitiveDef: MeshPrimitive, parser: Parser): Promise<void>;

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

@@ -1,5 +1,5 @@
 import * as THREE from 'three';
-import type { MeshPrimitive, TextureInfo } 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,8 +15,10 @@ 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>;
     loadNodeAttachments(index: number, parser: Parser): null | Promise<THREE.Object3D>;
     loadCamera(index: number, parser: Parser): null | Promise<THREE.Camera>;
     loadAnimation(index: number, parser: Parser): null | Promise<THREE.AnimationClip>;

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

@@ -16,9 +16,10 @@ import { KHR_materials_emissive_strength } from './extensions/KHR_materials_emis
 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 { PBM_mesh } from './extensions/PBM_mesh';
 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;
@@ -36,8 +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;
-    PBM_mesh: typeof PBM_mesh;
+    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,8 +1,10 @@
 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';
+import { PBMMeshMaterial } from '../../materials/pbmMeshMaterial';
+import { PBMPointCloudMaterial } from '../../materials/pbmPointCloudMaterial';
 import { ImageBitmapLike } from '../../../texture/imageBitmap';
 type ParserOptions = {
     copyUV2: boolean;
@@ -66,19 +68,24 @@ export declare class Parser {
     createPrimitiveKey(primitiveDef: MeshPrimitive): string;
     /**
      * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
-     * @param primitiveRef
+     * @param primitiveDef
      */
-    loadGeometry(primitiveRef: MeshPrimitive): Promise<THREE.BufferGeometry>;
+    loadGeometry(primitiveDef: MeshPrimitive): Promise<THREE.BufferGeometry>;
     loadImage(index: number): Promise<ImageBitmapLike>;
-    loadMaterialAsMeshStandardMaterial(primitiveDef: MeshPrimitive): Promise<THREE.MeshStandardMaterial>;
-    loadMaterialAsMeshBasicMaterial(primitiveDef: MeshPrimitive): Promise<THREE.MeshBasicMaterial>;
-    loadMaterialAsLineBasicMaterial(primitiveDef: MeshPrimitive): Promise<THREE.LineBasicMaterial>;
-    loadMaterialAsPointsMaterial(primitiveDef: MeshPrimitive): Promise<THREE.PointsMaterial>;
+    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
+     */
+    loadMesh(index: number): Promise<THREE.Object3D>;
     /**
      * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
-     * @param primitiveRef
+     * @param primitiveDef
      */
-    loadMaterial(primitiveRef: MeshPrimitive): Promise<THREE.Material>;
+    loadMaterial(primitiveDef: MeshPrimitive): Promise<THREE.Material>;
+    loadMaterialAsPBMPointCloudMaterial(primitiveDef: MeshPrimitive): Promise<PBMPointCloudMaterial>;
+    loadMaterialAsPBMMeshMaterial(primitiveDef: MeshPrimitive): Promise<PBMMeshMaterial>;
+    loadMaterialAsLineBasicMaterial(primitiveDef: MeshPrimitive): Promise<THREE.LineBasicMaterial>;
     loadTexture(index: number): Promise<THREE.Texture>;
     /**
      * 当骨骼权重和不足 1 时，可能出现问题。
@@ -86,11 +93,6 @@ export declare class Parser {
      * 需要对 normalized 也做检测。
      */
     normalizeSkinWeights(skinnedMesh: THREE.SkinnedMesh): void;
-    /**
-     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
-     * @param index
-     */
-    loadMesh(index: number): Promise<THREE.Object3D>;
     assignFinalMaterial(mesh: THREE.Points | THREE.Line | THREE.Mesh): void;
     loadNodeAttachments(index: number): Promise<THREE.Object3D>[];
     /**

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 };