@roomle/embedding-lib 5.34.0-alpha.2 → 5.34.0-debug.1

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/poisson-denoise-pass.d.ts

@@ -1,68 +0,0 @@
-import { DenoisePass } from './../render-utility';
-import { NormalVectorSourceType, DepthValueSourceType } from './pass-utility';
-import { Camera, Texture, WebGLRenderer, 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/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/render-pass.d.ts

@@ -1,20 +0,0 @@
-import { PassRenderer } from '../render-utility';
-import { RenderCacheManager } from '../render-cache';
-import { RenderPassManager } from '../render-pass-manager';
-import { GBufferTextures } from './gbuffer-render-pass';
-import { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { WebGPURenderer } from 'three/webgpu';
-import { Pass } from 'three/examples/jsm/postprocessing/Pass.js';
-
-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 | WebGPURenderer, _writeBuffer: WebGLRenderTarget, _readBuffer: WebGLRenderTarget, _deltaTime: number, _maskActive: boolean): void;
-    abstract renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/scene-render-pass.d.ts

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

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

@@ -1,209 +0,0 @@
-import { RenderPass } from './render-pass';
-import { RenderPassManager } from '../render-pass-manager';
-import { SceneVolume } from '../render-utility';
-import { LightSource } from '../light-source-detection';
-import { ObjectRenderCache } from '../render-cache';
-import { Enumify } from '../../../types';
-import { Box3, Layers, Light, Object3D, RectAreaLight, ShadowMapType, Texture, WebGLRenderer, Mesh, Vector2, Vector3 } from 'three';
-import { WebGPURenderer } from 'three/webgpu';
-
-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 | WebGPURenderer): 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/packages/web-sdk/packages/common-core/src/webgl/renderer/pass/shadow-and-ao-pass.d.ts

@@ -1,108 +0,0 @@
-import { Enumify } from '../../../types';
-import { RenderPass } from './render-pass';
-import { RenderPassManager } from '../render-pass-manager';
-import { DenoisePass, SceneVolume } from '../render-utility';
-import { AORenderPassParameters, AORenderPass } from './ao-pass';
-import { PoissonDenoisePassParameters, PoissonDenoiseRenderPass } from './poisson-denoise-pass';
-import { Texture, WebGLRenderer, Matrix4, WebGLRenderTarget } from 'three';
-import { WebGPURenderer } from 'three/webgpu';
-
-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 | WebGPURenderer): void;
-    private _setRenderState;
-    private _evaluateIfUpdateIsNeeded;
-    private _renderShadowAndAo;
-    private _renderAo;
-    private _renderSoftShadow;
-    private _renderDynamicShadow;
-    private _renderDenoise;
-    renderToTarget(renderer: WebGLRenderer): void;
-}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/pmrem-environment.d.ts

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

package/packages/web-sdk/packages/common-core/src/webgl/renderer/render-cache.d.ts

@@ -1,71 +0,0 @@
-import { Material, Object3D, Mesh } from 'three';
-
-export declare const isTransparentMaterial: (material: Material | Material[], threshold: number) => boolean;
-export declare const isTransmissiveMaterial: (material: Material | Material[]) => boolean;
-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/packages/web-sdk/packages/common-core/src/webgl/renderer/render-pass-manager.d.ts

@@ -1,99 +0,0 @@
-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 { OutlineRenderer } from './outline-renderer';
-import { DebugPass } from './pass/debug-pass';
-import { SceneRenderPass } from './pass/scene-render-pass';
-import { SceneRenderer } from './scene-renderer';
-import { WebGLRenderTarget, Camera, Scene, Texture, WebGLRenderer } from 'three';
-import { WebGPURenderer } from 'three/webgpu';
-
-export interface LutPassParameters {
-    [key: string]: any;
-    enabled: boolean;
-    lut: string;
-    intensity: number;
-}
-export declare class RenderPassManager {
-    _creator_: string;
-    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;
-    private _lutMap;
-    private _lutPass;
-    private _lutPassParameters;
-    lutPassNeedsUpdate: boolean;
-    private _renderToRenderTarget;
-    private _outputPass;
-    private _passRenderTarget?;
-    private _passPassRenderTarget?;
-    private _initData;
-    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 lutPassParameters(): LutPassParameters;
-    get lutMaps(): string[];
-    get outlinePass(): OutlinePass | null;
-    get outlineRenderer(): OutlineRenderer;
-    get debugPass(): DebugPass;
-    get debugOutput(): string;
-    constructor(creator: string, sceneRender: SceneRenderer);
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    loadLutImage(name: string, url: string): void;
-    loadLutCube(name: string, url: string): void;
-    loadLut3dl(name: string, url: string): void;
-    createOutlinePass(): OutlinePass;
-    getRenderPassRenderTarget(renderer: WebGLRenderer | WebGPURenderer): WebGLRenderTarget | null;
-    getPostPassRenderTarget(renderer: WebGLRenderer | WebGPURenderer): WebGLRenderTarget | null;
-    setGroundVisibility(visible: boolean): void;
-    updatePasses(_renderer: WebGLRenderer | WebGPURenderer, scene: Scene, camera: Camera): void;
-    private _evaluateIfShadowAndAoUpdateIsNeeded;
-    private _dynamicChanges;
-    private _updateSceneRenderPass;
-    private _updateBakedGroundContactShadowPass;
-    private _updateGBufferPass;
-    private _updateGroundReflectionPass;
-    private _updateScreenSpaceShadowPass;
-    private _updateShadowAndAoPass;
-    private _updateLutPass;
-    private _updateOutlinePass;
-    private _updateDebugPass;
-    private _updateMaterials;
-    private _updateMaterial;
-    private _updatePlugInAo;
-    private _updatePlugInReflection;
-    renderPasses(renderer: WebGLRenderer | WebGPURenderer, scene: Scene): void;
-}