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

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

@@ -0,0 +1,69 @@
+import * as THREE from 'three';
+import { Tile } from './tile';
+import type { FrameState } from './types';
+import { TileRequestScheduler } from './tile-request-scheduler';
+import { TileCache } from './tile-cache';
+import { TilesetHeader, TrajectoryHeader } from './header';
+import { Trajectory } from './trajectory';
+export interface TilesetOptions {
+    url?: string;
+    tileLoader: (tile: Tile) => Promise<void>;
+    tileUnloader: (tile: Tile) => Promise<void>;
+    onTileLoad: (tile: Tile) => any;
+    onTileUnload: (tile: Tile) => any;
+    onTileError: (tile: Tile, error: Error) => any;
+    trajectoryLoader: (trajectory: Trajectory) => Promise<void>;
+    trajectoryUnloader: (trajectory: Trajectory) => Promise<void>;
+    onTrajectoryLoad: (trajectory: Trajectory) => any;
+    onTrajectoryUnload: (trajectory: Trajectory) => any;
+    onTrajectoryError: (trajectory: Trajectory, error: Error) => any;
+}
+export declare class Tileset {
+    asset: {
+        version: string;
+        tilesetVersion: string;
+        gltfUpAxis: "Y" | "Z";
+        overview?: {
+            imageFile: string;
+            worldFile: string;
+            imageWidth: number;
+            imageHeight: number;
+        };
+        trajectories?: TrajectoryHeader[];
+        [key: string]: any;
+    };
+    id: string;
+    frameNumber: number;
+    hasMixedContent: boolean;
+    properties: NonNullable<TilesetHeader['properties']>;
+    options: TilesetOptions;
+    root: Tile;
+    rootMeta: NonNullable<TilesetHeader['rootMeta']>;
+    transform: THREE.Matrix4;
+    geometricError: number;
+    cache: TileCache;
+    currentMaxScreenSpaceError: number;
+    requestScheduler: TileRequestScheduler;
+    private cacheMemoryUsageInBytes;
+    private normalTraverser;
+    private skipTraverser;
+    private mostDetailTraverser;
+    loadedTiles: Set<Tile>;
+    needsRefinedTiles: Set<Tile>;
+    requestedTiles: Tile[];
+    selectedTiles: Tile[];
+    unloadTiles: Tile[];
+    trajectories: Trajectory[];
+    selectedTrajectories: Trajectory[];
+    pointLength: number;
+    floorLength: number;
+    constructor(header: TilesetHeader, options: TilesetOptions);
+    /**
+     * 通过当前的内存使用，推测 maxScreenSpaceError
+     */
+    private adjustScreenSpaceError;
+    private getTraverser;
+    /** Release resources */
+    reset(): void;
+    update(frameState: FrameState, cacheFrameStates?: FrameState[]): void;
+}

package/five/model/tile3d/trajectory-content.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from 'three';
+import type { Trajectory } from './trajectory';
+import { Fetcher } from '../../utils/ajax';
+export declare function loadTrajectory<T extends Trajectory>(trajectory: T, options: {
+    fetcher: Fetcher;
+    search?: string;
+    renderer?: THREE.WebGLRenderer;
+}): Promise<T>;
+export declare function unloadTrajectory(trajectory: Trajectory): void;

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

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import type { Camera } from '../../core/camera';
+import type { ModelScene } from '../model-scene';
+import type { ParameterValue } from '../parameter';
+import type { Trajectory } from './trajectory';
+import type { Tile3D } from './index';
+export declare class TrajectoryNode extends THREE.Object3D {
+    name: string;
+    contentObject: THREE.Object3D;
+    private disposers;
+    constructor(name: string, contentObject: THREE.Object3D, disposer?: () => void);
+    update(renderer: THREE.WebGLRenderer, camera: Camera, modelScene: ModelScene, tile3d: Tile3D, trajectory: Trajectory, parameterValue: ParameterValue): boolean;
+    dispose(): void;
+    clone(): this;
+}

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

@@ -0,0 +1,30 @@
+import * as THREE from 'three';
+import type { TrajectoryHeader } from './header';
+import type { TrajectoryNode } from './trajectory-node';
+import type { Tileset } from './tileset';
+export type TrajectoryContentData = {
+    byteLength: number;
+    memoryUsage: number;
+    uri: string;
+    object: TrajectoryNode;
+    positionArray: ArrayLike<number>;
+    timeArray: ArrayLike<number>;
+};
+export declare class Trajectory {
+    id: string;
+    name: string;
+    tileset: Tileset;
+    transform: THREE.Matrix4;
+    visible: boolean;
+    content: {
+        uri: string;
+        data?: TrajectoryContentData;
+        loadState: 'LOADING' | 'UNLOADED' | 'READY' | 'FAILED';
+        loadProgress: number;
+        loadStateUpdateTime: number;
+        loadfailRetryDelay: number;
+        byteLength: number;
+        memoryUsage: number;
+    };
+    constructor(id: string, header: TrajectoryHeader, tileset: Tileset);
+}

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

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+import type { CullingVolume } from '../../utils/volume';
+export type TileRequestOrder = 'SCREEN_SPACE_ERROR' | 'SCREEN_LEVEL_VERTICAL' | 'SCREEN_VERTICAL';
+export type FrameState = {
+    frameNumber: number;
+    time: number;
+    camera: {
+        type: "PerspectiveCamera" | "OrthographicCamera";
+        position: THREE.Vector3;
+        direction: THREE.Vector3;
+        up: THREE.Vector3;
+        projectionMatrix: THREE.Matrix4;
+        visible: boolean;
+        refine: boolean;
+    };
+    height: number;
+    pixelRatio: number;
+    cullingVolume: CullingVolume;
+    sseDenominator: number;
+    minLevelOfDetail: number;
+    maxLevelOfDetail: number;
+    minGeometricError: number;
+    maxGeometricError: number;
+    skipLevelOfDetail: boolean;
+    mostDetail: boolean;
+    loadSiblings: boolean;
+    cameraCulling: boolean;
+    maxRequests: number;
+    requestOrder: TileRequestOrder;
+    maxScreenSpaceError: number;
+    memoryAdjustedScreenSpaceError: boolean;
+    maxMemoryUsage: number;
+};

package/five/model/view-layer.d.ts

@@ -0,0 +1,20 @@
+import { Tile3D } from './tile3d';
+import { WorkModel } from "../work";
+import { TextureOptions } from "../types/imageOptions";
+import { Fetcher } from "../utils/ajax";
+export interface ViewLayer extends Tile3D {
+}
+export interface ViewLayerInit {
+    tilesetUrl: string;
+    name: string;
+    type: "point_cloud" | "mesh" | "gaussian_splatting";
+    upAxis: string;
+    light: boolean;
+    fetcher: Fetcher;
+}
+export declare function loadViewLayer(init: ViewLayerInit): Promise<ViewLayer>;
+export declare function loadViewLayers(workModel: WorkModel, options: {
+    fetcher: Fetcher;
+    light: boolean;
+    textureOptions?: TextureOptions;
+}): Promise<ViewLayer[]>;

package/five/renderer/five-renderer.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import { type Scene } from '../core/scene';
+import { type Camera } from '../core/camera';
+import { type ModelScene } from '../model';
+import { EffectComposer } from './postprocessing/composer';
+export declare class FiveRenderer {
+    composer: EffectComposer;
+    composerVersion: string;
+    colorRenderTarget: THREE.WebGLRenderTarget;
+    normalRenderTarget: THREE.WebGLRenderTarget;
+    renderMode: 'default' | 'ssaa' | 'point-cloud-high-quality';
+    private sceneRenders;
+    constructor();
+    private renderSceneToBuffers;
+    render(renderer: THREE.WebGLRenderer, scene: Scene, modelScene: ModelScene, camera: Camera, sceneUpdated: boolean): boolean;
+    dispose(): void;
+}

package/five/renderer/index.d.ts

@@ -0,0 +1,3 @@
+export { EffectComposer, FivePass, type Pass, AdaptiveLuminancePass, EyeDomeLightingPass } from './postprocessing';
+export { FullScreenQuad } from './tools/full-screen-quad';
+export { FiveRenderer } from './five-renderer';

package/five/renderer/postprocessing/composer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * Converted to TypeScript
+ */
+import * as THREE from 'three';
+import { type Pass } from './passes/pass';
+/**
+ * EffectComposer
+ *
+ * 基于three.js的EffectComposer，用于管理后处理pass的渲染流程
+ */
+export declare class EffectComposer {
+    renderTarget1: THREE.WebGLRenderTarget;
+    renderTarget2: THREE.WebGLRenderTarget;
+    writeBuffer: THREE.WebGLRenderTarget;
+    readBuffer: THREE.WebGLRenderTarget;
+    passes: Pass[];
+    normalMaterial: THREE.MeshNormalMaterial;
+    clock: THREE.Clock;
+    renderToScreen: boolean;
+    status: {
+        endabledPassNumber: number;
+        needsColorGBuffer: boolean;
+        needsDepthGBuffer: boolean;
+        needsNormalGBuffer: boolean;
+        version: string;
+    };
+    gbuffer: Map<'depth' | 'normal' | 'color', THREE.Texture>;
+    constructor();
+    swapBuffers(): void;
+    addPass(pass: Pass): void;
+    insertPass(pass: Pass, index: number): void;
+    render(renderer: THREE.WebGLRenderer): boolean;
+    setSize(width: number, height: number): void;
+    updateStatus(): void;
+    dispose(): void;
+}

package/five/renderer/postprocessing/index.d.ts

@@ -0,0 +1,7 @@
+export { EffectComposer } from './composer';
+export { type Pass, FivePass } from './passes/pass';
+export { AdaptiveLuminancePass } from './passes/adaptive-luminance-pass';
+export { EyeDomeLightingPass } from './passes/eye-dome-lighting-pass';
+export { GaussianBlurPass } from './passes/gaussian-blur-pass';
+export { FlowingLight2DPass } from './passes/flowing-light-2d-pass';
+export { FlowingLight3DPass } from './passes/flowing-light-3d-pass';

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

@@ -0,0 +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;
+    constructor();
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget, deltaTime: number, maskActive?: boolean): void;
+    clearBuffer(): void;
+    dispose(): void;
+}

package/five/renderer/postprocessing/passes/eye-dome-lighting-pass.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+import { FivePass } from './pass';
+import { type Camera } from '../../../core/camera';
+export declare class EyeDomeLightingPass extends FivePass {
+    strength: number;
+    radius: number;
+    neighbours: number;
+    private camera;
+    private fsQuad;
+    private material;
+    constructor(camera: Camera);
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget, deltaTime: number, maskActive?: boolean): void;
+    dispose(): void;
+}

package/five/renderer/postprocessing/passes/flowing-light-2d-pass.d.ts

@@ -0,0 +1,36 @@
+import * as THREE from 'three';
+import { FivePass } from './pass';
+import { type Camera } from '../../../core/camera';
+type Line = {
+    id?: string;
+    points: THREE.Vector2[];
+    totalLength: number;
+    color: THREE.Color;
+    opacity?: number;
+    duration?: number;
+    delay?: number;
+    lineWidth?: number;
+    tailLengthRatio?: number;
+};
+export declare class FlowingLight2DPass extends FivePass {
+    private camera;
+    private mesh;
+    private material;
+    private uTime;
+    private lines;
+    private lineScene;
+    private orthoCamera;
+    private lineRenderTarget;
+    private blendMaterial;
+    private blendQuad;
+    constructor(camera: Camera);
+    setLines(lines: Line[]): void;
+    setLine(params: {
+        id: string;
+    } & Partial<Omit<Line, 'id'>>): void;
+    private _updateLineAttributes;
+    private _rebuildMesh;
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget, deltaTime: number, maskActive?: boolean): void;
+    dispose(): void;
+}
+export {};

package/five/renderer/postprocessing/passes/flowing-light-3d-pass.d.ts

@@ -0,0 +1,36 @@
+import * as THREE from 'three';
+import { FivePass } from './pass';
+import { type Camera } from '../../../core/camera';
+type Line = {
+    id?: string;
+    points: THREE.Vector3[];
+    totalLength: number;
+    color: THREE.Color;
+    opacity?: number;
+    duration?: number;
+    delay?: number;
+    lineWidth?: number;
+    tailLengthRatio?: number;
+};
+export declare class FlowingLight3DPass extends FivePass {
+    private camera;
+    private mesh;
+    private material;
+    private uTime;
+    private lines;
+    private lineScene;
+    private orthoCamera;
+    private lineRenderTarget;
+    private blendMaterial;
+    private blendQuad;
+    constructor(camera: Camera);
+    setLines(lines: Line[]): void;
+    setLine(params: {
+        id: string;
+    } & Partial<Omit<Line, 'id'>>): void;
+    private _updateLineAttributes;
+    private _rebuildMesh;
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget, deltaTime: number, maskActive?: boolean): void;
+    dispose(): void;
+}
+export {};

package/five/renderer/postprocessing/passes/gaussian-blur-pass.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+import { FivePass } from './pass';
+import { type Camera } from '../../../core/camera';
+export declare class GaussianBlurPass extends FivePass {
+    private camera;
+    private fsQuad;
+    material: THREE.ShaderMaterial;
+    constructor(camera: Camera);
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget, deltaTime: number, maskActive?: boolean): void;
+    setRadius(radius: number): void;
+    dispose(): void;
+}

package/five/renderer/postprocessing/passes/pass.d.ts

@@ -0,0 +1,38 @@
+import * as THREE from 'three';
+import { FullScreenQuad } from '../../tools/full-screen-quad';
+/**
+ * Pass基类
+ * three.js 的 Pass 接口，用于 EffectComposer
+ */
+export interface Pass {
+    enabled: boolean;
+    needsSwap: boolean;
+    clear: boolean;
+    renderToScreen: boolean;
+    setSize(width: number, height: number): void;
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget, deltaTime?: number, maskActive?: boolean): void;
+}
+/**
+ * FivePass
+ *
+ * Five 引擎优化的 Pass 基类
+ * 支持 G-Buffer 注入，避免重复渲染场景
+ */
+export declare class FivePass implements Pass {
+    static FullScreenQuad: typeof FullScreenQuad;
+    enabled: boolean;
+    needsSwap: boolean;
+    clear: boolean;
+    renderToScreen: boolean;
+    dependencies: ('depth' | 'normal' | 'color')[];
+    /**
+     * G-Buffer 纹理集合
+     * 包含 depth、normal、color 等纹理
+     * 由 EffectComposer 在 render 时注入
+     */
+    gbuffer: Map<'depth' | 'normal' | 'color', THREE.Texture>;
+    constructor(dependencies?: ('depth' | 'normal' | 'color')[]);
+    setSize(width: number, height: number): void;
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget, deltaTime?: number, maskActive?: boolean): void;
+    dispose(): void;
+}

package/five/renderer/scene-renderers/point-cloud-high-quality-scene-renderer.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import { type Scene } from '../../core/scene';
+import { type Camera } from '../../core/camera';
+import { type ModelScene } from '../../model';
+import { SceneRenderer } from './scene-renderer';
+export declare class PointCloudHighQualitySceneRnderer extends SceneRenderer {
+    name: string;
+    private tempRenderTarget;
+    clearBuffers(): void;
+    render(renderer: THREE.WebGLRenderer, scene: Scene, modelScene: ModelScene, camera: Camera, sceneUpdated: boolean, renderTarget: THREE.WebGLRenderTarget | null): boolean;
+}

package/five/renderer/scene-renderers/scene-renderer.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from 'three';
+import { type Scene } from '../../core/scene';
+import { type Camera } from '../../core/camera';
+import { type ModelScene } from '../../model';
+export declare class SceneRenderer {
+    name: string;
+    clearBuffers(): void;
+    render(renderer: THREE.WebGLRenderer, scene: Scene, modelScene: ModelScene, camera: Camera, sceneUpdated: boolean, renderTarget: THREE.WebGLRenderTarget | null): boolean;
+}

package/five/renderer/scene-renderers/ssaa-scene-renderer.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import { type Scene } from '../../core/scene';
+import { type Camera } from '../../core/camera';
+import { type ModelScene } from '../../model';
+import { SceneRenderer } from './scene-renderer';
+export declare function renderSample(renderer: THREE.WebGLRenderer, source: THREE.Texture, weight: number): void;
+export declare class SSAASceneRnderer extends SceneRenderer {
+    name: string;
+    sampleLevel: number;
+    unbiased: boolean;
+    protected sampleRenderTarget: THREE.WebGLRenderTarget | null;
+    clearBuffers(): void;
+    render(renderer: THREE.WebGLRenderer, scene: Scene, modelScene: ModelScene, camera: Camera, sceneUpdated: boolean, renderTarget: THREE.WebGLRenderTarget | null): boolean;
+}
+export declare const JitterVectors: number[][][];

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

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+/**
+ * 用于全屏渲染的辅助类
+ */
+export declare class FullScreenQuad<T extends THREE.Material = THREE.Material> {
+    private static camera;
+    private static geometry;
+    private _scene;
+    private _mesh;
+    constructor(material: T);
+    get material(): T;
+    set material(value: T);
+    dispose(): void;
+    render(renderer: THREE.WebGLRenderer): void;
+}

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

@@ -0,0 +1,2 @@
+import * as THREE from 'three';
+export declare function renderFullScreenDepth(renderer: THREE.WebGLRenderer, depthTexture: THREE.Texture): void;

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

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

package/five/texture/imageBitmap.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+export type ImageBitmapLikeImage = HTMLImageElement & {
+    close: () => void;
+};
+export type ImageBitmapLike = ImageBitmap | ImageBitmapLikeImage;
+export declare function useNativeImageBitmap(enable: boolean): void;
+export declare function canUseNativeImageBitmap(): boolean;
+export declare function createImageBitmapLikeImage(options?: {
+    onClose?: (this: ImageBitmapLikeImage) => void;
+}): ImageBitmapLikeImage;
+export declare function createImageBitmapLike(blob: Blob): Promise<ImageBitmapLike>;
+export declare function imageBitmapToTexture(image: ImageBitmapLike, maxSize?: THREE.Vector2): THREE.Texture;
+export declare function imageBitmapsToCubeTexture(images: ImageBitmapLike[]): THREE.CubeTexture;

package/five/texture/initTexture.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from "three";
+export declare function initTexture<T extends THREE.Texture>(texture: T, renderer: THREE.WebGLRenderer): Promise<T>;
+export declare function initTextures<T extends THREE.Texture[]>(textures: T, renderer: THREE.WebGLRenderer): Promise<T>;

package/five/texture/loader.d.ts

@@ -0,0 +1,39 @@
+import * as THREE from "three";
+import { CubeFace } from '../types/cube';
+import { ImageURLOptions } from '../utils/imageURL';
+import { Fetcher, NetworkResponse, NetWorkMeta } from "../utils/ajax";
+export declare class TextureLoader {
+    loadTexture(source: string, options: {
+        imageURL?: {
+            transform?: (source: string, options: ImageURLOptions) => string;
+            options?: ImageURLOptions;
+        };
+        flipY?: boolean;
+        format?: THREE.PixelFormat;
+        encoding?: THREE.TextureEncoding;
+        minFilter?: THREE.TextureFilter;
+        magFilter?: THREE.TextureFilter;
+        generateMipmaps?: boolean;
+        wrapS?: THREE.Wrapping;
+        wrapT?: THREE.Wrapping;
+        maxSize?: THREE.Vector2;
+        viaAjax?: boolean;
+        timeout?: number;
+        fetcher: Fetcher;
+    }, onLoad?: (response: NetworkResponse<THREE.Texture>) => void, onError?: (error: Error) => void, onProgress?: (percent: number) => void, renderer?: THREE.WebGLRenderer): Promise<NetworkResponse<THREE.Texture>>;
+    loadCubeTexture(sources: Record<CubeFace, string>, options: {
+        imageURL?: {
+            transform?: (source: string, options: ImageURLOptions) => string;
+            options?: ImageURLOptions;
+        };
+        format?: THREE.PixelFormat;
+        minFilter?: THREE.TextureFilter;
+        magFilter?: THREE.TextureFilter;
+        generateMipmaps?: boolean;
+        wrapS?: THREE.Wrapping;
+        wrapT?: THREE.Wrapping;
+        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[]>>;
+}