@roomle/web-sdk 2.91.0-alpha.1 → 2.91.0-alpha.3

package/lib/definitions/packages/common-core/src/webgl/renderer/pass/outline-pass.d.ts

@@ -0,0 +1,64 @@
+import { RenderPass } from './render-pass';
+import type { RenderPassManager } from '../render-pass-manager';
+import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
+import type { Camera, Object3D, Scene, Texture, WebGLRenderer } from 'three';
+import { Color, Matrix4, ShaderMaterial, Vector2, WebGLRenderTarget } from 'three';
+export interface OutlinePassParameters {
+    downSampleRatio?: number;
+    edgeDetectionFxaa?: boolean;
+}
+export declare class OutlinePass extends RenderPass {
+    static BlurDirectionX: Vector2;
+    static BlurDirectionY: Vector2;
+    static highlightLines: boolean;
+    renderScene: Scene;
+    renderCamera: Camera;
+    selectedObjects: Object3D[];
+    visibleEdgeColor: Color;
+    hiddenEdgeColor: Color;
+    edgeGlow: number;
+    usePatternTexture: boolean;
+    patternTexture: Texture | null;
+    edgeThickness: number;
+    edgeStrength: number;
+    downSampleRatio: number;
+    pulsePeriod: number;
+    edgeDetectionFxaa: boolean;
+    _visibilityCache: Map<Object3D, boolean>;
+    resolution: Vector2;
+    renderTargetMaskBuffer: WebGLRenderTarget;
+    prepareMaskMaterial: ShaderMaterial;
+    renderTargetFxaaBuffer?: WebGLRenderTarget;
+    fxaaRenderMaterial?: ShaderMaterial;
+    renderTargetMaskDownSampleBuffer: WebGLRenderTarget;
+    renderTargetBlurBuffer1: WebGLRenderTarget;
+    renderTargetBlurBuffer2: WebGLRenderTarget;
+    edgeDetectionMaterial: ShaderMaterial;
+    renderTargetEdgeBuffer1: WebGLRenderTarget;
+    renderTargetEdgeBuffer2: WebGLRenderTarget;
+    separableBlurMaterial1: ShaderMaterial;
+    separableBlurMaterial2: ShaderMaterial;
+    overlayMaterial: ShaderMaterial;
+    copyUniforms: any;
+    materialCopy: ShaderMaterial;
+    oldClearColor: Color;
+    oldClearAlpha: number;
+    fsQuad: FullScreenQuad;
+    tempPulseColor1: Color;
+    tempPulseColor2: Color;
+    textureMatrix: Matrix4;
+    clearBackground: boolean;
+    constructor(renderPassManager: RenderPassManager, resolution: Vector2, scene: Scene, camera: Camera, selectedObjects: Object3D[], parameters?: OutlinePassParameters);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    private _canBeHighlighted;
+    private _changeVisibilityOfSelectedObjects;
+    private _changeVisibilityOfNonSelectedObjects;
+    private _updateTextureMatrix;
+    render(renderer: WebGLRenderer, _writeBuffer: WebGLRenderTarget | null, readBuffer: WebGLRenderTarget | null, _deltaTime: number, maskActive: boolean): void;
+    renderPass(renderer: WebGLRenderer): void;
+    private _getPrepareMaskMaterial;
+    private _getEdgeDetectionMaterial;
+    private _getSeperableBlurMaterial;
+    private _getOverlayMaterial;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/pass/pass-utility.d.ts

@@ -0,0 +1,12 @@
+import type { Enumify } from '../../../types';
+export declare const NORMAL_VECTOR_SOURCE_TYPES: {
+    readonly INPUT_RGB_NORMAL: "inputRgbNormal";
+    readonly FLOAT_BUFFER_NORMAL: "floatBufferNormal";
+    readonly CONSTANT_Z: "constantZ";
+};
+export type NormalVectorSourceType = Enumify<typeof NORMAL_VECTOR_SOURCE_TYPES>;
+export declare const DEPTH_VALUE_SOURCE_TYPES: {
+    readonly SEPARATE_BUFFER: "separateBuffer";
+    readonly NORMAL_VECTOR_ALPHA: "normalVectorAlpha";
+};
+export type DepthValueSourceType = Enumify<typeof DEPTH_VALUE_SOURCE_TYPES>;

package/lib/definitions/packages/common-core/src/webgl/renderer/pass/poisson-denoise-pass.d.ts

@@ -0,0 +1,68 @@
+import type { DenoisePass } from './../render-utility';
+import type { NormalVectorSourceType, DepthValueSourceType } from './pass-utility';
+import { type Camera, type Texture, type WebGLRenderer } from 'three';
+import { Box3, WebGLRenderTarget } from 'three';
+export interface PoissonDenoisePassParameters {
+    [key: string]: any;
+    iterations: number;
+    samples: number;
+    rings: number;
+    radiusExponent: number;
+    radius: number;
+    lumaPhi: number;
+    depthPhi: number;
+    normalPhi: number;
+    nvOrientatedSamples?: boolean;
+}
+export declare const defaultPoissonDenoisePassParameters: PoissonDenoisePassParameters;
+export interface PoissonDenoiseParameters {
+    poissonDenoisePassParameters?: PoissonDenoisePassParameters;
+    normalVectorSourceType?: NormalVectorSourceType;
+    depthValueSourceType?: DepthValueSourceType;
+    rgInputTexture?: boolean;
+    luminanceWeighted?: boolean;
+    luminanceType?: string;
+    sampleLuminance?: string;
+    fragmentOutput?: string;
+    inputTexture?: Texture;
+    depthTexture?: Texture;
+    normalTexture?: Texture;
+}
+export declare class PoissonDenoiseRenderPass implements DenoisePass {
+    needsUpdate: boolean;
+    parameters: PoissonDenoisePassParameters;
+    private _width;
+    private _height;
+    private _samples;
+    private _normalVectorSourceType;
+    private _depthValueSourceType;
+    _inputTexture: Texture | null;
+    depthTexture: Texture | null;
+    normalTexture: Texture | null;
+    private _noiseTexture;
+    private _pdMaterial?;
+    private _renderTargets;
+    private _outputRenderTargetIndex;
+    private _passRenderer;
+    private _sceneClipBox;
+    private _rgInputTexture;
+    private _luminanceWeighted;
+    private _luminanceType;
+    private _sampleLuminance;
+    private _fragmentOutput;
+    get texture(): Texture | null;
+    set inputTexture(texture: Texture | null);
+    constructor(width: number, height: number, samples: number, parameters?: PoissonDenoiseParameters);
+    private _getNoiseTexture;
+    private _getMaterial;
+    private _updateShader;
+    private _updateUniforms;
+    private _getRenderTargets;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateBounds(sceneClipBox: Box3): void;
+    updateParameters(parameters: PoissonDenoisePassParameters): void;
+    updateTextures(parameters: PoissonDenoiseParameters): void;
+    render(renderer: WebGLRenderer, camera: Camera): void;
+    renderToTarget(renderer: WebGLRenderer, camera: Camera, renderTarget: WebGLRenderTarget): void;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/pass/render-pass.d.ts

@@ -0,0 +1,18 @@
+import type { PassRenderer } from '../render-utility';
+import type { RenderCacheManager } from '../render-cache';
+import type { RenderPassManager } from '../render-pass-manager';
+import type { GBufferTextures } from './gbuffer-render-pass';
+import type { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Pass } from 'three/examples/jsm/postprocessing/Pass';
+export declare abstract class RenderPass extends Pass {
+    private _renderPassManager;
+    protected get renderPassManager(): RenderPassManager;
+    protected get renderCacheManager(): RenderCacheManager;
+    protected get scene(): Scene;
+    protected get camera(): Camera;
+    protected get gBufferTextures(): GBufferTextures;
+    protected get passRenderer(): PassRenderer;
+    constructor(renderPassManager: RenderPassManager);
+    render(renderer: WebGLRenderer, _writeBuffer: WebGLRenderTarget, _readBuffer: WebGLRenderTarget, _deltaTime: number, _maskActive: boolean): void;
+    abstract renderPass(renderer: WebGLRenderer): void;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/pass/scene-render-pass.d.ts

@@ -0,0 +1,12 @@
+import { RenderPass } from './render-pass';
+import type { RenderPassManager } from '../render-pass-manager';
+import type { WebGLRenderer } from 'three';
+import { MeshStandardMaterial } from 'three';
+export declare class SceneRenderPass extends RenderPass {
+    drawGround: boolean;
+    drawWithDebugMaterial: boolean;
+    grayDebugMaterial: MeshStandardMaterial;
+    constructor(renderPassManager: RenderPassManager);
+    dispose(): void;
+    renderPass(renderer: WebGLRenderer): void;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/pass/screen-space-shadow-map-pass.d.ts

@@ -0,0 +1,208 @@
+import { RenderPass } from './render-pass';
+import type { RenderPassManager } from '../render-pass-manager';
+import type { SceneVolume } from '../render-utility';
+import type { LightSource } from '../light-source-detection';
+import { ObjectRenderCache } from '../render-cache';
+import type { Enumify } from '../../../types';
+import type { Box3, Layers, Light, Object3D, RectAreaLight, ShadowMapType, Texture, WebGLRenderer, Mesh } from 'three';
+import { Vector2, Vector3 } from 'three';
+export declare const SHADOW_LIGHT_SOURCE_TYPES: {
+    readonly DIRECTION_LIGHT_SHADOW: "DirectionalLightShadow";
+    readonly SPOT_LIGHT_SHADOW: "SpotLightShadow";
+};
+export type ShadowLightSourceType = Enumify<typeof SHADOW_LIGHT_SOURCE_TYPES>;
+export interface ScreenSpaceShadowMapParameters {
+    [key: string]: any;
+    alwaysUpdate: boolean;
+    enableShadowMap: boolean;
+    enableGroundBoundary: boolean;
+    layers: Layers | null;
+    shadowLightSourceType: ShadowLightSourceType;
+    maximumNumberOfLightSources: number;
+    directionalDependency: number;
+    directionalExponent: number;
+    groundBoundary: number;
+    fadeOutDistance: number;
+    fadeOutBlur: number;
+}
+export declare const defaultScreenSpaceShadowMapParameters: ScreenSpaceShadowMapParameters;
+interface ActiveShadowLight {
+    light: Light;
+    intensity: number;
+    groundShadow: boolean;
+}
+export interface ShadowLightSource {
+    getPosition(): Vector3;
+    getShadowLight(): Light;
+    getOriginalLight(): Light | null;
+    dispose(): void;
+    addTo(object: Object3D): void;
+    removeFrom(object: Object3D): void;
+    updatePositionAndTarget(): void;
+    updateBounds(sceneBounds: SceneVolume): void;
+    forceShadowUpdate(): void;
+    _updateShadowType(typeParameters: ShadowTypeParameters, shadowScale: number): void;
+    prepareRenderShadow(): ActiveShadowLight[];
+    finishRenderShadow(): void;
+}
+export interface ScreenSpaceShadowMapConstructorParameters {
+    samples?: number;
+    shadowMapSize?: number;
+    alwaysUpdate?: boolean;
+    enableShadowMap?: boolean;
+    layers?: Layers | null;
+    shadowLightSourceType?: ShadowLightSourceType;
+    maximumNumberOfLightSources?: number;
+    directionalDependency?: number;
+    directionalExponent?: number;
+    groundBoundary?: number;
+    fadeOutDistance?: number;
+    fadeOutBlur?: number;
+}
+export declare class ScreenSpaceShadowMapPass extends RenderPass {
+    parameters: ScreenSpaceShadowMapParameters;
+    needsUpdate: boolean;
+    drawGround: boolean;
+    shadowTypeNeedsUpdate: boolean;
+    shadowConfiguration: ShadowTypeConfiguration;
+    private _shadowLightSources;
+    private _shadowMapPassOverrideMaterialCache;
+    private _viewportSize;
+    private _samples;
+    private _shadowScale;
+    private _groundMapScale;
+    private _shadowMapSize;
+    castShadow: boolean;
+    private _shadowRenderTarget;
+    private _cameraUpdate;
+    get shadowTexture(): Texture;
+    set shadowOnGround(value: boolean);
+    constructor(renderPassManager: RenderPassManager, viewportSize: Vector2, parameters: ScreenSpaceShadowMapConstructorParameters);
+    private _getScreenSpaceShadowMapParameters;
+    dispose(): void;
+    updateParameters(parameters: ScreenSpaceShadowMapParameters): void;
+    updateBounds(sceneBounds: SceneVolume, scaleShadow: number): void;
+    forceShadowUpdate(): void;
+    getShadowLightSources(): Light[];
+    findShadowLightSource(lightSource: Light): Light | undefined;
+    addRectAreaLight(rectAreaLight: RectAreaLight, parent: Object3D): void;
+    updateRectAreaLights(rectAreaLights: RectAreaLight[], parent: Object3D): void;
+    createShadowFromLightSources(parent: Object3D, lightSources: LightSource[]): void;
+    private _addShadowFromLightSources;
+    private _createShadowLightSourceArray;
+    setSize(width: number, height: number): void;
+    updatePositionAndTarget(): void;
+    renderPass(renderer: WebGLRenderer): void;
+    private _renderSimpleShadowMapFromShadowLightSources;
+    private _getSortedShadowLightSources;
+    private _setShadowLightSourcesIntensity;
+    private _updateShadowType;
+    switchType(type: string): boolean;
+}
+export declare const SHADOW_MATERIAL_TYPE: {
+    readonly DEFAULT: "default";
+    readonly UNLIT: "unlit";
+    readonly EMISSIVE: "emissive";
+    readonly SHADOW: "shadow";
+};
+export type ShadowMaterialType = Enumify<typeof SHADOW_MATERIAL_TYPE>;
+export declare class ShadowMapPassOverrideMaterialCache extends ObjectRenderCache {
+    static useModifiedMaterial: boolean;
+    private _shadowObjectMaterial;
+    private _unlitMaterial;
+    private _emissiveMaterial;
+    private _receiveShadowMaterial;
+    private _boundingBoxSet;
+    private _shadowOnGround;
+    set shadowOnGround(value: boolean);
+    constructor();
+    dispose(): void;
+    setShadowParameters(enableGroundBoundary: boolean, directionalDependency: number, directionalExponent: number, groundBoundary: number, groundMapScale: number, distance: number, blur: number): void;
+    setBoundingBox(box: Box3): void;
+    private _createShadowMaterial;
+    private _createCustomerShadowMaterial;
+    addLineOrPoint(object3d: Object3D): void;
+    addMesh(mesh: Mesh): void;
+    addObject(object3d: Object3D): void;
+    private _setMeshMaterialAndVisibility;
+    private _setShadowMaterialForOpaqueObject;
+    private _setMeshShadowStandardMaterial;
+    private _setMeshShadowFloorMaterial;
+}
+export interface ShadowTypeParameters {
+    castShadow: boolean;
+    type: ShadowMapType;
+    bias: number;
+    normalBias: number;
+    radius: number;
+}
+export declare class ShadowTypeConfiguration {
+    private static _noShadow;
+    private static _basicShadow;
+    private static _pcfShadow;
+    private static _pcfSoftShadow;
+    private static _vcmShadow;
+    types: Map<string, ShadowTypeParameters>;
+    private static _defaultType;
+    shadowType: string;
+    currentConfiguration: ShadowTypeParameters;
+    switchType(type: any): boolean;
+}
+export interface BaseShadowLightSourceParameters {
+    shadowMapSize?: number;
+    blurSamples?: number;
+}
+declare abstract class BaseShadowLightSource implements ShadowLightSource {
+    protected _shadowLightSource: Light;
+    protected _shadowMapSize: number;
+    protected _blurSamples: number;
+    protected _isVisibleBackup: boolean;
+    protected _castShadowBackup: boolean;
+    constructor(lightSource: Light, parameters: BaseShadowLightSourceParameters);
+    getPosition(): Vector3;
+    getShadowLight(): Light;
+    getOriginalLight(): Light | null;
+    dispose(): void;
+    addTo(parent: Object3D): void;
+    removeFrom(parent: Object3D): void;
+    updatePositionAndTarget(): void;
+    updateBounds(sceneBounds: SceneVolume): void;
+    forceShadowUpdate(): void;
+    protected _updateShadowPositionAndTarget(cameraPosition: Vector3, targetPosition: Vector3): void;
+    _updateShadowType(typeParameters: ShadowTypeParameters, shadowScale: number): void;
+    prepareRenderShadow(): ActiveShadowLight[];
+    finishRenderShadow(): void;
+}
+export interface DirectionalShadowLightSourceParameters extends BaseShadowLightSourceParameters {
+    shadowLightSourceType?: ShadowLightSourceType;
+    addHelper?: boolean;
+}
+export declare class RectAreaShadowLightSource extends BaseShadowLightSource {
+    private _rectAreaLight;
+    private _rectLightHelper?;
+    constructor(rectAreaLight: RectAreaLight, parameters: DirectionalShadowLightSourceParameters);
+    getPosition(): Vector3;
+    getRectAreaLight(): RectAreaLight;
+    getOriginalLight(): Light | null;
+    prepareRenderShadow(): ActiveShadowLight[];
+    finishRenderShadow(): void;
+}
+export interface EnvironmentShadowLightSourceParameters extends BaseShadowLightSourceParameters {
+    shadowLightSourceType?: ShadowLightSourceType;
+}
+export declare class EnvironmentShadowLightSource extends BaseShadowLightSource {
+    private _position;
+    private _intensity;
+    constructor(position: Vector3, lightIntensity: number, parameters: EnvironmentShadowLightSourceParameters);
+    getPosition(): Vector3;
+    prepareRenderShadow(): ActiveShadowLight[];
+    finishRenderShadow(): void;
+}
+export declare class GroundShadowLightSource extends BaseShadowLightSource {
+    private _position;
+    constructor(position: Vector3, parameters: EnvironmentShadowLightSourceParameters);
+    getPosition(): Vector3;
+    prepareRenderShadow(): ActiveShadowLight[];
+    finishRenderShadow(): void;
+}
+export {};

package/lib/definitions/packages/common-core/src/webgl/renderer/pass/shadow-and-ao-pass.d.ts

@@ -0,0 +1,109 @@
+import type { Enumify } from '../../../types';
+import { RenderPass } from './render-pass';
+import type { RenderPassManager } from '../render-pass-manager';
+import type { DenoisePass, SceneVolume } from '../render-utility';
+import type { AORenderPassParameters } from './ao-pass';
+import { AORenderPass } from './ao-pass';
+import type { PoissonDenoisePassParameters } from './poisson-denoise-pass';
+import { PoissonDenoiseRenderPass } from './poisson-denoise-pass';
+import type { Texture, WebGLRenderer } from 'three';
+import { Matrix4, WebGLRenderTarget } from 'three';
+export declare const SHADOW_BLUR_TYPES: {
+    readonly OFF: "off";
+    readonly HARD: "hard";
+    readonly POISSON: "poisson";
+    readonly FULL: "full";
+};
+export type ShadowBlurType = Enumify<typeof SHADOW_BLUR_TYPES>;
+export interface ShadowParameters {
+    [key: string]: any;
+    shadowRadius: number;
+}
+export interface ShadowAndAoPassParameters {
+    enabled: boolean;
+    applyToMaterial: boolean;
+    aoIntensity: number;
+    shadowIntensity: number;
+    aoOnGround: boolean;
+    shadowOnGround: boolean;
+    alwaysUpdate: boolean;
+    progressiveDenoiseIterations: number;
+    shadow: ShadowParameters;
+    ao: AORenderPassParameters;
+    poissonDenoise: PoissonDenoisePassParameters;
+}
+export declare const defaultShadowParameters: ShadowParameters;
+export declare const defaultPassParameters: {
+    enabled: boolean;
+    applyToMaterial: boolean;
+    aoIntensity: number;
+    shadowIntensity: number;
+    aoOnGround: boolean;
+    shadowOnGround: boolean;
+    alwaysUpdate: boolean;
+    progressiveDenoiseIterations: number;
+};
+export interface ShadowAndAoPassConstructorParameters {
+    enabled?: boolean;
+    applyToMaterial?: boolean;
+    aoIntensity?: number;
+    shadowIntensity?: number;
+    aoOnGround?: boolean;
+    shadowOnGround?: boolean;
+    alwaysUpdate?: boolean;
+    progressiveDenoiseIterations?: number;
+    shadow?: ShadowParameters;
+    ao?: AORenderPassParameters;
+    poissonDenoise?: PoissonDenoisePassParameters;
+}
+export interface ShadowAndAoPassSettings {
+    shadowMapTexture: Texture | null;
+    shadowBlurType: ShadowBlurType;
+    shadowFadeInBlurType: ShadowBlurType;
+    shadowFadeInMix: number;
+    noOStaticFrames: number;
+}
+export declare class ShadowAndAoPass extends RenderPass {
+    static shadowTransform: Matrix4;
+    parameters: ShadowAndAoPassParameters;
+    needsUpdate: boolean;
+    renderToRenderTarget: boolean;
+    shadowAndAoPassSettings: ShadowAndAoPassSettings;
+    private _width;
+    private _height;
+    private _samples;
+    private _aoAndSoftShadowRenderTarget?;
+    private _softShadowPass?;
+    private _aoPass?;
+    private _fadeRenderTarget?;
+    private _poissonDenoisePass?;
+    private _copyMaterial;
+    private _blendMaterial;
+    private _blendAoAndShadowMaterial;
+    private _cameraUpdate;
+    private _finalTexture;
+    private _onlyHardShadow;
+    get aoAndSoftShadowRenderTarget(): WebGLRenderTarget;
+    get aoRenderPass(): AORenderPass;
+    get softShadowPass(): PoissonDenoiseRenderPass;
+    get fadeRenderTarget(): WebGLRenderTarget;
+    get denoisePass(): DenoisePass;
+    get denoiseRenderTargetTexture(): Texture | null;
+    get finalTexture(): Texture | null;
+    constructor(renderPassManager: RenderPassManager, width: number, height: number, samples: number, parameters?: ShadowAndAoPassConstructorParameters);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateParameters(parameters: ShadowAndAoPassParameters): void;
+    private _updatePassParameters;
+    updateBounds(sceneBounds: SceneVolume, _shadowAndAoScale: number): void;
+    private _getRenderConditions;
+    renderPass(renderer: WebGLRenderer): void;
+    private _setRenderState;
+    private _evaluateIfUpdateIsNeeded;
+    private _renderShadowAndAo;
+    private _renderAo;
+    private _renderSoftShadow;
+    private _renderDynamicShadow;
+    private _renderDenoise;
+    renderToTarget(renderer: WebGLRenderer): void;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/pmrem-environment.d.ts

@@ -0,0 +1,11 @@
+import type { Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { PMREMGenerator } from 'three';
+export declare class EnvironmentPmremGenertor extends PMREMGenerator {
+    private _extendedEquirectMaterial;
+    constructor(renderer: WebGLRenderer);
+    fromEquirectangularTexture(equirectangularTexture: Texture, parameters?: {
+        rotation?: number;
+        intensity?: number;
+    }): WebGLRenderTarget;
+    private _createEquirectMaterial;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/render-cache.d.ts

@@ -0,0 +1,69 @@
+import type { Material, Object3D } from 'three';
+import { Mesh } from 'three';
+export interface RenderCache {
+    dispose(): void;
+    clear(): void;
+    addLineOrPoint(object3d: Object3D): void;
+    addMesh(mesh: Mesh): void;
+    addObject(object3d: Object3D): void;
+    onBeforeRender(): void;
+    onAfterRender(): void;
+}
+export interface ThreeObject3d {
+    isLine?: boolean;
+    isPoints?: boolean;
+    isMesh?: boolean;
+}
+export type CacheKey = any;
+export declare class RenderCacheManager {
+    private _cacheMap;
+    dispose(): void;
+    registerCache(key: CacheKey, cache: RenderCache): void;
+    clearCache(): void;
+    clearObjectCache(key: CacheKey): void;
+    onBeforeRender(key: CacheKey, object3d: Object3D): void;
+    onAfterRender(key: CacheKey): void;
+    render(key: CacheKey, object3d: Object3D, renderMethod: () => void): void;
+}
+export declare class VisibilityRenderCache implements RenderCache {
+    private _visibilityCache;
+    private _isObjectInvisible?;
+    constructor(isObjectInvisible?: (object: any) => boolean);
+    dispose(): void;
+    clear(): void;
+    addLineOrPoint(object3d: Object3D): void;
+    addMesh(mesh: Mesh): void;
+    addObject(object3d: Object3D): void;
+    onBeforeRender(): void;
+    onAfterRender(): void;
+}
+export declare class DepthWriteRenderCache {
+    private _depthWriteCache;
+    private _doNotWriteDepth?;
+    constructor(doNotWriteDepth?: (object: any) => boolean);
+    dispose(): void;
+    clear(): void;
+    addLineOrPoint(_: Object3D): void;
+    addObject(_: Object3D): void;
+    addMesh(mesh: Mesh): void;
+    onBeforeRender(): void;
+    onAfterRender(): void;
+}
+export interface ObjectCacheData {
+    visible?: boolean;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+    material?: Material | Material[];
+}
+export declare abstract class ObjectRenderCache implements RenderCache {
+    private _objectCache;
+    abstract dispose(): void;
+    abstract addLineOrPoint(object3d: Object3D): void;
+    abstract addMesh(mesh: Mesh): void;
+    abstract addObject(object3d: Object3D): void;
+    clear(): void;
+    onBeforeRender(): void;
+    onAfterRender(): void;
+    addToCache(object: Object3D | Mesh, updateObjectData: ObjectCacheData): void;
+    private _updateObject;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/render-pass-manager.d.ts

@@ -0,0 +1,73 @@
+import { PassRenderer } from './render-utility';
+import { BakedGroundContactShadowPass } from './pass/baked-ground-contact-shadow-pass';
+import { GBufferRenderPass } from './pass/gbuffer-render-pass';
+import { GroundReflectionPass } from './pass/ground-reflection-pass';
+import { ScreenSpaceShadowMapPass } from './pass/screen-space-shadow-map-pass';
+import { ShadowAndAoPass } from './pass/shadow-and-ao-pass';
+import { OutlinePass } from './pass/outline-pass';
+import type { OutlineRenderer } from './outline-renderer';
+import { DebugPass } from './pass/debug-pass';
+import { SceneRenderPass } from './pass/scene-render-pass';
+import type { SceneRenderer } from './scene-renderer';
+import type { Camera, Scene, Texture, WebGLRenderer } from 'three';
+export declare class RenderPassManager {
+    materialsNeedUpdate: boolean;
+    private _sceneRenderer;
+    private _passRenderer;
+    private _sceneRenderPass;
+    private _bakedGroundContactShadowPass;
+    private _gBufferRenderPass;
+    private _groundReflectionPass;
+    private _screenSpaceShadowMapPass;
+    private _shadowAndAoPass;
+    private _outlinePass;
+    private _debugPass;
+    private _scene?;
+    private _camera?;
+    private _cameraUpdate;
+    private _cameraChanged;
+    private _noUpdateNeededCount;
+    private _noOStaticFrames;
+    private _maxSamples;
+    private _passUpdateStates;
+    aoPassMapTexture: Texture | null;
+    get passRenderer(): PassRenderer;
+    get scene(): Scene;
+    get camera(): Camera;
+    get aspect(): number;
+    get cameraChanged(): boolean;
+    get noOStaticFrames(): number;
+    get renderCacheManager(): import("./render-cache").RenderCacheManager;
+    private get parameters();
+    get sceneRenderPass(): SceneRenderPass;
+    get bakedGroundContactShadowPass(): BakedGroundContactShadowPass;
+    get gBufferRenderPass(): GBufferRenderPass;
+    get groundReflectionPass(): GroundReflectionPass;
+    get screenSpaceShadowMapPass(): ScreenSpaceShadowMapPass;
+    get shadowAndAoPass(): ShadowAndAoPass;
+    get outlinePass(): OutlinePass | null;
+    get outlineRenderer(): OutlineRenderer;
+    get debugPass(): DebugPass;
+    get debugOutput(): string;
+    constructor(sceneRender: SceneRenderer);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    createOutlinePass(): OutlinePass;
+    setGroundVisibility(visible: boolean): void;
+    updatePasses(renderer: WebGLRenderer, scene: Scene, camera: Camera): void;
+    private _evaluateIfShadowAndAoUpdateIsNeeded;
+    private _dynamicChanges;
+    private _updateSceneRenderPass;
+    private _updateBakedGroundContactShadowPass;
+    private _updateGBufferPass;
+    private _updateGroundReflectionPass;
+    private _updateScreenSpaceShadowPass;
+    private _updateShadowAndAoPass;
+    private _updateOutlinePass;
+    private _updateDebugPass;
+    private _updateMaterials;
+    private _updateMaterial;
+    private _updatePlugInAo;
+    private _updatePlugInReflection;
+    renderPasses(renderer: WebGLRenderer, scene: Scene): void;
+}