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

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

@@ -0,0 +1,44 @@
+import type { LightSource } from './light-source-detection';
+import type { WebGLRenderer } from 'three';
+import { CubeTexture, Scene, Texture } from 'three';
+export interface EnvironmentDefinitionTextureData {
+    _width: number;
+    _height: number;
+    data: number[];
+}
+interface EnvironmentDefinitionParameters {
+    textureData?: EnvironmentDefinitionTextureData;
+    rotation?: number;
+    intensity?: number;
+    maxNoOfLightSources?: number;
+}
+export declare abstract class EnvironmentSceneGenerator {
+    abstract generateScene(intensity: number, rotation: number): Scene;
+}
+export declare class EnvironmentDefinition {
+    needsUpdate: boolean;
+    readonly environmentSceneGenerator?: EnvironmentSceneGenerator;
+    readonly equirectangularTexture?: Texture;
+    readonly cubeTexture?: CubeTexture;
+    readonly textureData?: EnvironmentDefinitionTextureData;
+    private _rotation;
+    private _intensity;
+    private _maxNoOfLightSources?;
+    private _lightSources;
+    private _debugScene?;
+    private _parameters?;
+    private _environment;
+    get lightSources(): LightSource[];
+    set rotation(rotation: number);
+    set intensity(intensity: number);
+    set maxNoOfLightSources(maxNoOfLightSources: number);
+    get maxNoOfLightSources(): number | undefined;
+    constructor(environment: EnvironmentSceneGenerator | CubeTexture | Texture, parameters?: EnvironmentDefinitionParameters);
+    clone(): EnvironmentDefinition;
+    createNewEnvironment(renderer: WebGLRenderer): Texture | null;
+    private _getTextureOffset;
+    private _createPmremTexture;
+    private _detectLightSources;
+    createDebugScene(renderer: WebGLRenderer, scene: Scene, maxNoOfLightSources?: number): Scene | null;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import { EnvironmentSceneGenerator } from './environment-definition';
+import type { Enumify } from '../../types';
+import { Scene } from 'three';
+export declare const DEFAULT_ENVIRONMENT_SCENE_TYPES: {
+    readonly ALL_AROUND: "all_around";
+    readonly FRONT: "front";
+};
+export type DefaultEnvironmentSceneType = Enumify<typeof DEFAULT_ENVIRONMENT_SCENE_TYPES> | null;
+export interface DefaultEnvironmentSceneParameters {
+    type?: DefaultEnvironmentSceneType;
+    lightIntensity?: number;
+    topLightIntensity?: number;
+    sidLightIntensity?: number;
+    ambientLightIntensity?: number;
+    colorVariation?: number;
+}
+export declare class DefaultEnvironmentSceneGenerator extends EnvironmentSceneGenerator {
+    private _parameters;
+    constructor(parameters?: DefaultEnvironmentSceneParameters);
+    generateScene(intensity: number, rotation: number): Scene;
+}
+export declare class DefaultEnvironmentScene extends Scene {
+    private _type;
+    private _topLightIntensity;
+    private _sideLightIntensity;
+    private _sideReflectorIntensity;
+    private _ambientLightIntensity;
+    private _colorVariation;
+    private _lightGeometry;
+    private _reflectorLightGeometry;
+    constructor(parameters?: DefaultEnvironmentSceneParameters);
+    generateScene(scene: Scene): void;
+    dispose(): void;
+    private _createAllAroundSceneLight;
+    private _createFrontSceneLight;
+    private _createAreaLightMaterial;
+    private _createTopLight;
+    private _createSideLight;
+    private _createReflector;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/light-source-detection-debug.d.ts

@@ -0,0 +1,15 @@
+import type { LightSourceDetector } from './light-source-detection';
+import type { Material, Scene } from 'three';
+import { Mesh } from 'three';
+export declare class LightSourceDetectorDebug {
+    private _lightSourceDetector;
+    private _scene?;
+    constructor(lightSourceDetector: LightSourceDetector);
+    static createPlane(scene: Scene, material?: Material): Mesh;
+    createDebugScene(scene: Scene, maxNoOfLightSources?: number): void;
+    private _createLightGraphInMap;
+    private _createSamplePointsInMap;
+    private _createCirclesInMap;
+    private _createClusterLinesInMap;
+    private _uvToMapPosition;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/light-source-detection.d.ts

@@ -0,0 +1,87 @@
+import type { WebGLRenderer } from 'three';
+import { OrthographicCamera, ShaderMaterial, Texture, Vector2, Vector3, WebGLRenderTarget } from 'three';
+import type { EnvironmentDefinitionTextureData } from './environment-definition';
+export declare const sphereToEquirectangular: (pointOnSphere: Vector3) => Vector2;
+export declare const equirectangularToSphere: (uv: Vector2) => Vector3;
+export interface TextureConverterResult {
+    texture: Texture;
+    pixels: Uint8Array | Float32Array;
+    sRgbaPixels: boolean;
+}
+export declare class TextureConverter {
+    private _colorRenderTarget?;
+    private _environmentMapDecodeTarget?;
+    private _equirectangularDecodeMaterial?;
+    private _pmremDecodeMaterial?;
+    private _camera?;
+    private _planeMesh?;
+    get colorRenderTarget(): WebGLRenderTarget;
+    environmentMapDecodeTarget(renderer: WebGLRenderer): WebGLRenderTarget;
+    environmentMapDecodeMaterial(decodePmrem: boolean): EnvironmentMapDecodeMaterial;
+    get camera(): OrthographicCamera;
+    scaleTexture(renderer: WebGLRenderer, texture: Texture, targetWidth: number, targetHeight: number): TextureConverterResult;
+    newGrayscaleTexture(renderer: WebGLRenderer, texture: Texture, targetWidth: number, targetHeight: number): TextureConverterResult;
+}
+export declare class EnvironmentMapDecodeMaterial extends ShaderMaterial {
+    constructor(decodePmrem: boolean, grayscale: boolean);
+    setSourceTexture(map: Texture): void;
+}
+export interface LightSourceDetectorParameters {
+    numberOfSamples?: number;
+    width?: number;
+    height?: number;
+    sampleThreshold?: number;
+}
+export declare class LightSourceDetector {
+    private _numberOfSamples;
+    private _width;
+    private _height;
+    private _sampleThreshold;
+    readonly pointDistance: number;
+    readonly pixelDistance: number;
+    readonly samplePoints: Vector3[];
+    readonly sampleUVs: Vector2[];
+    textureData?: any;
+    grayscaleTexture: TextureConverterResult;
+    detectorTexture: Texture;
+    detectorArray: Float32Array;
+    private _textureConverter?;
+    lightSamples: LightSample[];
+    lightGraph: LightGraph;
+    lightSources: LightSource[];
+    private _grayScale;
+    constructor(parameters?: LightSourceDetectorParameters);
+    detectLightSources(renderer: WebGLRenderer, equirectangularTexture: Texture, textureData?: EnvironmentDefinitionTextureData): void;
+    private _createEquirectangularSamplePoints;
+    private _redFromRgbaToNormalizedFloatArray;
+    private _grayscaleTextureFromFloatArray;
+    private _filterLightSamples;
+    private _detectorTextureLuminanceValueFromUV;
+    private _originalLuminanceValueFromUV;
+    private _findClusterSegments;
+    private createLightSourcesFromLightGraph;
+}
+export declare class LightSample {
+    readonly position: Vector3;
+    readonly uv: Vector2;
+    constructor(position: Vector3, uv: Vector2);
+}
+export declare class LightGraph {
+    readonly noOfNodes: number;
+    edges: number[][];
+    adjacent: number[][];
+    components: number[][];
+    constructor(noOfNodes: number);
+    findConnectedComponents(): void;
+    private _dfs;
+}
+export declare class LightSource {
+    readonly lightSamples: LightSample[];
+    position: Vector3;
+    uv: Vector2;
+    averageIntensity: number;
+    maxIntensity: number;
+    size: number;
+    constructor(lightSamples: LightSample[]);
+    calculateLightSourceProperties(luminanceFunction: (uv: Vector2) => number): void;
+}

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

@@ -0,0 +1,14 @@
+import type { Blending, Texture } from 'three';
+import { ShaderMaterial } from 'three';
+import type { Nullable } from '../../../../../typings/helper';
+export interface BlendAoAndAShadowMaterialParameters {
+    texture?: Nullable<Texture>;
+    blending?: Blending;
+    aoIntensity?: number;
+    shadowIntensity?: number;
+}
+export declare class BlendAoAndAShadowMaterial extends ShaderMaterial {
+    private _intensity;
+    constructor(parameters?: BlendAoAndAShadowMaterialParameters);
+    update(parameters?: BlendAoAndAShadowMaterialParameters): BlendAoAndAShadowMaterial;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/materials/blend-ao-pass-depth-material.d.ts

@@ -0,0 +1,12 @@
+import type { Blending, Texture } from 'three';
+import { ShaderMaterial } from 'three';
+import type { Nullable } from '../../../../../typings/helper';
+export interface BlendAoPassDepthMaterialParameters {
+    texture?: Nullable<Texture>;
+    blending?: Blending;
+}
+export declare class BlendAoPassDepthMaterial extends ShaderMaterial {
+    private _intensity;
+    constructor(parameters?: BlendAoPassDepthMaterialParameters);
+    update(parameters?: BlendAoPassDepthMaterialParameters): BlendAoPassDepthMaterial;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/materials/illumination-buffer-material.d.ts

@@ -0,0 +1,14 @@
+import type { Box3 } from 'three';
+import { MeshLambertMaterial } from 'three';
+export declare class IlluminationBufferMaterial extends MeshLambertMaterial {
+    private static _enableGroundBoundary;
+    private static _shadowFadeOut;
+    private static _sceneBoxMin;
+    private static _sceneBoxMax;
+    private static _distributionProperties;
+    constructor(parameters?: any);
+    static setShadowParameters(enableGroundBoundary: boolean, directionalDependency: number, directionalExponent: number, groundBoundary: number, groundMapScale: number, distance: number, blur: number): void;
+    static setBoundingBox(box: Box3): void;
+    private _customProgramCacheKey;
+    private _onBeforeCompile;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/materials/normal-depth-material.d.ts

@@ -0,0 +1,14 @@
+import type { Blending, Camera, MeshNormalMaterial } from 'three';
+import { ShaderMaterial } from 'three';
+export interface GBufferNormalDepthMaterialParameters {
+    floatBufferType?: boolean;
+    linearDepth?: boolean;
+    camera?: Camera;
+    blending?: Blending;
+}
+export type GBufferNormalDepthMaterial = NormalAndDepthRenderMaterial | MeshNormalMaterial;
+export declare class NormalAndDepthRenderMaterial extends ShaderMaterial {
+    private static _normalAndDepthShader;
+    constructor(parameters: GBufferNormalDepthMaterialParameters);
+    update(parameters?: GBufferNormalDepthMaterialParameters): NormalAndDepthRenderMaterial;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/materials/postprocessing-material-plugin.d.ts

@@ -0,0 +1,25 @@
+import type { MeshStandardMaterial, Texture } from 'three';
+import type { Nullable } from '../../../../../typings/helper';
+export declare class PostProcessingMaterialPlugin {
+    applyAoAndShadowToAlpha: boolean;
+    private _aoPassMapUniform;
+    private _aoPassMapScaleUniform;
+    private _aoPassMapIntensityUniform;
+    private _shPassMapIntensityUniform;
+    private _reflectionPassMapUniform;
+    private _reflectionPassMapScaleUniform;
+    private _reflectionPassMapIntensityUniform;
+    applyReflectionPassMap: boolean;
+    set aoPassMap(value: Nullable<Texture>);
+    set aoPassMapScale(value: number);
+    set aoPassMapIntensity(value: number);
+    set shPassMapIntensity(value: number);
+    set reflectionPassMap(value: Nullable<Texture>);
+    set reflectionPassMapScale(value: number);
+    set reflectionPassMapIntensity(value: number);
+    static addPlugin(material: MeshStandardMaterial): PostProcessingMaterialPlugin | null;
+    private _isEnabled;
+    private _customProgramCacheKey;
+    private _onBeforeCompile;
+    private _initUniforms;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/objects/shadow-ground-plane.d.ts

@@ -0,0 +1,16 @@
+import type { Texture } from 'three';
+import { Mesh } from 'three';
+export interface ShadowGroundPlaneParameters {
+    opacity?: number;
+    polygonOffset?: number;
+}
+export declare class ShadowGroundPlane extends Mesh {
+    static alphaMap: boolean;
+    constructor(shadowMap: Texture | null, parameters?: ShadowGroundPlaneParameters);
+    setVisibility(visible: boolean): void;
+    setVisibilityLayers(visible: boolean): void;
+    setDepthWrite(write: boolean): void;
+    setReceiveShadow(receive: boolean): void;
+    setShadowMap(shadowMap: Texture | null): void;
+    updateMaterial(parameters: ShadowGroundPlaneParameters): void;
+}

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

@@ -0,0 +1,39 @@
+import type { RenderPassManager } from './render-pass-manager';
+import type { OutlinePass } from './pass/outline-pass';
+import type { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
+import type { Camera, ColorRepresentation, Object3D, Scene } from 'three';
+export interface OutlineParameters {
+    [key: string]: any;
+    enabled: boolean;
+    edgeStrength: number;
+    edgeGlow: number;
+    edgeThickness: number;
+    pulsePeriod: number;
+    usePatternTexture: false;
+    visibleEdgeColor: ColorRepresentation;
+    hiddenEdgeColor: ColorRepresentation;
+}
+export interface OutlineRendererParameters {
+    enabled?: boolean;
+    edgeStrength?: number;
+    edgeGlow?: number;
+    edgeThickness?: number;
+    pulsePeriod?: number;
+    usePatternTexture?: false;
+    visibleEdgeColor?: ColorRepresentation;
+    hiddenEdgeColor?: ColorRepresentation;
+}
+export declare class OutlineRenderer {
+    parameters: OutlineParameters;
+    private _renderPassManager;
+    private _effectComposer;
+    outlinePassActivated: boolean;
+    get isOutlinePassActivated(): boolean;
+    get outlinePass(): OutlinePass | null;
+    constructor(renderPassManager: RenderPassManager, _effectComposer: EffectComposer | null, parameters: OutlineRendererParameters);
+    updateParameters(parameters: OutlineParameters): void;
+    applyParameters(): void;
+    activateOutline(scene: Scene, camera: Camera): void;
+    deactivateOutline(): void;
+    updateOutline(scene: Scene, camera: Camera, selectedObjects: Object3D[]): void;
+}

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

@@ -0,0 +1,61 @@
+import type { NormalVectorSourceType, DepthValueSourceType } from './pass-utility';
+import type { AoAlgorithmType } from '../shaders/ao-shader';
+import type { Camera, Scene, Texture, WebGLRenderer } from 'three';
+import { Box3, WebGLRenderTarget } from 'three';
+export { AO_ALGORITHMS, type AoAlgorithmType } from '../shaders/ao-shader';
+export interface AORenderPassParameters {
+    [key: string]: any;
+    resolutionScale: number;
+    algorithm: AoAlgorithmType;
+    samples: number;
+    radius: number;
+    distanceExponent: number;
+    thickness: number;
+    distanceFallOff: number;
+    scale: number;
+    bias: number;
+    screenSpaceRadius: boolean;
+}
+export declare const defaultAORenderPassParameters: AORenderPassParameters;
+export interface AOPassParameters {
+    aoParameters?: AORenderPassParameters;
+    normalVectorSourceType?: NormalVectorSourceType;
+    depthValueSourceType?: DepthValueSourceType;
+    modulateRedChannel?: boolean;
+    depthTexture?: Texture;
+    normalTexture?: Texture;
+}
+export declare class AORenderPass {
+    needsUpdate: boolean;
+    parameters: AORenderPassParameters;
+    private _width;
+    private _height;
+    private _samples;
+    private _gBufferAntiAliasing;
+    private _normalVectorSourceType;
+    private _depthValueSourceType;
+    private _modulateRedChannel;
+    depthTexture: Texture | null;
+    normalTexture: Texture | null;
+    private _noiseTexture;
+    private _aoMaterial?;
+    private _renderTarget;
+    private _passRenderer;
+    private _sceneClipBox;
+    private _sceneScale;
+    get texture(): Texture | null;
+    constructor(width: number, height: number, samples: number, gBufferAntiAliasing: boolean, parameters?: AOPassParameters);
+    private _getNoiseTexture;
+    private _getMaterial;
+    private _newAoMaterial;
+    private _updateShader;
+    private _updateUniforms;
+    private _getRenderTargets;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateBounds(sceneClipBox: Box3, sceneScale?: number): void;
+    updateParameters(parameters: AORenderPassParameters): void;
+    updateTextures(parameters: AOPassParameters): void;
+    clear(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget): void;
+    render(renderer: WebGLRenderer, camera: Camera, scene: Scene, renderTarget?: WebGLRenderTarget): void;
+}

package/lib/definitions/packages/common-core/src/webgl/renderer/pass/baked-ground-contact-shadow-pass.d.ts

@@ -0,0 +1,78 @@
+import type { SceneVolume } from '../render-utility';
+import { ShadowGroundPlane } from '../objects/shadow-ground-plane';
+import { RenderPass } from './render-pass';
+import type { RenderPassManager } from '../render-pass-manager';
+import type { Group, Layers, WebGLRenderer } from 'three';
+import { WebGLRenderTarget } from 'three';
+export interface BakedGroundContactShadowParameters {
+    [key: string]: any;
+    enabled: boolean;
+    cameraHelper: boolean;
+    alwaysUpdate: boolean;
+    fadeIn: boolean;
+    blurMin: number;
+    blurMax: number;
+    fadeoutFalloff: number;
+    fadeoutBias: number;
+    opacity: number;
+    maximumPlaneSize: number;
+    planeSize: number;
+    cameraFar: number;
+    hardLayers: Layers | null;
+    softLayers: Layers | null;
+    polygonOffset: number;
+}
+export interface BakedGroundContactShadowConstructorParameters {
+    sharedShadowGroundPlane?: ShadowGroundPlane;
+    shadowMapSize?: number;
+    enabled?: boolean;
+    cameraHelper?: boolean;
+    alwaysUpdate?: boolean;
+    fadeIn?: boolean;
+    blurMin?: number;
+    blurMax?: number;
+    fadeoutFalloff?: number;
+    fadeoutBias?: number;
+    opacity?: number;
+    maximumPlaneSize?: number;
+    planeSize?: number;
+    cameraFar?: number;
+    hardLayers?: Layers | null;
+    softLayers?: Layers | null;
+    polygonOffset?: number;
+}
+export declare class BakedGroundContactShadowPass extends RenderPass {
+    static addTestMesh: boolean;
+    shadowMapSize: number;
+    limitPlaneSize: boolean;
+    parameters: BakedGroundContactShadowParameters;
+    private _renderer;
+    needsUpdate: boolean;
+    noNeedOfUpdateCount: number;
+    private _blurScale;
+    private _shadowScale;
+    private _groundGroup;
+    private _groundShadowFar;
+    private _sharedShadowGroundPlane?;
+    private _shadowGroundPlane?;
+    private _groundContactCamera;
+    private _renderTargetBlur;
+    private _blurPass;
+    readonly renderTarget: WebGLRenderTarget;
+    private _depthMaterial;
+    get shadowGroundPlane(): ShadowGroundPlane;
+    constructor(renderPassManager: RenderPassManager, renderer: WebGLRenderer, groundGroup: Group, parameters: BakedGroundContactShadowConstructorParameters);
+    private _getDefaultParameters;
+    dispose(): void;
+    updateParameters(parameters: BakedGroundContactShadowParameters): void;
+    applyParameters(): void;
+    setScale(groundContactShadowScale: number, _shadowScale?: number): void;
+    updateBounds(sceneBounds: SceneVolume, groundLevel?: number): void;
+    updatePlaneAndShadowCamera(): void;
+    setGroundVisibilityLayers(visible: boolean): void;
+    renderPass(renderer: WebGLRenderer): void;
+    private _renderGroundContact;
+    private _renderBlur;
+    private _renderReduceBandingBlur;
+    private _renderBlurPass;
+}

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

@@ -0,0 +1,23 @@
+import { RenderPass } from './render-pass';
+import type { RenderPassManager } from '../render-pass-manager';
+import type { CopyTransformMaterialParameters } from '../shader-utility';
+import type { BlendAoAndAShadowMaterialParameters } from '../materials/blend-ao-and-shadow-material';
+import type { BlendAoPassDepthMaterialParameters } from '../materials/blend-ao-pass-depth-material';
+import type { ShaderMaterial, WebGLRenderer } from 'three';
+export declare class DebugPass extends RenderPass {
+    private _environmentMapDecodeMaterial;
+    private _copyMaterial?;
+    private _blendAoAndShadowMaterial?;
+    private _blendAoPassDepthMaterial?;
+    private _srgbToLinearCopyMaterial?;
+    private _depthRenderMaterial?;
+    debugOutput: string;
+    constructor(renderPassManager: RenderPassManager);
+    dispose(): void;
+    protected getCopyMaterial(parameters?: CopyTransformMaterialParameters): ShaderMaterial;
+    protected getBlendAoAndShadowMaterial(parameters?: BlendAoAndAShadowMaterialParameters): ShaderMaterial;
+    protected getBlendAoPassDepthMaterial(parameters?: BlendAoPassDepthMaterialParameters): ShaderMaterial;
+    protected getSrgbToLinearCopyMaterial(parameters?: CopyTransformMaterialParameters): ShaderMaterial;
+    private _getDepthRenderMaterial;
+    renderPass(renderer: WebGLRenderer): void;
+}

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

@@ -0,0 +1,69 @@
+import { RenderPass } from './render-pass';
+import type { RenderPassManager } from '../render-pass-manager';
+import type { CopyTransformMaterialParameters } from '../shader-utility';
+import { ObjectRenderCache } from '../render-cache';
+import type { Camera, MagnificationTextureFilter, Mesh, Object3D, ShaderMaterial, Texture, TextureFilter, WebGLRenderer } from 'three';
+import { Material, WebGLRenderTarget } from 'three';
+export interface GBufferTextures {
+    get isFloatGBufferWithRgbNormalAlphaDepth(): boolean;
+    get gBufferTexture(): Texture;
+    get depthBufferTexture(): Texture;
+    get textureWithDepthValue(): Texture;
+}
+export interface GBufferParameters {
+    [key: string]: any;
+    depthNormalScale: number;
+}
+export interface GBufferRenderTargetsParameters {
+    capabilities?: any;
+    textureMinificationFilter?: TextureFilter;
+    textureMagnificationFilter?: MagnificationTextureFilter;
+    width?: number;
+    height?: number;
+    samples?: number;
+    shared?: boolean;
+    depthNormalScale?: number;
+}
+export declare class GBufferRenderPass extends RenderPass implements GBufferTextures {
+    parameters: GBufferParameters;
+    readonly floatRgbNormalAlphaDepth: boolean;
+    readonly linearDepth: boolean;
+    copyToSeparateDepthBuffer: boolean;
+    private _gBufferMaterialCache?;
+    private _targetMinificationTextureFilter;
+    private _targetMagnificationTextureFilter;
+    private _width;
+    private _height;
+    private _samples;
+    private _gBufferRenderMaterial?;
+    private _depthNormalRenderTarget?;
+    private _separateDeptRenderTarget?;
+    private _copyMaterial?;
+    private _shared;
+    needsUpdate: boolean;
+    drawGround: boolean;
+    set groundDepthWrite(value: boolean);
+    get isFloatGBufferWithRgbNormalAlphaDepth(): boolean;
+    get gBufferTexture(): Texture;
+    get depthBufferTexture(): Texture;
+    get textureWithDepthValue(): Texture;
+    updateGBufferRenderMaterial(camera: Camera): Material;
+    get depthNormalRenderTarget(): WebGLRenderTarget;
+    get separateDeptRenderTarget(): WebGLRenderTarget;
+    constructor(renderPassManager: RenderPassManager, parameters?: GBufferRenderTargetsParameters);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    renderPass(renderer: WebGLRenderer): void;
+    private _renderGBuffer;
+    protected getCopyMaterial(parameters?: CopyTransformMaterialParameters): ShaderMaterial;
+    private _copyDepthToSeparateDepthTexture;
+}
+export declare class GBufferMaterialCache extends ObjectRenderCache {
+    private _groundDepthWrite;
+    set groundDepthWrite(value: boolean);
+    constructor();
+    dispose(): void;
+    addLineOrPoint(object3d: Object3D): void;
+    addMesh(mesh: Mesh): void;
+    addObject(_object3d: Object3D): void;
+}

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

@@ -0,0 +1,74 @@
+import { RenderPass } from './render-pass';
+import type { RenderPassManager } from '../render-pass-manager';
+import type { Camera, Texture, WebGLRenderer } from 'three';
+import { ShaderMaterial, WebGLRenderTarget } from 'three';
+export interface GroundReflectionParameters {
+    [key: string]: any;
+    enabled: boolean;
+    intensity: number;
+    fadeOutDistance: number;
+    fadeOutExponent: number;
+    brightness: number;
+    blurHorizontal: number;
+    blurVertical: number;
+    blurAscent: number;
+    groundLevel: number;
+    groundReflectionScale: number;
+    renderTargetDownScale: number;
+}
+export interface GroundReflectionConstructorParameters {
+    enabled?: boolean;
+    intensity?: number;
+    fadeOutDistance?: number;
+    fadeOutExponent?: number;
+    brightness?: number;
+    blurHorizontal?: number;
+    blurVertical?: number;
+    blurAscent?: number;
+    groundLevel?: number;
+    groundReflectionScale?: number;
+    renderTargetDownScale?: number;
+}
+export declare class GroundReflectionPass extends RenderPass {
+    private _width;
+    private _height;
+    private _samples;
+    parameters: GroundReflectionParameters;
+    reflectionFadeInScale: number;
+    private _reflectionRenderTarget?;
+    private _intensityRenderTarget?;
+    private _blurRenderTarget?;
+    private _blurPass;
+    private _reflectionIntensityMaterial;
+    private _copyMaterial;
+    get reflectionRenderTarget(): WebGLRenderTarget;
+    get intensityRenderTarget(): WebGLRenderTarget;
+    get blurRenderTarget(): WebGLRenderTarget;
+    constructor(renderPassManager: RenderPassManager, width: number, height: number, samples: number, parameters: GroundReflectionConstructorParameters);
+    private _newRenderTarget;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateParameters(parameters: GroundReflectionParameters): void;
+    updateBounds(groundLevel: number, groundReflectionScale: number): void;
+    private _updateCopyMaterial;
+    renderPass(renderer: WebGLRenderer): void;
+    private _renderGroundReflection;
+    private _renderGroundReflectionIntensity;
+    blurReflection(renderer: WebGLRenderer, camera: Camera, renderTargets: WebGLRenderTarget[]): void;
+    private _createGroundReflectionCamera;
+}
+export interface GroundReflectionIntensityMaterialParameters {
+    texture?: Texture;
+    depthTexture?: Texture;
+    camera?: Camera;
+    groundLevel?: number;
+    fadeOutDistance?: number;
+    fadeOutExponent?: number;
+    width?: number;
+    height?: number;
+}
+export declare class GroundReflectionIntensityMaterial extends ShaderMaterial {
+    private static shader;
+    constructor(parameters?: GroundReflectionIntensityMaterialParameters);
+    update(parameters?: GroundReflectionIntensityMaterialParameters): GroundReflectionIntensityMaterial;
+}