@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline.d.ts

@@ -0,0 +1,214 @@
+/**
+ * The default rendering pipeline can be added to a scene to apply common post processing effects such as anti-aliasing or depth of field.
+ * See https://doc.babylonjs.com/how_to/using_default_rendering_pipeline
+ */
+export class DefaultRenderingPipeline extends PostProcessRenderPipeline {
+    /**
+     * Parse the serialized pipeline
+     * @param source Source pipeline.
+     * @param scene The scene to load the pipeline to.
+     * @param rootUrl The URL of the serialized pipeline.
+     * @returns An instantiated pipeline from the serialized object.
+     */
+    static Parse(source: any, scene: any, rootUrl: any): DefaultRenderingPipeline;
+    /**
+     * @constructor
+     * @param name - The rendering pipeline name (default: "")
+     * @param hdr - If high dynamic range textures should be used (default: true)
+     * @param scene - The scene linked to this pipeline (default: the last created scene)
+     * @param cameras - The array of cameras that the rendering pipeline will be attached to (default: scene.cameras)
+     * @param automaticBuild - if false, you will have to manually call prepare() to update the pipeline (default: true)
+     */
+    constructor(name: string | undefined, hdr: boolean | undefined, scene: import("@babylonjs/core").Nullable<import("@babylonjs/core").Scene> | undefined, cameras: any, automaticBuild?: boolean);
+    _camerasToBeAttached: any;
+    /**
+     * ID of the sharpen post process,
+     */
+    SharpenPostProcessId: string;
+    /**
+     * @ignore
+     * ID of the image processing post process;
+     */
+    ImageProcessingPostProcessId: string;
+    /**
+     * @ignore
+     * ID of the Fast Approximate Anti-Aliasing post process;
+     */
+    FxaaPostProcessId: string;
+    /**
+     * ID of the chromatic aberration post process,
+     */
+    ChromaticAberrationPostProcessId: string;
+    /**
+     * ID of the grain post process
+     */
+    GrainPostProcessId: string;
+    /**
+     * Glow post process which adds a glow to emissive areas of the image
+     */
+    _glowLayer: GlowLayer | null;
+    /**
+     * Animations which can be used to tweak settings over a period of time
+     */
+    animations: any[];
+    _imageProcessingConfigurationObserver: import("@babylonjs/core").Nullable<import("../../../Misc/observable.js").Observer<import("@babylonjs/core").ImageProcessingConfiguration>>;
+    _sharpenEnabled: boolean;
+    _bloomEnabled: boolean;
+    _depthOfFieldEnabled: boolean;
+    _depthOfFieldBlurLevel: DepthOfFieldEffectBlurLevel;
+    _fxaaEnabled: boolean;
+    _imageProcessingEnabled: boolean;
+    _bloomScale: number;
+    _chromaticAberrationEnabled: boolean;
+    _grainEnabled: boolean;
+    _buildAllowed: boolean;
+    /**
+     * This is triggered each time the pipeline has been built.
+     */
+    onBuildObservable: Observable<any>;
+    _resizeObserver: import("@babylonjs/core").Nullable<import("../../../Misc/observable.js").Observer<import("@babylonjs/core").Engine>>;
+    _hardwareScaleLevel: number;
+    _bloomKernel: number;
+    /**
+     * Specifies the weight of the bloom in the final rendering
+     */
+    _bloomWeight: number;
+    /**
+     * Specifies the luma threshold for the area that will be blurred by the bloom
+     */
+    _bloomThreshold: number;
+    _samples: number;
+    _hasCleared: boolean;
+    _prevPostProcess: any;
+    _prevPrevPostProcess: any;
+    _depthOfFieldSceneObserver: import("@babylonjs/core").Nullable<import("../../../Misc/observable.js").Observer<import("@babylonjs/core").Scene>>;
+    _activeCameraChangedObserver: import("@babylonjs/core").Nullable<import("../../../Misc/observable.js").Observer<import("@babylonjs/core").Scene>>;
+    _activeCamerasChangedObserver: import("@babylonjs/core").Nullable<import("../../../Misc/observable.js").Observer<import("@babylonjs/core").Scene>>;
+    _cameras: any;
+    _scene: import("@babylonjs/core").Nullable<import("@babylonjs/core").Scene>;
+    _hdr: boolean;
+    _defaultPipelineTextureType: number | undefined;
+    sharpen: SharpenPostProcess;
+    _sharpenEffect: PostProcessRenderEffect;
+    depthOfField: DepthOfFieldEffect;
+    bloom: BloomEffect;
+    chromaticAberration: ChromaticAberrationPostProcess;
+    _chromaticAberrationEffect: PostProcessRenderEffect;
+    grain: GrainPostProcess;
+    _grainEffect: PostProcessRenderEffect;
+    set bloomKernel(arg: number);
+    /**
+     * Specifies the size of the bloom blur kernel, relative to the final output size
+     */
+    get bloomKernel(): number;
+    /**
+     * Gets active scene
+     */
+    get scene(): import("@babylonjs/core").Nullable<import("@babylonjs/core").Scene>;
+    /**
+     * Enable or disable the sharpen process from the pipeline
+     */
+    set sharpenEnabled(arg: boolean);
+    get sharpenEnabled(): boolean;
+    /**
+     * The strength of the bloom.
+     */
+    set bloomWeight(arg: number);
+    get bloomWeight(): number;
+    /**
+     * The luminance threshold to find bright areas of the image to bloom.
+     */
+    set bloomThreshold(arg: number);
+    get bloomThreshold(): number;
+    /**
+     * The scale of the bloom, lower value will provide better performance.
+     */
+    set bloomScale(arg: number);
+    get bloomScale(): number;
+    /**
+     * Enable or disable the bloom from the pipeline
+     */
+    set bloomEnabled(arg: boolean);
+    get bloomEnabled(): boolean;
+    _rebuildBloom(): void;
+    set depthOfFieldEnabled(arg: boolean);
+    /**
+     * If the depth of field is enabled.
+     */
+    get depthOfFieldEnabled(): boolean;
+    set depthOfFieldBlurLevel(arg: DepthOfFieldEffectBlurLevel);
+    /**
+     * Blur level of the depth of field effect. (Higher blur will effect performance)
+     */
+    get depthOfFieldBlurLevel(): DepthOfFieldEffectBlurLevel;
+    /**
+     * If the anti aliasing is enabled.
+     */
+    set fxaaEnabled(arg: boolean);
+    get fxaaEnabled(): boolean;
+    /**
+     * MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
+     */
+    set samples(arg: number);
+    get samples(): number;
+    /**
+     * If image processing is enabled.
+     */
+    set imageProcessingEnabled(arg: boolean);
+    get imageProcessingEnabled(): boolean;
+    /**
+     * If glow layer is enabled. (Adds a glow effect to emmissive materials)
+     */
+    set glowLayerEnabled(arg: boolean);
+    get glowLayerEnabled(): boolean;
+    /**
+     * Gets the glow layer (or null if not defined)
+     */
+    get glowLayer(): GlowLayer | null;
+    /**
+     * Enable or disable the chromaticAberration process from the pipeline
+     */
+    set chromaticAberrationEnabled(arg: boolean);
+    get chromaticAberrationEnabled(): boolean;
+    /**
+     * Enable or disable the grain process from the pipeline
+     */
+    set grainEnabled(arg: boolean);
+    get grainEnabled(): boolean;
+    /**
+     * Force the compilation of the entire pipeline.
+     */
+    prepare(): void;
+    _setAutoClearAndTextureSharing(postProcess: any, skipTextureSharing?: boolean): void;
+    _buildPipeline(): void;
+    imageProcessing: ImageProcessingPostProcess | null | undefined;
+    fxaa: FxaaPostProcess | null | undefined;
+    _disposePostProcesses(disposeNonRecreated?: boolean): void;
+    /**
+     * Adds a camera to the pipeline
+     * @param camera the camera to be added
+     */
+    addCamera(camera: any): void;
+    /**
+     * Removes a camera from the pipeline
+     * @param camera the camera to remove
+     */
+    removeCamera(camera: any): void;
+    /**
+     * Serialize the rendering pipeline (Used when exporting)
+     * @returns the serialized object
+     */
+    serialize(): any;
+}
+import { PostProcessRenderPipeline } from "../../../PostProcesses/RenderPipeline/postProcessRenderPipeline.js";
+import { GlowLayer } from "../../../Layers/glowLayer.js";
+import { DepthOfFieldEffectBlurLevel } from "../../../PostProcesses/depthOfFieldEffect.js";
+import { Observable } from "../../../Misc/observable.js";
+import { SharpenPostProcess } from "../../../PostProcesses/sharpenPostProcess.js";
+import { PostProcessRenderEffect } from "../../../PostProcesses/RenderPipeline/postProcessRenderEffect.js";
+import { DepthOfFieldEffect } from "../../../PostProcesses/depthOfFieldEffect.js";
+import { BloomEffect } from "../../../PostProcesses/bloomEffect.js";
+import { ChromaticAberrationPostProcess } from "../../../PostProcesses/chromaticAberrationPostProcess.js";
+import { GrainPostProcess } from "../../../PostProcesses/grainPostProcess.js";
+import { ImageProcessingPostProcess } from "../../../PostProcesses/imageProcessingPostProcess.js";
+import { FxaaPostProcess } from "../../../PostProcesses/fxaaPostProcess.js";

package/dist/types/node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./defaultRenderingPipeline.js";
+export * from "./lensRenderingPipeline.js";
+export * from "./ssao2RenderingPipeline.js";
+export * from "./ssaoRenderingPipeline.js";
+export * from "./standardRenderingPipeline.js";

package/dist/types/node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/lensRenderingPipeline.d.ts

@@ -0,0 +1,223 @@
+/**
+ * BABYLON.JS Chromatic Aberration GLSL Shader
+ * Author: Olivier Guyot
+ * Separates very slightly R, G and B colors on the edges of the screen
+ * Inspired by Francois Tarlier & Martins Upitis
+ */
+export class LensRenderingPipeline extends PostProcessRenderPipeline {
+    /**
+     * @constructor
+     *
+     * Effect parameters are as follow:
+     * {
+     *      chromatic_aberration: number;       // from 0 to x (1 for realism)
+     *      edge_blur: number;                  // from 0 to x (1 for realism)
+     *      distortion: number;                 // from 0 to x (1 for realism), note that this will effect the pointer position precision
+     *      grain_amount: number;               // from 0 to 1
+     *      grain_texture: BABYLON.Texture;     // texture to use for grain effect; if unset, use random B&W noise
+     *      dof_focus_distance: number;         // depth-of-field: focus distance; unset to disable (disabled by default)
+     *      dof_aperture: number;               // depth-of-field: focus blur bias (default: 1)
+     *      dof_darken: number;                 // depth-of-field: darken that which is out of focus (from 0 to 1, disabled by default)
+     *      dof_pentagon: boolean;              // depth-of-field: makes a pentagon-like "bokeh" effect
+     *      dof_gain: number;                   // depth-of-field: highlights gain; unset to disable (disabled by default)
+     *      dof_threshold: number;              // depth-of-field: highlights threshold (default: 1)
+     *      blur_noise: boolean;                // add a little bit of noise to the blur (default: true)
+     * }
+     * Note: if an effect parameter is unset, effect is disabled
+     *
+     * @param name The rendering pipeline name
+     * @param parameters - An object containing all parameters (see above)
+     * @param scene The scene linked to this pipeline
+     * @param ratio The size of the postprocesses (0.5 means that your postprocess will have a width = canvas.width 0.5 and a height = canvas.height 0.5)
+     * @param cameras The array of cameras that the rendering pipeline will be attached to
+     */
+    constructor(name: any, parameters: any, scene: any, ratio: number | undefined, cameras: any);
+    /**
+     * @ignore
+     * The chromatic aberration PostProcess id in the pipeline
+     */
+    LensChromaticAberrationEffect: string;
+    /**
+     * @ignore
+     * The highlights enhancing PostProcess id in the pipeline
+     */
+    HighlightsEnhancingEffect: string;
+    /**
+     * @ignore
+     * The depth-of-field PostProcess id in the pipeline
+     */
+    LensDepthOfFieldEffect: string;
+    _pentagonBokehIsEnabled: boolean;
+    _scene: any;
+    _depthTexture: any;
+    _grainTexture: any;
+    _edgeBlur: any;
+    _grainAmount: any;
+    _chromaticAberration: any;
+    _distortion: any;
+    _highlightsGain: any;
+    _highlightsThreshold: any;
+    _dofDistance: any;
+    _dofAperture: any;
+    _dofDarken: any;
+    _dofPentagon: any;
+    _blurNoise: any;
+    /**
+     * Gets associated scene
+     */
+    get scene(): any;
+    set edgeBlur(arg: any);
+    /**
+     * Gets or sets the edge blur
+     */
+    get edgeBlur(): any;
+    set grainAmount(arg: any);
+    /**
+     * Gets or sets the grain amount
+     */
+    get grainAmount(): any;
+    set chromaticAberration(arg: any);
+    /**
+     * Gets or sets the chromatic aberration amount
+     */
+    get chromaticAberration(): any;
+    set dofAperture(arg: any);
+    /**
+     * Gets or sets the depth of field aperture
+     */
+    get dofAperture(): any;
+    set edgeDistortion(arg: any);
+    /**
+     * Gets or sets the edge distortion
+     */
+    get edgeDistortion(): any;
+    set dofDistortion(arg: any);
+    /**
+     * Gets or sets the depth of field distortion
+     */
+    get dofDistortion(): any;
+    set darkenOutOfFocus(arg: any);
+    /**
+     * Gets or sets the darken out of focus amount
+     */
+    get darkenOutOfFocus(): any;
+    set blurNoise(arg: any);
+    /**
+     * Gets or sets a boolean indicating if blur noise is enabled
+     */
+    get blurNoise(): any;
+    set pentagonBokeh(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating if pentagon bokeh is enabled
+     */
+    get pentagonBokeh(): boolean;
+    set highlightsGain(arg: any);
+    /**
+     * Gets or sets the highlight grain amount
+     */
+    get highlightsGain(): any;
+    set highlightsThreshold(arg: any);
+    /**
+     * Gets or sets the highlight threshold
+     */
+    get highlightsThreshold(): any;
+    /**
+     * Sets the amount of blur at the edges
+     * @param amount blur amount
+     */
+    setEdgeBlur(amount: any): void;
+    /**
+     * Sets edge blur to 0
+     */
+    disableEdgeBlur(): void;
+    /**
+     * Sets the amount of grain
+     * @param amount Amount of grain
+     */
+    setGrainAmount(amount: any): void;
+    /**
+     * Set grain amount to 0
+     */
+    disableGrain(): void;
+    /**
+     * Sets the chromatic aberration amount
+     * @param amount amount of chromatic aberration
+     */
+    setChromaticAberration(amount: any): void;
+    /**
+     * Sets chromatic aberration amount to 0
+     */
+    disableChromaticAberration(): void;
+    /**
+     * Sets the EdgeDistortion amount
+     * @param amount amount of EdgeDistortion
+     */
+    setEdgeDistortion(amount: any): void;
+    /**
+     * Sets edge distortion to 0
+     */
+    disableEdgeDistortion(): void;
+    /**
+     * Sets the FocusDistance amount
+     * @param amount amount of FocusDistance
+     */
+    setFocusDistance(amount: any): void;
+    /**
+     * Disables depth of field
+     */
+    disableDepthOfField(): void;
+    /**
+     * Sets the Aperture amount
+     * @param amount amount of Aperture
+     */
+    setAperture(amount: any): void;
+    /**
+     * Sets the DarkenOutOfFocus amount
+     * @param amount amount of DarkenOutOfFocus
+     */
+    setDarkenOutOfFocus(amount: any): void;
+    /**
+     * Creates a pentagon bokeh effect
+     */
+    enablePentagonBokeh(): void;
+    /**
+     * Disables the pentagon bokeh effect
+     */
+    disablePentagonBokeh(): void;
+    /**
+     * Enables noise blur
+     */
+    enableNoiseBlur(): void;
+    /**
+     * Disables noise blur
+     */
+    disableNoiseBlur(): void;
+    /**
+     * Sets the HighlightsGain amount
+     * @param amount amount of HighlightsGain
+     */
+    setHighlightsGain(amount: any): void;
+    /**
+     * Sets the HighlightsThreshold amount
+     * @param amount amount of HighlightsThreshold
+     */
+    setHighlightsThreshold(amount: any): void;
+    /**
+     * Disables highlights
+     */
+    disableHighlights(): void;
+    /**
+     * Removes the internal pipeline assets and detaches the pipeline from the scene cameras
+     * @param disableDepthRender If the scene's depth rendering should be disabled (default: false)
+     */
+    dispose(disableDepthRender?: boolean): void;
+    _chromaticAberrationPostProcess: PostProcess | null | undefined;
+    _highlightsPostProcess: PostProcess | null | undefined;
+    _depthOfFieldPostProcess: PostProcess | null | undefined;
+    _createChromaticAberrationPostProcess(ratio: any): void;
+    _createHighlightsPostProcess(ratio: any): void;
+    _createDepthOfFieldPostProcess(ratio: any): void;
+    _createGrainTexture(): void;
+}
+import { PostProcessRenderPipeline } from "../../../PostProcesses/RenderPipeline/postProcessRenderPipeline.js";
+import { PostProcess } from "../../../PostProcesses/postProcess.js";

package/dist/types/node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Render pipeline to produce ssao effect
+ */
+export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
+    /**
+     *  Support test.
+     */
+    static get IsSupported(): boolean;
+    /**
+     * Parse the serialized pipeline
+     * @param source Source pipeline.
+     * @param scene The scene to load the pipeline to.
+     * @param rootUrl The URL of the serialized pipeline.
+     * @returns An instantiated pipeline from the serialized object.
+     */
+    static Parse(source: any, scene: any, rootUrl: any): SSAO2RenderingPipeline;
+    /**
+     * @constructor
+     * @param name The rendering pipeline name
+     * @param scene The scene linked to this pipeline
+     * @param ratio The size of the postprocesses. Can be a number shared between passes or an object for more precision: { ssaoRatio: 0.5, blurRatio: 1.0 }
+     * @param cameras The array of cameras that the rendering pipeline will be attached to
+     * @param forceGeometryBuffer Set to true if you want to use the legacy geometry buffer renderer
+     * @param textureType The texture type used by the different post processes created by SSAO (default: 0)
+     */
+    constructor(name: any, scene: any, ratio: any, cameras: any, forceGeometryBuffer?: boolean, textureType?: number);
+    /**
+     * @ignore
+     * The PassPostProcess id in the pipeline that contains the original scene color
+     */
+    SSAOOriginalSceneColorEffect: string;
+    /**
+     * @ignore
+     * The SSAO PostProcess id in the pipeline
+     */
+    SSAORenderEffect: string;
+    /**
+     * @ignore
+     * The horizontal blur PostProcess id in the pipeline
+     */
+    SSAOBlurHRenderEffect: string;
+    /**
+     * @ignore
+     * The vertical blur PostProcess id in the pipeline
+     */
+    SSAOBlurVRenderEffect: string;
+    /**
+     * @ignore
+     * The PostProcess id in the pipeline that combines the SSAO-Blur output with the original scene color (SSAOOriginalSceneColorEffect)
+     */
+    SSAOCombineRenderEffect: string;
+    /**
+     * The output strength of the SSAO post-process. Default value is 1.0.
+     */
+    totalStrength: number;
+    /**
+     * Maximum depth value to still render AO. A smooth falloff makes the dimming more natural, so there will be no abrupt shading change.
+     */
+    maxZ: number;
+    /**
+     * In order to save performances, SSAO radius is clamped on close geometry. This ratio changes by how much
+     */
+    minZAspect: number;
+    _samples: number;
+    _textureSamples: number;
+    /**
+     * Force rendering the geometry through geometry buffer
+     */
+    _forceGeometryBuffer: boolean;
+    _expensiveBlur: boolean;
+    /**
+     * The radius around the analyzed pixel used by the SSAO post-process. Default value is 2.0
+     */
+    radius: number;
+    /**
+     * The base color of the SSAO post-process
+     * The final result is "base + ssao" between [0, 1]
+     */
+    base: number;
+    _bits: Uint32Array;
+    _scene: any;
+    _ratio: any;
+    _originalColorPostProcess: PassPostProcess | undefined;
+    /**
+     * Number of samples used for the SSAO calculations. Default value is 8
+     */
+    set samples(arg: number);
+    get samples(): number;
+    _sampleSphere: number[] | undefined;
+    /**
+     * Number of samples to use for antialiasing
+     */
+    set textureSamples(arg: number);
+    get textureSamples(): number;
+    get _geometryBufferRenderer(): any;
+    get _prePassRenderer(): any;
+    /**
+     * If bilateral blur should be used
+     */
+    set expensiveBlur(arg: boolean);
+    get expensiveBlur(): boolean;
+    /**
+     * Gets active scene
+     */
+    get scene(): any;
+    /**
+     * Removes the internal pipeline assets and detaches the pipeline from the scene cameras
+     * @param disableGeometryBufferRenderer
+     */
+    dispose(disableGeometryBufferRenderer?: boolean): void;
+    _createBlurPostProcess(ssaoRatio: any, blurRatio: any, textureType: any): void;
+    _samplerOffsets: any[] | undefined;
+    _blurHPostProcess: PostProcess | undefined;
+    _blurVPostProcess: PostProcess | undefined;
+    _radicalInverse_VdC(i: any): number;
+    _hammersley(i: any, n: any): number[];
+    _hemisphereSample_uniform(u: any, v: any): Vector3;
+    _generateHemisphere(): number[];
+    _getDefinesForSSAO(): string;
+    _createSSAOPostProcess(ratio: any, textureType: any): void;
+    _ssaoPostProcess: PostProcess | undefined;
+    _createSSAOCombinePostProcess(ratio: any, textureType: any): void;
+    _ssaoCombinePostProcess: PostProcess | undefined;
+    _createRandomTexture(): void;
+    _randomTexture: DynamicTexture | undefined;
+    /**
+     * Serialize the rendering pipeline (Used when exporting)
+     * @returns the serialized object
+     */
+    serialize(): any;
+}
+export namespace SSAO2RenderingPipeline {
+    const ORTHO_DEPTH_PROJECTION: number[];
+    const PERSPECTIVE_DEPTH_PROJECTION: number[];
+}
+import { PostProcessRenderPipeline } from "../../../PostProcesses/RenderPipeline/postProcessRenderPipeline.js";
+import { PassPostProcess } from "../../../PostProcesses/passPostProcess.js";
+import { PostProcess } from "../../../PostProcesses/postProcess.js";
+import { Vector3 } from "../../../Maths/math.vector.js";
+import { DynamicTexture } from "../../../Materials/Textures/dynamicTexture.js";

package/dist/types/node_modules/@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssaoRenderingPipeline.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Render pipeline to produce ssao effect
+ */
+export class SSAORenderingPipeline extends PostProcessRenderPipeline {
+    /**
+     * @constructor
+     * @param name - The rendering pipeline name
+     * @param scene - The scene linked to this pipeline
+     * @param ratio - The size of the postprocesses. Can be a number shared between passes or an object for more precision: { ssaoRatio: 0.5, combineRatio: 1.0 }
+     * @param cameras - The array of cameras that the rendering pipeline will be attached to
+     */
+    constructor(name: any, scene: any, ratio: any, cameras: any);
+    /**
+     * @ignore
+     * The PassPostProcess id in the pipeline that contains the original scene color
+     */
+    SSAOOriginalSceneColorEffect: string;
+    /**
+     * @ignore
+     * The SSAO PostProcess id in the pipeline
+     */
+    SSAORenderEffect: string;
+    /**
+     * @ignore
+     * The horizontal blur PostProcess id in the pipeline
+     */
+    SSAOBlurHRenderEffect: string;
+    /**
+     * @ignore
+     * The vertical blur PostProcess id in the pipeline
+     */
+    SSAOBlurVRenderEffect: string;
+    /**
+     * @ignore
+     * The PostProcess id in the pipeline that combines the SSAO-Blur output with the original scene color (SSAOOriginalSceneColorEffect)
+     */
+    SSAOCombineRenderEffect: string;
+    /**
+     * The output strength of the SSAO post-process. Default value is 1.0.
+     */
+    totalStrength: number;
+    /**
+     * The radius around the analyzed pixel used by the SSAO post-process. Default value is 0.0006
+     */
+    radius: number;
+    /**
+     * Related to fallOff, used to interpolate SSAO samples (first interpolate function input) based on the occlusion difference of each pixel
+     * Must not be equal to fallOff and superior to fallOff.
+     * Default value is 0.0075
+     */
+    area: number;
+    /**
+     * Related to area, used to interpolate SSAO samples (second interpolate function input) based on the occlusion difference of each pixel
+     * Must not be equal to area and inferior to area.
+     * Default value is 0.000001
+     */
+    fallOff: number;
+    /**
+     * The base color of the SSAO post-process
+     * The final result is "base + ssao" between [0, 1]
+     */
+    base: number;
+    _firstUpdate: boolean;
+    _scene: any;
+    _originalColorPostProcess: PassPostProcess;
+    /**
+     * Gets active scene
+     */
+    get scene(): any;
+    /**
+     * @internal
+     */
+    _attachCameras(cameras: any, unique: any): void;
+    /**
+     * Removes the internal pipeline assets and detaches the pipeline from the scene cameras
+     * @param disableDepthRender
+     */
+    dispose(disableDepthRender?: boolean): void;
+    _createBlurPostProcess(ratio: any): void;
+    _blurHPostProcess: BlurPostProcess | undefined;
+    _blurVPostProcess: BlurPostProcess | undefined;
+    _createSSAOPostProcess(ratio: any): void;
+    _ssaoPostProcess: PostProcess | undefined;
+    _createSSAOCombinePostProcess(ratio: any): void;
+    _ssaoCombinePostProcess: PostProcess | undefined;
+    _createRandomTexture(): void;
+    _randomTexture: DynamicTexture | undefined;
+}
+import { PostProcessRenderPipeline } from "../../../PostProcesses/RenderPipeline/postProcessRenderPipeline.js";
+import { PassPostProcess } from "../../../PostProcesses/passPostProcess.js";
+import { BlurPostProcess } from "../../../PostProcesses/blurPostProcess.js";
+import { PostProcess } from "../../../PostProcesses/postProcess.js";
+import { DynamicTexture } from "../../../Materials/Textures/dynamicTexture.js";