@realsee/five-webgpu 1.0.0-alpha.1

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

@@ -0,0 +1,171 @@
+import * as THREE from "three/webgpu";
+import { Subscribe } from '../../utils/subscribe';
+import type { PanoId } from '../../utils/pano';
+import type { HDRCfgData } from '../../utils/hdr-data';
+import type { ParameterValue } from '../parameter';
+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 declare class PBMUpdateable extends Subscribe<{
+    "update": () => 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;
+}
+export interface PBMPanoPicture {
+    /** 点位 Id */
+    panoId: PanoId;
+    /** 全景图 */
+    map: THREE.CubeTexture;
+    /** 图片直方图 peak mean min max */
+    mapHistogram: THREE.Vector4;
+    /** 图片尺寸 */
+    mapSize: number;
+    /** 全景图变换矩阵 4x4 */
+    matrix: THREE.Matrix4;
+    /** 缩放 */
+    zoom: number;
+    hdrConfig?: PBMHDRConfig;
+}
+export interface PBMHDRConfig extends HDRCfgData {
+    map: THREE.CubeTexture;
+}
+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 interface IPBMMaterial {
+    readonly isPBMMaterial: true;
+    flatShading: boolean;
+    pano0Map: THREE.CubeTexture | null;
+    pano0MapSize: number;
+    pano0Histogram: THREE.Vector4;
+    pano0Matrix: THREE.Matrix4;
+    pano0Zoom: number;
+    pano0GainMap: THREE.CubeTexture | null;
+    pano0HdrMaxContentBoost: number;
+    pano0HdrMinContentBoost: number;
+    pano0HdrCapacityMin: number;
+    pano0HdrCapacityMax: number;
+    pano0HdrGamma: number;
+    pano0DepthMap: THREE.CubeTexture | null;
+    pano0DepthMaxDepth: number;
+    pano1Map: THREE.CubeTexture | null;
+    pano1MapSize: number;
+    pano1Histogram: THREE.Vector4;
+    pano1Matrix: THREE.Matrix4;
+    pano1Zoom: number;
+    pano1GainMap: THREE.CubeTexture | null;
+    pano1HdrMaxContentBoost: number;
+    pano1HdrMinContentBoost: number;
+    pano1HdrCapacityMin: number;
+    pano1HdrCapacityMax: number;
+    pano1HdrGamma: number;
+    pano1DepthMap: THREE.CubeTexture | null;
+    pano1DepthMaxDepth: number;
+    panoFilterSaturationBias: number;
+    panoFilterContrastBias: number;
+    panoFilterLutMap: THREE.Texture | null;
+    panoFilterTemperatureBias: number;
+    panoFilterTintBias: number;
+    refinedScreenMap: THREE.Texture | null;
+    refinedScreenProjectionMatrix: THREE.Matrix4;
+    refinedScreenMatrixInverse: THREE.Matrix4;
+    refinedScreenOpacity: number;
+    refinedScreenPano: number;
+    pointSize: PBMPointSize;
+    pointShape: PBMPointShape;
+    pointBack: PBMPointBack;
+    pointScale: number;
+    pointMinPixel: number;
+    pointMaxPixel: number;
+    vertexMarks: boolean;
+    colorAlpha: number;
+    alphaMode: string;
+    modelAlpha: number;
+    progress: number;
+    transition: PBMTransition;
+    colorStyle: PBMColorStyle;
+    constantColor: THREE.Vector3;
+    floorIndex: number;
+    shownFloorIndex: number;
+    floorStyle: string;
+    brightness: number;
+    colorSaturation: number;
+    colorBrightness: number;
+    gradientTexture: THREE.Texture | null;
+    useHDR: boolean;
+    maxDisplayBoost: number;
+    modelBoundingMin: THREE.Vector3;
+    modelBoundingMax: THREE.Vector3;
+}
+export type PBMPropertyKey = keyof Omit<IPBMMaterial, 'isPBMMaterial'>;
+export declare const pbmProperties: PBMPropertyKey[];
+export declare function createDefaultPBMProperties(): Omit<IPBMMaterial, 'isPBMMaterial' | 'flatShading'>;
+/** 复制 PBM 扩展属性 */
+export declare function copyPBMProperties(target: IPBMMaterial, source: IPBMMaterial): void;
+/** 类型守卫 */
+export declare function isPBMMaterial(obj: any): obj is IPBMMaterial;
+export declare function assignPBMMaterialFromParameterValue(material: IPBMMaterial & THREE.Material, parameterValue: ParameterValue): void;

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

@@ -0,0 +1,6 @@
+import * as THREE from 'three/webgpu';
+/**
+ * 注册 PBM 材质到渲染器的 NodeLibrary。
+ * 应在渲染前调用一次。
+ */
+export declare function registerPBMMaterials(renderer: THREE.WebGPURenderer): void;

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

@@ -0,0 +1,57 @@
+/**
+ * pbmMeshMaterial.ts — PBM 材质统一入口
+ *
+ * 导出传统材质类（业务层使用）和注册函数。
+ * 使用方式：
+ *   import { PBMMeshBasicMaterial, registerPBMMaterials } from './pbmMeshMaterial';
+ *   registerPBMMaterials(renderer);
+ *   const material = new PBMMeshBasicMaterial();
+ */
+import * as THREE from 'three/webgpu';
+import { type IPBMMaterial } from './pbmMaterial';
+export type PBMMeshShaderType = 'panoOnly' | 'basic' | 'phong' | 'standard';
+export interface PBMMeshBasicMaterial extends THREE.MeshBasicMaterial, IPBMMaterial {
+}
+export declare class PBMMeshBasicMaterial extends THREE.MeshBasicMaterial implements IPBMMaterial {
+    readonly isPBMMaterial = true;
+    readonly shaderType = "baisc";
+    constructor(parameters?: THREE.MeshBasicMaterialParameters);
+    copy(source: PBMMeshBasicMaterial): this;
+}
+export interface PBMMeshPanoOnlyMaterial extends THREE.MeshBasicMaterial, IPBMMaterial {
+}
+export declare class PBMMeshPanoOnlyMaterial extends THREE.MeshBasicMaterial implements IPBMMaterial {
+    readonly isPBMMaterial = true;
+    readonly shaderType = "panoOnly";
+    constructor(parameters?: THREE.MeshBasicMaterialParameters);
+    copy(source: PBMMeshPanoOnlyMaterial): this;
+}
+export interface PBMMeshPhongMaterial extends THREE.MeshPhongMaterial, IPBMMaterial {
+}
+export declare class PBMMeshPhongMaterial extends THREE.MeshPhongMaterial implements IPBMMaterial {
+    readonly isPBMMaterial = true;
+    readonly shaderType = "phong";
+    constructor(parameters?: THREE.MeshPhongMaterialParameters);
+    copy(source: PBMMeshPhongMaterial): this;
+}
+export interface PBMMeshPhysicalMaterial extends THREE.MeshPhysicalMaterial, IPBMMaterial {
+}
+export declare class PBMMeshPhysicalMaterial extends THREE.MeshPhysicalMaterial implements IPBMMaterial {
+    readonly isPBMMaterial: true;
+    readonly shaderType = "standard";
+    constructor(parameters?: THREE.MeshPhysicalMaterialParameters);
+    copy(source: PBMMeshPhysicalMaterial): this;
+}
+export type PBMMeshMaterial = PBMMeshBasicMaterial | PBMMeshPhongMaterial | PBMMeshPhysicalMaterial | PBMMeshPanoOnlyMaterial;
+export declare function createPBMMeshMaterial(shaderType?: PBMMeshShaderType | {
+    shaderType?: PBMMeshShaderType;
+}): PBMMeshMaterial;
+export interface PBMPointCloudMaterial extends THREE.Material, IPBMMaterial {
+}
+export declare class PBMPointCloudMaterial extends THREE.Material implements IPBMMaterial {
+    readonly isPBMMaterial: true;
+    readonly shaderType = "standard";
+    constructor();
+    copy(source: PBMPointCloudMaterial): this;
+}
+export declare function createPBMPointCloudMaterial(): PBMPointCloudMaterial;

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

@@ -0,0 +1,20 @@
+/**
+ * pbmMeshMaterial.ts — PBM 材质统一入口
+ *
+ * 导出传统材质类（业务层使用）和注册函数。
+ * 使用方式：
+ *   import { PBMMeshBasicMaterial, registerPBMMaterials } from './pbmMeshMaterial';
+ *   registerPBMMaterials(renderer);
+ *   const material = new PBMMeshBasicMaterial();
+ */
+import * as THREE from 'three/webgpu';
+import { type IPBMMaterial } from './pbmMaterial';
+export interface PBMPointCloudMaterial extends THREE.Material, IPBMMaterial {
+}
+export declare class PBMPointCloudMaterial extends THREE.Material implements IPBMMaterial {
+    readonly isPBMMaterial: true;
+    readonly shaderType = "standard";
+    constructor();
+    copy(source: PBMPointCloudMaterial): this;
+}
+export declare function createPBMPointCloudMaterial(): PBMPointCloudMaterial;

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

@@ -0,0 +1,46 @@
+/**
+ * PBMPointCloudNodeMaterial — 点云 NodeMaterial (TSL billboard quad)
+ *
+ * WebGPU 不支持可变大小点图元，因此采用实例化四边形方案：
+ * 每个点渲染为一个面向相机的 billboard quad，在顶点阶段完成展开。
+ *
+ * 配合 PBMPointCloud (THREE.Mesh + InstancedBufferGeometry) 使用。
+ * 几何体中 instancePosition/instanceColor/instanceNormal 由 PBMPointCloud 自动生成。
+ */
+import * as THREE from 'three/webgpu';
+import type { PBMColorStyle, PBMFloorStyle, PBMPointShape, PBMPointSize, PBMPointBack } from './pbmMaterial';
+export declare class PBMPointCloudNodeMaterial extends THREE.NodeMaterial {
+    readonly isPBMPointCloudMaterial: true;
+    pointSizeMode: PBMPointSize;
+    pointShape: PBMPointShape;
+    pointBack: PBMPointBack;
+    colorStyle: PBMColorStyle;
+    floorStyle: PBMFloorStyle;
+    vertexMarks: boolean;
+    pointScale: number;
+    pointMinPixel: number;
+    pointMaxPixel: number;
+    modelAlpha: number;
+    opacity: number;
+    constantColor: THREE.Vector3;
+    floorIndex: number;
+    shownFloorIndex: number;
+    brightness: number;
+    colorSaturation: number;
+    colorBrightness: number;
+    outlineGain: number;
+    distanceGain: number;
+    modelBoundingMin: THREE.Vector3;
+    modelBoundingMax: THREE.Vector3;
+    flatShading: boolean;
+    private _gradientTexture;
+    get gradientTexture(): THREE.Texture | null;
+    set gradientTexture(v: THREE.Texture | null);
+    constructor();
+    customProgramCacheKey(): string;
+    setupVertex(_builder: THREE.NodeBuilder): THREE.Node<"vec4">;
+    setup(builder: THREE.NodeBuilder): void;
+    private _buildColorNode;
+    private _buildOutputNode;
+    copy(source: PBMPointCloudNodeMaterial): this;
+}

package/five/model/materials/tsl/colorFilter.d.ts

@@ -0,0 +1,9 @@
+/**
+ * colorFilter.ts — 全景图滤镜管线（HSL、色温、对比度、LUT）
+ */
+import * as THREE from 'three/webgpu';
+export declare const filterColorTemperature: THREE.TSL.FnNode<[number | THREE.Node, number | THREE.Node], THREE.Node<"vec3">>;
+export declare const filterColorTint: THREE.TSL.FnNode<[number | THREE.Node, number | THREE.Node], THREE.Node<"vec3">>;
+export declare const filterContrast: THREE.TSL.FnNode<[number | THREE.Node, number | THREE.Node, number | THREE.Node], THREE.Node<"vec3">>;
+export declare const filterSaturation: THREE.TSL.FnNode<[number | THREE.Node, number | THREE.Node], THREE.Node<"vec3">>;
+export declare function colorFilter(saturationBias: THREE.Node<'float'>, contrastBias: THREE.Node<'float'>, temperatureBias: THREE.Node<'float'>, tintBias: THREE.Node<'float'>, lutSampler: (uv: THREE.Node<'vec2'>) => THREE.Node<'vec4'>): THREE.TSL.FnNode<[number | THREE.Node, number | THREE.Node], THREE.VarNode<"vec3">>;

package/five/model/materials/tsl/defines.d.ts

@@ -0,0 +1,68 @@
+import * as THREE from 'three/webgpu';
+export declare const TRANSPARENT: THREE.ConstNode<"vec4", THREE.Vector4>;
+export declare const resolution: THREE.UniformNode<"vec2", THREE.Vector2>;
+export declare const pixelRatio: THREE.UniformNode<"float", number>;
+export declare const vCameraDirection: THREE.VaryingNode<"vec3">;
+export declare const vRoofMark: THREE.VaryingNode<"float">;
+export declare const progress: THREE.Node<"float">;
+export declare const maxDisplayBoost: THREE.Node<"float">;
+export declare const modelAlpha: THREE.Node<"float">;
+export declare const pano0Matrix: THREE.Node<"mat4">;
+export declare const pano0Zoom: THREE.Node<"float">;
+export declare const pano0Histogram: THREE.Node<"vec4">;
+export declare const pano0HdrMaxContentBoost: THREE.Node<"float">;
+export declare const pano0HdrMinContentBoost: THREE.Node<"float">;
+export declare const pano0HdrCapacityMin: THREE.Node<"float">;
+export declare const pano0HdrCapacityMax: THREE.Node<"float">;
+export declare const pano0HdrGamma: THREE.Node<"float">;
+export declare const pano0DepthMaxDepth: THREE.Node<"float">;
+export declare const pano1Matrix: THREE.Node<"mat4">;
+export declare const pano1Zoom: THREE.Node<"float">;
+export declare const pano1Histogram: THREE.Node<"vec4">;
+export declare const pano1HdrMaxContentBoost: THREE.Node<"float">;
+export declare const pano1HdrMinContentBoost: THREE.Node<"float">;
+export declare const pano1HdrCapacityMin: THREE.Node<"float">;
+export declare const pano1HdrCapacityMax: THREE.Node<"float">;
+export declare const pano1HdrGamma: THREE.Node<"float">;
+export declare const pano1DepthMaxDepth: THREE.Node<"float">;
+export declare const panoFilterSaturationBias: THREE.Node<"float">;
+export declare const panoFilterContrastBias: THREE.Node<"float">;
+export declare const panoFilterTemperatureBias: THREE.Node<"float">;
+export declare const panoFilterTintBias: THREE.Node<"float">;
+export declare const refinedScreenProjectionMatrix: THREE.Node<"mat4">;
+export declare const refinedScreenMatrixInverse: THREE.Node<"mat4">;
+export declare const refinedScreenOpacity: THREE.Node<"float">;
+export declare const refinedScreenPano: THREE.Node<"float">;
+export declare const colorAlpha: THREE.Node<"float">;
+export declare const brightness: THREE.Node<"float">;
+export declare const floorIndex: THREE.Node<"float">;
+export declare const shownFloorIndex: THREE.Node<"float">;
+export declare const modelBoundingMin: THREE.Node<"vec3">;
+export declare const modelBoundingMax: THREE.Node<"vec3">;
+export declare const constantColor: THREE.Node<"vec3">;
+export declare const pointScale: THREE.Node<"float">;
+export declare const pointMinPixel: THREE.Node<"float">;
+export declare const pointMaxPixel: THREE.Node<"float">;
+export declare const colorSaturation: THREE.Node<"float">;
+export declare const colorBrightness: THREE.Node<"float">;
+export declare const isCurrentFloor: THREE.VarNode<"bool">;
+export declare const isRoof: THREE.VarNode<"bool">;
+export declare const isRoofCut: THREE.VarNode<"bool">;
+export declare const pano0Origin: THREE.VarNode<"vec3">;
+export declare const pano0SampleDirection: THREE.VarNode<"vec3">;
+export declare const pano1Origin: THREE.VarNode<"vec3">;
+export declare const pano1SampleDirection: THREE.VarNode<"vec3">;
+export declare const pano0SdrColor: THREE.VarNode<"vec3">;
+export declare const pano1SdrColor: THREE.VarNode<"vec3">;
+export declare const pano0GainColor: THREE.VarNode<"vec3">;
+export declare const pano1GainColor: THREE.VarNode<"vec3">;
+export declare const pano0HdrColor: THREE.VarNode<"vec3">;
+export declare const pano1HdrColor: THREE.VarNode<"vec3">;
+export declare const refinedScreenPano0Color: THREE.VarNode<"vec4">;
+export declare const refinedScreenPano1Color: THREE.VarNode<"vec4">;
+export declare const pano0DepthTrust: THREE.VarNode<"float">;
+export declare const pano1DepthTrust: THREE.VarNode<"float">;
+export declare const gradientColor: THREE.VarNode<"vec3">;
+export declare const floorOpacity: THREE.VarNode<"float">;
+export declare const pano0Color: THREE.VarNode<"vec3">;
+export declare const pano1Color: THREE.VarNode<"vec3">;

package/five/model/materials/tsl/nodeTypes.d.ts

@@ -0,0 +1,12 @@
+/**
+ * nodeTypes.ts — TSL node 类型别名 + 类型化辅助函数
+ */
+import * as THREE from 'three/webgpu';
+export declare function safeFloatAttribute(name: string, defaultValue?: number): THREE.Node<'float'>;
+export declare function mrFloat(name: string): THREE.Node<'float'>;
+export declare function mrVec3(name: string): THREE.Node<'vec3'>;
+export declare function mrVec4(name: string): THREE.Node<'vec4'>;
+export declare function mrMat4(name: string): THREE.Node<'mat4'>;
+export declare function mrCubeTexture(name: string, uvNode: THREE.Node<"vec3">): THREE.Node<"vec4">;
+/** 创建一个带自定义 uvNode 的 texture materialReference */
+export declare function mrTexture(name: string, uvNode: THREE.Node<"vec2">): THREE.Node<"vec4">;

package/five/model/materials/tsl/outputBuilder.d.ts

@@ -0,0 +1,26 @@
+/**
+ * panoOutputBuilder.ts — 全景渲染输出组装
+ *
+ * 核心功能：全景采样 + HDR + RS + filter + depth + transition 输出组装，
+ * 以及 pano 特有的渲染函数（zoomVector, cameraDirection, roofMark,
+ * discardNode, colorNode, opacityNode 等）。
+ * 通用工具函数（rgb2hsv, hsv2rgb, resolutionUniform, pixelRatioUniform）在 utils.ts 中。
+ */
+import * as THREE from 'three/webgpu';
+import type { PBMTransition, PBMColorStyle } from '../pbmMaterial';
+import { IPBMMaterial } from '../pbmMaterial';
+export interface SetupPanoOutputOptions {
+    useVertexMark: boolean;
+    useFloorStyleVisibility: boolean;
+    useGradientTexture: boolean;
+    useRefinedScreen: boolean;
+    usePanoFilter: boolean;
+    usePanoDepth: boolean;
+    useHDR: boolean;
+    colorMode: PBMColorStyle;
+    transition: PBMTransition;
+}
+export declare function setupMeshOutput(material: THREE.NodeMaterial & IPBMMaterial, builder: THREE.NodeBuilder): void;
+export declare function setupMeshPanoOnlyOutput(material: THREE.NodeMaterial & IPBMMaterial, builder: THREE.NodeBuilder): void;
+export declare function setupPointCloudVertex(material: THREE.NodeMaterial & THREE.Material & IPBMMaterial, builder: THREE.NodeBuilder): THREE.Node;
+export declare function setupPointCloudOutput(material: THREE.NodeMaterial & IPBMMaterial, builder: THREE.NodeBuilder): void;

package/five/model/materials/tsl/panoColor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * panoOutputBuilder.ts — 全景渲染输出组装
+ *
+ * 核心功能：全景采样 + HDR + RS + filter + depth + transition 输出组装，
+ * 以及 pano 特有的渲染函数（zoomVector, cameraDirection, roofMark,
+ * discardNode, colorNode, opacityNode 等）。
+ * 通用工具函数（rgb2hsv, hsv2rgb, resolutionUniform, pixelRatioUniform）在 utils.ts 中。
+ */
+import * as THREE from 'three/webgpu';
+import type { PBMTransition } from '../pbmMaterial';
+export declare function panoColor(options: {
+    transition: PBMTransition;
+    usePanoFilter: boolean;
+    useRefinedScreen: boolean;
+    useHDR: boolean;
+    usePanoDepth: boolean;
+}): THREE.TSL.FnNode<[number | THREE.Node], THREE.VarNode<"vec3">>;

package/five/model/materials/tsl/panoTransition.d.ts

@@ -0,0 +1,8 @@
+/**
+ * colorFilter.ts — 全景图滤镜管线（HSL、色温、对比度、LUT）
+ */
+import * as THREE from 'three/webgpu';
+import type { PBMTransition } from '../pbmMaterial';
+export declare function panoTransition(options: {
+    transition: PBMTransition;
+}): THREE.TSL.FnNode<[number | THREE.Node, number | THREE.Node, number | THREE.Node], THREE.VarNode<"vec3">>;

package/five/model/materials/tsl/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * utils.ts — 通用 TSL 工具函数
+ */
+import * as THREE from 'three/webgpu';
+export declare const rgb2hsv: THREE.TSL.FnNode<[number | THREE.Node], THREE.Node<"vec3">>;
+export declare const hsv2rgb: THREE.TSL.FnNode<[number | THREE.Node], THREE.Node<"vec3">>;
+export declare const unpackRGBAToDepth: THREE.TSL.FnNode<[number | THREE.Node], THREE.Node<"float">>;
+export declare const hdrBoost: THREE.TSL.FnNode<[number | THREE.Node, number | THREE.Node, number | THREE.Node, number | THREE.Node, number | THREE.Node, number | THREE.Node, number | THREE.Node], THREE.Node<"vec3">>;
+export declare const zoomVector: THREE.TSL.FnNode<[number | THREE.Node, number | THREE.Node, number | THREE.Node], THREE.Node<"vec3">>;
+/** 计算全景采样方向：用 mat4 矩阵右乘方向向量 (w=0) 得到旋转后的方向 */
+export declare const sampleDirection: THREE.TSL.FnNode<[number | THREE.Node, number | THREE.Node, number | THREE.Node, number | THREE.Node], THREE.Node<"vec3">>;

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

@@ -0,0 +1,172 @@
+import * as THREE from 'three/webgpu';
+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.WebGPURenderer, 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;
+}