@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,354 @@
+/**
+ * Standard rendering pipeline
+ * Default pipeline should be used going forward but the standard pipeline will be kept for backwards compatibility.
+ * @see https://doc.babylonjs.com/how_to/using_standard_rendering_pipeline
+ */
+export class StandardRenderingPipeline 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): StandardRenderingPipeline;
+    /**
+     * Default pipeline should be used going forward but the standard pipeline will be kept for backwards compatibility.
+     * @constructor
+     * @param name The rendering pipeline name
+     * @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 originalPostProcess the custom original color post-process. Must be "reusable". Can be null.
+     * @param cameras The array of cameras that the rendering pipeline will be attached to
+     */
+    constructor(name: any, scene: any, ratio: any, originalPostProcess: null | undefined, cameras: any);
+    /**
+     * Post-process used to down scale an image x4
+     */
+    downSampleX4PostProcess: PostProcess | null;
+    /**
+     * Post-process used to calculate the illuminated surfaces controlled by a threshold
+     */
+    brightPassPostProcess: PostProcess | null;
+    /**
+     * Post-process array storing all the horizontal blur post-processes used by the pipeline
+     */
+    blurHPostProcesses: any[];
+    /**
+     * Post-process array storing all the vertical blur post-processes used by the pipeline
+     */
+    blurVPostProcesses: any[];
+    /**
+     * Post-process used to add colors of 2 textures (typically brightness + real scene color)
+     */
+    textureAdderPostProcess: PostProcess | null;
+    /**
+     * Post-process used to create volumetric lighting effect
+     */
+    volumetricLightPostProcess: PostProcess | null;
+    /**
+     * Post-process used to smooth the previous volumetric light post-process on the X axis
+     */
+    volumetricLightSmoothXPostProcess: any;
+    /**
+     * Post-process used to smooth the previous volumetric light post-process on the Y axis
+     */
+    volumetricLightSmoothYPostProcess: any;
+    /**
+     * Post-process used to merge the volumetric light effect and the real scene color
+     */
+    volumetricLightMergePostProces: PostProcess | null;
+    /**
+     * Post-process used to store the final volumetric light post-process (attach/detach for debug purpose)
+     */
+    volumetricLightFinalPostProcess: PostProcess | null;
+    /**
+     * Base post-process used to calculate the average luminance of the final image for HDR
+     */
+    luminancePostProcess: PostProcess | null;
+    /**
+     * Post-processes used to create down sample post-processes in order to get
+     * the average luminance of the final image for HDR
+     * Array of length "StandardRenderingPipeline.LuminanceSteps"
+     */
+    luminanceDownSamplePostProcesses: any[];
+    /**
+     * Post-process used to create a HDR effect (light adaptation)
+     */
+    hdrPostProcess: PostProcess | null;
+    /**
+     * Post-process used to store the final texture adder post-process (attach/detach for debug purpose)
+     */
+    textureAdderFinalPostProcess: PostProcess | null;
+    /**
+     * Post-process used to store the final lens flare post-process (attach/detach for debug purpose)
+     */
+    lensFlareFinalPostProcess: PostProcess | null;
+    /**
+     * Post-process used to merge the final HDR post-process and the real scene color
+     */
+    hdrFinalPostProcess: PostProcess | null;
+    /**
+     * Post-process used to create a lens flare effect
+     */
+    lensFlarePostProcess: PostProcess | null;
+    /**
+     * Post-process that merges the result of the lens flare post-process and the real scene color
+     */
+    lensFlareComposePostProcess: PostProcess | null;
+    /**
+     * Post-process used to create a motion blur effect
+     */
+    motionBlurPostProcess: PostProcess | MotionBlurPostProcess | null;
+    /**
+     * Post-process used to create a depth of field effect
+     */
+    depthOfFieldPostProcess: PostProcess | null;
+    /**
+     * The Fast Approximate Anti-Aliasing post process which attempts to remove aliasing from an image.
+     */
+    fxaaPostProcess: FxaaPostProcess | null;
+    /**
+     * Post-process used to simulate realtime reflections using the screen space and geometry renderer.
+     */
+    screenSpaceReflectionPostProcess: ScreenSpaceReflectionPostProcess | null;
+    /**
+     * Represents the brightness threshold in order to configure the illuminated surfaces
+     */
+    brightThreshold: number;
+    /**
+     * Configures the blur intensity used for surexposed surfaces are highlighted surfaces (light halo)
+     */
+    blurWidth: number;
+    /**
+     * Sets if the blur for highlighted surfaces must be only horizontal
+     */
+    horizontalBlur: boolean;
+    /**
+     * Texture used typically to simulate "dirty" on camera lens
+     */
+    lensTexture: any;
+    /**
+     * Represents the offset coefficient based on Rayleigh principle. Typically in interval [-0.2, 0.2]
+     */
+    volumetricLightCoefficient: number;
+    /**
+     * The overall power of volumetric lights, typically in interval [0, 10] maximum
+     */
+    volumetricLightPower: number;
+    /**
+     * Used the set the blur intensity to smooth the volumetric lights
+     */
+    volumetricLightBlurScale: number;
+    /**
+     * Light (spot or directional) used to generate the volumetric lights rays
+     * The source light must have a shadow generate so the pipeline can get its
+     * depth map
+     */
+    sourceLight: any;
+    /**
+     * For eye adaptation, represents the minimum luminance the eye can see
+     */
+    hdrMinimumLuminance: number;
+    /**
+     * For eye adaptation, represents the decrease luminance speed
+     */
+    hdrDecreaseRate: number;
+    /**
+     * For eye adaptation, represents the increase luminance speed
+     */
+    hdrIncreaseRate: number;
+    /**
+     * Lens color texture used by the lens flare effect. Mandatory if lens flare effect enabled
+     */
+    lensColorTexture: any;
+    /**
+     * The overall strength for the lens flare effect
+     */
+    lensFlareStrength: number;
+    /**
+     * Dispersion coefficient for lens flare ghosts
+     */
+    lensFlareGhostDispersal: number;
+    /**
+     * Main lens flare halo width
+     */
+    lensFlareHaloWidth: number;
+    /**
+     * Based on the lens distortion effect, defines how much the lens flare result
+     * is distorted
+     */
+    lensFlareDistortionStrength: number;
+    /**
+     * Configures the blur intensity used for for lens flare (halo)
+     */
+    lensFlareBlurWidth: number;
+    /**
+     * Lens star texture must be used to simulate rays on the flares and is available
+     * in the documentation
+     */
+    lensStarTexture: any;
+    /**
+     * As the "lensTexture" (can be the same texture or different), it is used to apply the lens
+     * flare effect by taking account of the dirt texture
+     */
+    lensFlareDirtTexture: any;
+    /**
+     * Represents the focal length for the depth of field effect
+     */
+    depthOfFieldDistance: number;
+    /**
+     * Represents the blur intensity for the blurred part of the depth of field effect
+     */
+    depthOfFieldBlurWidth: number;
+    /**
+     * List of animations for the pipeline (IAnimatable implementation)
+     */
+    animations: any[];
+    _currentDepthOfFieldSource: any;
+    _fixedExposure: number;
+    _currentExposure: number;
+    _hdrAutoExposure: boolean;
+    _hdrCurrentLuminance: number;
+    _motionStrength: number;
+    _isObjectBasedMotionBlur: boolean;
+    _camerasToBeAttached: any;
+    _bloomEnabled: boolean;
+    _depthOfFieldEnabled: boolean;
+    _vlsEnabled: boolean;
+    _lensFlareEnabled: boolean;
+    _hdrEnabled: boolean;
+    _motionBlurEnabled: boolean;
+    _fxaaEnabled: boolean;
+    _screenSpaceReflectionsEnabled: boolean;
+    _motionBlurSamples: number;
+    _volumetricLightStepsCount: number;
+    _samples: number;
+    _cameras: any;
+    _scene: any;
+    _basePostProcess: any;
+    _ratio: any;
+    _floatTextureType: number;
+    /**
+     * Sets the overall exposure used by the pipeline
+     */
+    set exposure(arg: number);
+    /**
+     * Gets the overall exposure used by the pipeline
+     */
+    get exposure(): number;
+    /**
+     * Sets whether or not the exposure of the overall pipeline should be automatically adjusted by the HDR post-process
+     */
+    set hdrAutoExposure(arg: boolean);
+    /**
+     * Gets whether or not the exposure of the overall pipeline should be automatically adjusted by the HDR post-process
+     */
+    get hdrAutoExposure(): boolean;
+    /**
+     * Sets how much the image is blurred by the movement while using the motion blur post-process
+     */
+    set motionStrength(arg: number);
+    /**
+     * Gets how much the image is blurred by the movement while using the motion blur post-process
+     */
+    get motionStrength(): number;
+    /**
+     * Sets whether or not the motion blur post-process should be object based or screen based
+     */
+    set objectBasedMotionBlur(arg: boolean);
+    /**
+     * Gets whether or not the motion blur post-process is object based or screen based.
+     */
+    get objectBasedMotionBlur(): boolean;
+    set BloomEnabled(arg: boolean);
+    /**
+     * @ignore
+     * Specifies if the bloom pipeline is enabled
+     */
+    get BloomEnabled(): boolean;
+    set DepthOfFieldEnabled(arg: boolean);
+    /**
+     * @ignore
+     * Specifies if the depth of field pipeline is enabled
+     */
+    get DepthOfFieldEnabled(): boolean;
+    set LensFlareEnabled(arg: boolean);
+    /**
+     * @ignore
+     * Specifies if the lens flare pipeline is enabled
+     */
+    get LensFlareEnabled(): boolean;
+    set HDREnabled(arg: boolean);
+    /**
+     * @ignore
+     * Specifies if the HDR pipeline is enabled
+     */
+    get HDREnabled(): boolean;
+    set VLSEnabled(arg: boolean);
+    /**
+     * @ignore
+     * Specifies if the volumetric lights scattering effect is enabled
+     */
+    get VLSEnabled(): boolean;
+    set MotionBlurEnabled(arg: boolean);
+    /**
+     * @ignore
+     * Specifies if the motion blur effect is enabled
+     */
+    get MotionBlurEnabled(): boolean;
+    set fxaaEnabled(arg: boolean);
+    /**
+     * Specifies if anti-aliasing is enabled
+     */
+    get fxaaEnabled(): boolean;
+    set screenSpaceReflectionsEnabled(arg: boolean);
+    /**
+     * Specifies if screen space reflections are enabled.
+     */
+    get screenSpaceReflectionsEnabled(): boolean;
+    set volumetricLightStepsCount(arg: number);
+    /**
+     * Specifies the number of steps used to calculate the volumetric lights
+     * Typically in interval [50, 200]
+     */
+    get volumetricLightStepsCount(): number;
+    set motionBlurSamples(arg: number);
+    /**
+     * Specifies the number of samples used for the motion blur effect
+     * Typically in interval [16, 64]
+     */
+    get motionBlurSamples(): number;
+    set samples(arg: number);
+    /**
+     * Specifies MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
+     */
+    get samples(): number;
+    _buildPipeline(): void;
+    originalPostProcess: any;
+    _createDownSampleX4PostProcess(scene: any, ratio: any): void;
+    _createBrightPassPostProcess(scene: any, ratio: any): void;
+    _createBlurPostProcesses(scene: any, ratio: any, indice: any, blurWidthKey?: string): void;
+    _createTextureAdderPostProcess(scene: any, ratio: any): void;
+    _createVolumetricLightPostProcess(scene: any, ratio: any): void;
+    _createLuminancePostProcesses(scene: any, textureType: any): void;
+    _createHdrPostProcess(scene: any, ratio: any): void;
+    _createLensFlarePostProcess(scene: any, ratio: any): void;
+    _createDepthOfFieldPostProcess(scene: any, ratio: any): void;
+    _createMotionBlurPostProcess(scene: any, ratio: any): void;
+    _getDepthTexture(): any;
+    _disposePostProcesses(): void;
+    /**
+     * Serialize the rendering pipeline (Used when exporting)
+     * @returns the serialized object
+     */
+    serialize(): any;
+}
+export namespace StandardRenderingPipeline {
+    const LuminanceSteps: number;
+}
+import { PostProcessRenderPipeline } from "../../../PostProcesses/RenderPipeline/postProcessRenderPipeline.js";
+import { PostProcess } from "../../../PostProcesses/postProcess.js";
+import { MotionBlurPostProcess } from "../../motionBlurPostProcess.js";
+import { FxaaPostProcess } from "../../../PostProcesses/fxaaPostProcess.js";
+import { ScreenSpaceReflectionPostProcess } from "../../screenSpaceReflectionPostProcess.js";

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

@@ -0,0 +1,5 @@
+export * from "./Pipelines/index.js";
+export * from "./postProcessRenderEffect.js";
+export * from "./postProcessRenderPipeline.js";
+export * from "./postProcessRenderPipelineManager.js";
+export * from "./postProcessRenderPipelineManagerSceneComponent.js";

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

@@ -0,0 +1,61 @@
+/**
+ * This represents a set of one or more post processes in Babylon.
+ * A post process can be used to apply a shader to a texture after it is rendered.
+ * @example https://doc.babylonjs.com/how_to/how_to_use_postprocessrenderpipeline
+ */
+export class PostProcessRenderEffect {
+    /**
+     * Instantiates a post process render effect.
+     * A post process can be used to apply a shader to a texture after it is rendered.
+     * @param engine The engine the effect is tied to
+     * @param name The name of the effect
+     * @param getPostProcesses A function that returns a set of post processes which the effect will run in order to be run.
+     * @param singleInstance False if this post process can be run on multiple cameras. (default: true)
+     */
+    constructor(engine: any, name: any, getPostProcesses: any, singleInstance: any);
+    _name: any;
+    _singleInstance: any;
+    _getPostProcesses: any;
+    _cameras: {};
+    _indicesForCamera: {};
+    _postProcesses: {};
+    /**
+     * Checks if all the post processes in the effect are supported.
+     */
+    get isSupported(): boolean;
+    /**
+     * Updates the current state of the effect
+     * @internal
+     */
+    _update(): void;
+    /**
+     * Attaches the effect on cameras
+     * @param cameras The camera to attach to.
+     * @internal
+     */
+    _attachCameras(cameras: any): void;
+    /**
+     * Detaches the effect on cameras
+     * @param cameras The camera to detach from.
+     * @internal
+     */
+    _detachCameras(cameras: any): void;
+    /**
+     * Enables the effect on given cameras
+     * @param cameras The camera to enable.
+     * @internal
+     */
+    _enable(cameras: any): void;
+    /**
+     * Disables the effect on the given cameras
+     * @param cameras The camera to disable.
+     * @internal
+     */
+    _disable(cameras: any): void;
+    /**
+     * Gets a list of the post processes contained in the effect.
+     * @param camera The camera to get the post processes on.
+     * @returns The list of the post processes in the effect.
+     */
+    getPostProcesses(camera: any): any;
+}

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

@@ -0,0 +1,70 @@
+/**
+ * PostProcessRenderPipeline
+ * @see https://doc.babylonjs.com/how_to/how_to_use_postprocessrenderpipeline
+ */
+export class PostProcessRenderPipeline {
+    /**
+     * Initializes a PostProcessRenderPipeline
+     * @param _engine engine to add the pipeline to
+     * @param name name of the pipeline
+     */
+    constructor(_engine: any, name: any);
+    _engine: any;
+    _name: any;
+    _renderEffects: {};
+    _renderEffectsForIsolatedPass: any[];
+    _cameras: any[];
+    /**
+     * Gets pipeline name
+     */
+    get name(): any;
+    /** Gets the list of attached cameras */
+    get cameras(): any[];
+    /**
+     * Gets the class name
+     * @returns "PostProcessRenderPipeline"
+     */
+    getClassName(): string;
+    /**
+     * If all the render effects in the pipeline are supported
+     */
+    get isSupported(): boolean;
+    /**
+     * Adds an effect to the pipeline
+     * @param renderEffect the effect to add
+     */
+    addEffect(renderEffect: any): void;
+    /** @internal */
+    _rebuild(): void;
+    /**
+     * @internal
+     */
+    _enableEffect(renderEffectName: any, cameras: any): void;
+    /**
+     * @internal
+     */
+    _disableEffect(renderEffectName: any, cameras: any): void;
+    /**
+     * @internal
+     */
+    _attachCameras(cameras: any, unique: any): void;
+    /**
+     * @internal
+     */
+    _detachCameras(cameras: any): void;
+    /** @internal */
+    _update(): void;
+    /** @internal */
+    _reset(): void;
+    _enableMSAAOnFirstPostProcess(sampleCount: any): boolean;
+    /**
+     * Sets the required values to the prepass renderer.
+     * @param prePassRenderer defines the prepass renderer to setup.
+     * @returns true if the pre pass is needed.
+     */
+    setPrePassRenderer(prePassRenderer: any): boolean;
+    /**
+     * Disposes of the pipeline
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,53 @@
+/**
+ * PostProcessRenderPipelineManager class
+ * @see https://doc.babylonjs.com/how_to/how_to_use_postprocessrenderpipeline
+ */
+export class PostProcessRenderPipelineManager {
+    _renderPipelines: {};
+    /**
+     * Gets the list of supported render pipelines
+     */
+    get supportedPipelines(): any[];
+    /**
+     * Adds a pipeline to the manager
+     * @param renderPipeline The pipeline to add
+     */
+    addPipeline(renderPipeline: any): void;
+    /**
+     * Attaches a camera to the pipeline
+     * @param renderPipelineName The name of the pipeline to attach to
+     * @param cameras the camera to attach
+     * @param unique if the camera can be attached multiple times to the pipeline
+     */
+    attachCamerasToRenderPipeline(renderPipelineName: any, cameras: any, unique?: boolean): void;
+    /**
+     * Detaches a camera from the pipeline
+     * @param renderPipelineName The name of the pipeline to detach from
+     * @param cameras the camera to detach
+     */
+    detachCamerasFromRenderPipeline(renderPipelineName: any, cameras: any): void;
+    /**
+     * Enables an effect by name on a pipeline
+     * @param renderPipelineName the name of the pipeline to enable the effect in
+     * @param renderEffectName the name of the effect to enable
+     * @param cameras the cameras that the effect should be enabled on
+     */
+    enableEffectInPipeline(renderPipelineName: any, renderEffectName: any, cameras: any): void;
+    /**
+     * Disables an effect by name on a pipeline
+     * @param renderPipelineName the name of the pipeline to disable the effect in
+     * @param renderEffectName the name of the effect to disable
+     * @param cameras the cameras that the effect should be disabled on
+     */
+    disableEffectInPipeline(renderPipelineName: any, renderEffectName: any, cameras: any): void;
+    /**
+     * Updates the state of all contained render pipelines and disposes of any non supported pipelines
+     */
+    update(): void;
+    /** @internal */
+    _rebuild(): void;
+    /**
+     * Disposes of the manager and pipelines
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Defines the Render Pipeline scene component responsible to rendering pipelines
+ */
+export class PostProcessRenderPipelineManagerSceneComponent {
+    /**
+     * Creates a new instance of the component for the given scene
+     * @param scene Defines the scene to register the component in
+     */
+    constructor(scene: any);
+    /**
+     * The component name helpful to identify the component in the list of scene components.
+     */
+    name: string;
+    scene: any;
+    /**
+     * Registers the component in a given scene
+     */
+    register(): void;
+    /**
+     * Rebuilds the elements related to this component in case of
+     * context lost for instance.
+     */
+    rebuild(): void;
+    /**
+     * Disposes the component and the associated resources
+     */
+    dispose(): void;
+    _gatherRenderTargets(): void;
+}

package/dist/types/node_modules/@babylonjs/core/PostProcesses/anaglyphPostProcess.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Postprocess used to generate anaglyphic rendering
+ */
+export class AnaglyphPostProcess extends PostProcess {
+    /**
+     * Creates a new AnaglyphPostProcess
+     * @param name defines postprocess name
+     * @param options defines creation options or target ratio scale
+     * @param rigCameras defines cameras using this postprocess
+     * @param samplingMode defines required sampling mode (BABYLON.Texture.NEAREST_SAMPLINGMODE by default)
+     * @param engine defines hosting engine
+     * @param reusable defines if the postprocess will be reused multiple times per frame
+     */
+    constructor(name: any, options: any, rigCameras: any, samplingMode: any, engine: any, reusable: any);
+    _passedProcess: any;
+}
+import { PostProcess } from "./postProcess.js";

package/dist/types/node_modules/@babylonjs/core/PostProcesses/blackAndWhitePostProcess.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Post process used to render in black and white
+ */
+export class BlackAndWhitePostProcess extends PostProcess {
+    /**
+     * @internal
+     */
+    static _Parse(parsedPostProcess: any, targetCamera: any, scene: any, rootUrl: any): BlackAndWhitePostProcess;
+    /**
+     * Creates a black and white post process
+     * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses#black-and-white
+     * @param name The name of the effect.
+     * @param options The required width/height ratio to downsize to before computing the render pass.
+     * @param camera The camera to apply the render pass to.
+     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
+     * @param engine The engine which the post process will be applied. (default: current engine)
+     * @param reusable If the post process can be reused on the same frame. (default: false)
+     */
+    constructor(name: any, options: any, camera: any, samplingMode: any, engine: any, reusable: any);
+    /**
+     * Linear about to convert he result to black and white (default: 1)
+     */
+    degree: number;
+}
+import { PostProcess } from "./postProcess.js";

package/dist/types/node_modules/@babylonjs/core/PostProcesses/bloomEffect.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The bloom effect spreads bright areas of an image to simulate artifacts seen in cameras
+ */
+export class BloomEffect extends PostProcessRenderEffect {
+    /**
+     * Creates a new instance of @see BloomEffect
+     * @param scene The scene the effect belongs to.
+     * @param _bloomScale The ratio of the blur texture to the input texture that should be used to compute the bloom.
+     * @param bloomWeight The the strength of bloom.
+     * @param bloomKernel The size of the kernel to be used when applying the blur.
+     * @param pipelineTextureType The type of texture to be used when performing the post processing.
+     * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
+     */
+    constructor(scene: any, _bloomScale: any, bloomWeight: any, bloomKernel: any, pipelineTextureType?: number, blockCompilation?: boolean);
+    _bloomScale: any;
+    /**
+     * @internal Internal
+     */
+    _effects: (BlurPostProcess | ExtractHighlightsPostProcess)[];
+    _downscale: ExtractHighlightsPostProcess;
+    _blurX: BlurPostProcess;
+    _blurY: BlurPostProcess;
+    set kernel(arg: number);
+    /**
+     * Specifies the size of the bloom blur kernel, relative to the final output size
+     */
+    get kernel(): number;
+    _merge: BloomMergePostProcess;
+    set threshold(arg: number);
+    /**
+     * The luminance threshold to find bright areas of the image to bloom.
+     */
+    get threshold(): number;
+    set weight(arg: number);
+    /**
+     * The strength of the bloom.
+     */
+    get weight(): number;
+    /**
+     * Disposes each of the internal effects for a given camera.
+     * @param camera The camera to dispose the effect on.
+     */
+    disposeEffects(camera: any): void;
+    /**
+     * @internal Internal
+     */
+    _updateEffects(): void;
+    /**
+     * Internal
+     * @returns if all the contained post processes are ready.
+     * @internal
+     */
+    _isReady(): boolean;
+}
+import { PostProcessRenderEffect } from "../PostProcesses/RenderPipeline/postProcessRenderEffect.js";
+import { BlurPostProcess } from "./blurPostProcess.js";
+import { ExtractHighlightsPostProcess } from "./extractHighlightsPostProcess.js";
+import { BloomMergePostProcess } from "./bloomMergePostProcess.js";