@realsee/five 6.8.0-alpha.2 → 6.8.0-alpha.21

package/five/model/tile3d/tileset-base-traverser.d.ts

@@ -0,0 +1,59 @@
+import type { Tileset } from './tileset';
+import type { Tile } from './tile';
+import type { FrameState } from './types';
+export declare class ManagedArray<T> {
+    private map;
+    private array;
+    private _length;
+    constructor();
+    /**
+     * Gets or sets the length of the array.
+     * If the set length is greater than the length of the internal array, the internal array is resized.
+     * @type Number
+     */
+    get length(): number;
+    /**
+     * Gets the element at an index.
+     * @param index - The index to get.
+     */
+    get(index: number): T;
+    /**
+     * Sets the element at an index. Resizes the array if index is greater than the length of the array.
+     * @param index - The index to set.
+     * @param element - The element to set at index.
+     */
+    set(index: number, element: T): void;
+    delete(element: T): void;
+    /**
+     * Push an element into the array.
+     * @param element - The element to push.
+     */
+    push(element: T): void;
+    /**
+     * Pop an element from the array.
+     *
+     * @returns The last element in the array.
+     */
+    pop(): T;
+    reset(): void;
+    find(target: T): boolean;
+    peek(): T | undefined;
+}
+declare class TilesetBaseTraverser {
+    tileset: Tileset;
+    protected _canSelectTile: boolean;
+    private _loadAllTilesTraversalStack;
+    constructor(tileset: Tileset);
+    traverse(root: Tile, frameState: FrameState, cacheFrameStates?: FrameState[]): void;
+    reset(): void;
+    protected updateTile(tile: Tile, frameState: FrameState): void;
+    protected selectTile(tile: Tile, frameState: FrameState): void;
+    protected loadTile(tile: Tile, frameState: FrameState): void;
+    protected touchTile(tile: Tile, frameState: FrameState): void;
+    protected canTraverse(tile: Tile, frameState: FrameState): boolean;
+    protected updateTileVisibility(tile: Tile, frameState: FrameState): void;
+    protected anyChildrenVisible(tile: Tile, frameState: FrameState): boolean;
+    protected meetsScreenSpaceErrorEarly(tile: Tile, frameState: FrameState): boolean;
+    protected sortTilesByDistanceToCamera(tiles: Tile[]): void;
+}
+export { TilesetBaseTraverser };

package/five/model/tile3d/tileset-most-detail-traverser.d.ts

@@ -0,0 +1,14 @@
+import type { Tileset } from './tileset';
+import type { Tile } from './tile';
+import type { FrameState } from './types';
+import { TilesetBaseTraverser } from './tileset-base-traverser';
+export declare class TilesetMostDetailTraverser extends TilesetBaseTraverser {
+    private _traversalStack;
+    constructor(tileset: Tileset);
+    protected canTraverse(tile: Tile, frameState: FrameState): boolean;
+    traverse(root: Tile, frameState: FrameState, cacheFrameStates: FrameState[]): void;
+    reset(): void;
+    private executeTraversal;
+    private updateAndPushChildren;
+    private selectDesiredTile;
+}

package/five/model/tile3d/tileset-normal-traverser.d.ts

@@ -0,0 +1,15 @@
+import type { Tileset } from './tileset';
+import type { Tile } from './tile';
+import type { FrameState } from './types';
+import { TilesetBaseTraverser } from './tileset-base-traverser';
+export declare class TilesetNormalTraverser extends TilesetBaseTraverser {
+    private _traversalStack;
+    private _emptyTraversalStack;
+    constructor(tileset: Tileset);
+    traverse(root: Tile, frameState: FrameState, cacheFrameStates?: FrameState[]): void;
+    reset(): void;
+    private executeTraversal;
+    private updateAndPushChildren;
+    private selectDesiredTile;
+    private executeEmptyTraversal;
+}

package/five/model/tile3d/tileset-skip-traverser.d.ts

@@ -0,0 +1,60 @@
+import type { Tileset } from './tileset';
+import type { Tile } from './tile';
+import type { FrameState } from './types';
+import { TilesetBaseTraverser } from './tileset-base-traverser';
+declare class TilesetSkipTraverser extends TilesetBaseTraverser {
+    private baseScreenSpaceError;
+    private skipScreenSpaceErrorFactor;
+    private skipLevels;
+    private _traversalStack;
+    private _descendantTraversalStack;
+    private _selectionTraversalStack;
+    private _selectionTraversalancestorStack;
+    constructor(tileset: Tileset);
+    traverse(root: Tile, frameState: FrameState, cacheFrameStates?: FrameState[]): void;
+    reset(): void;
+    private executeTraversal;
+    private updateAndPushChildren;
+    private selectDesiredTile;
+    /**
+     * Mark descendant tiles for rendering, and update as needed
+     */
+    private selectDescendants;
+    /**
+     * Determine if a tile has reached the limit of level of detail skipping.
+     * If so, it should _not_ be skipped: it should be loaded and rendered
+     *
+     * @private
+     * @param {Cesium3DTileset} tileset
+     * @param {Cesium3DTile} tile
+     * @returns {boolean} true if this tile should not be skipped
+     */
+    private reachedSkippingThreshold;
+    /**
+     * Update links to the ancestor tiles that have content
+     */
+    private updateTileAncestorContentLinks;
+    /**
+     * Determine if a tile is part of the base traversal.
+     * If not, this tile could be considered for level of detail skipping
+     */
+    private inBaseTraversal;
+    /**
+     * Traverse the tree and check if their selected frame is the current frame. If so, add it to a selection queue.
+     * This is a preorder traversal so children tiles are selected before ancestor tiles.
+     *
+     * The reason for the preorder traversal is so that tiles can easily be marked with their
+     * selection depth. A tile's _selectionDepth is its depth in the tree where all non-selected tiles are removed.
+     * This property is important for use in the stencil test because we want to render deeper tiles on top of their
+     * ancestors. If a tileset is very deep, the depth is unlikely to fit into the stencil buffer.
+     *
+     * We want to select children before their ancestors because there is no guarantee on the relationship between
+     * the children's z-depth and the ancestor's z-depth. We cannot rely on Z because we want the child to appear on top
+     * of ancestor regardless of true depth. The stencil tests used require children to be drawn first.
+     *
+     * NOTE: 3D Tiles uses 3 bits from the stencil buffer meaning this will not work when there is a chain of
+     * selected tiles that is deeper than 7. This is not very likely.
+     */
+    private traverseAndSelect;
+}
+export { TilesetSkipTraverser };

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,17 @@
+import * as THREE from 'three';
+import { FivePass } from './pass';
+export declare class AdaptiveLuminancePass extends FivePass {
+    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;
+    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-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-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, flipY?: boolean, opacity?: number): void;