@roomle/web-sdk 2.90.0 → 2.91.0-alpha.10

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

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

@@ -0,0 +1,84 @@
+import type { Camera, Material, Object3D, ShaderMaterialParameters, Texture, WebGLRenderer, WebGLRenderTarget, ColorRepresentation } from 'three';
+import { Box3, Color, CubeTexture, DataTexture, OrthographicCamera, PerspectiveCamera, Scene, Vector3 } from 'three';
+export declare const createUniformColorTexture: (color: Color) => Texture;
+export declare const createUniformColorCubeTexture: (color: Color) => CubeTexture;
+export declare const createNoiseTexture: (size: number, min: number, max: number) => Texture;
+export declare const loadAndSetTexture: (setTexture: (texture: Texture) => void, resource: string, color?: Color) => void;
+export declare const setOrthographicViewVolumeFromBox: (camera: OrthographicCamera, viewBox: Box3) => void;
+export declare const setPerspectiveViewVolumeFromBox: (camera: PerspectiveCamera, viewBox: Box3) => void;
+export declare class SceneVolume {
+    bounds: Box3;
+    size: Vector3;
+    center: Vector3;
+    maxSceneDistanceFromCenter: number;
+    maxSceneDistanceFrom0: number;
+    copyFrom(other: SceneVolume): void;
+    updateFromObject(sceneObject: Object3D): void;
+    updateFromBox(boundingBox: Box3): void;
+    updateCameraViewVolumeFromBounds(camera: Camera): void;
+    getNearAndFarForPerspectiveCamera(cameraPosition: Vector3, backScale?: number): number[];
+}
+export declare const getMaxSamples: (renderTarget: WebGLRenderer) => number;
+export declare class BoxUpdateHelper {
+    box: Box3;
+    color: ColorRepresentation;
+    opacity: number;
+    private _group;
+    private _boxMesh;
+    private _boxWire;
+    get visible(): boolean;
+    set visible(isVisible: boolean);
+    get object(): Object3D;
+    constructor(box: Box3, parameters?: {
+        color?: number;
+        opacity?: number;
+    });
+    update(): void;
+    addTo(scene: Object3D): void;
+    removeFrom(scene: Object3D): void;
+}
+export declare const boxFromOrthographicViewVolume: (camera: OrthographicCamera) => Box3;
+export declare const boundingBoxInViewSpace: (worldBox: Box3, camera: Camera) => Box3;
+export declare class CameraUpdate {
+    private _lastCameraProjection;
+    private _lastCameraWorld;
+    changed(camera: Camera): boolean;
+}
+export declare const viewSpacePositionFromAltitudeAndAzimuth: (distance: number, altitudeDeg: number, azimuthDeg: number) => Vector3;
+export declare const viewSpacePositionFromUV: (distance: number, u: number, v: number) => Vector3;
+export declare const spiralQuadraticSampleKernel: (kernelSize: number) => Vector3[];
+export declare const generateUniformKernelRotations: () => DataTexture;
+export declare const generateMagicSquare: (size: number) => number[];
+export declare const generateMagicSquareDistributedKernelRotations: (size: number) => DataTexture;
+export declare class PassRenderer {
+    private _originalClearColor;
+    private _originalClearAlpha;
+    private _originalAutoClear;
+    private _originalRenderTarget;
+    private _screenSpaceQuad;
+    private _emptyScene;
+    private _defaultCamera;
+    renderWithOverrideMaterial(renderer: WebGLRenderer, scene: Scene, camera: Camera, overrideMaterial: Material | null, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    clear(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    render(renderer: WebGLRenderer, scene: Scene, camera: Camera, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    renderScreenSpace(renderer: WebGLRenderer, passMaterial: Material, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    private _prepareRenderer;
+    private _backup;
+    private _restore;
+}
+export declare class BlurPass {
+    private _passRenderer;
+    private _blurMaterial;
+    constructor(blurShaderParameters?: ShaderMaterialParameters, parameters?: {
+        passRenderer?: PassRenderer;
+    });
+    dispose(): void;
+    render(renderer: WebGLRenderer, renderTargets: WebGLRenderTarget[], uvMin: number[], uvMax: number[]): void;
+}
+export interface DenoisePass {
+    get texture(): Texture | null;
+    set inputTexture(texture: Texture | null);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    render(renderer: WebGLRenderer, camera: Camera): void;
+}

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

@@ -0,0 +1,16 @@
+import type { SceneRenderer } from './scene-renderer';
+import type { GUI } from 'dat.gui';
+export declare class SceneRendererGUI {
+    private _sceneRenderer;
+    private _qualityLevel;
+    private _ambientOcclusionType;
+    constructor(sceneRenderer: SceneRenderer);
+    addGUI(gui: GUI, updateCallback: () => void): void;
+    private _addRepresentationalGUI;
+    private _addDebugGUI;
+    private _addShadowTypeGUI;
+    private _addShadowAndAoGUI;
+    private _addGroundReflectionGUI;
+    private _addBakedGroundContactShadowGUI;
+    private _addOutlineGUI;
+}