@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,320 @@
+/**
+ * PostProcess can be used to apply a shader to a texture after it has been rendered
+ * See https://doc.babylonjs.com/how_to/how_to_use_postprocesses
+ */
+export class PostProcess {
+    /**
+     * Creates a material from parsed material data
+     * @param parsedPostProcess defines parsed post process data
+     * @param scene defines the hosting scene
+     * @param rootUrl defines the root URL to use to load textures
+     * @returns a new post process
+     */
+    static Parse(parsedPostProcess: any, scene: any, rootUrl: any): any;
+    /**
+     * @internal
+     */
+    static _Parse(parsedPostProcess: any, targetCamera: any, scene: any, rootUrl: any): PostProcess;
+    /**
+     * Creates a new instance PostProcess
+     * @param name The name of the PostProcess.
+     * @param fragmentUrl The url of the fragment shader to be used.
+     * @param parameters Array of the names of uniform non-sampler2D variables that will be passed to the shader.
+     * @param samplers Array of the names of uniform sampler2D variables that will be passed to the shader.
+     * @param options The required width/height ratio to downsize to before computing the render pass. (Use 1.0 for full size)
+     * @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)
+     * @param defines String of defines that will be set when running the fragment shader. (default: null)
+     * @param textureType Type of textures used when performing the post process. (default: 0)
+     * @param vertexUrl The url of the vertex shader to be used. (default: "postprocess")
+     * @param indexParameters The index parameters to be used for babylons include syntax "#include<kernelBlurVaryingDeclaration>[0..varyingCount]". (default: undefined) See usage in babylon.blurPostProcess.ts and kernelBlur.vertex.fx
+     * @param blockCompilation If the shader should not be compiled immediatly. (default: false)
+     * @param textureFormat Format of textures used when performing the post process. (default: TEXTUREFORMAT_RGBA)
+     */
+    constructor(name: any, fragmentUrl: any, parameters: any, samplers: any, options: any, camera: any, samplingMode: number | undefined, engine: any, reusable: any, defines: null | undefined, textureType: number | undefined, vertexUrl: string | undefined, indexParameters: any, blockCompilation?: boolean, textureFormat?: number);
+    /** @internal */
+    _parentContainer: any;
+    /**
+     * Width of the texture to apply the post process on
+     */
+    width: number;
+    /**
+     * Height of the texture to apply the post process on
+     */
+    height: number;
+    /**
+     * Gets the node material used to create this postprocess (null if the postprocess was manually created)
+     */
+    nodeMaterialSource: any;
+    /**
+     * Internal, reference to the location where this postprocess was output to. (Typically the texture on the next postprocess in the chain)
+     * @internal
+     */
+    _outputTexture: any;
+    /**
+     * If the buffer needs to be cleared before applying the post process. (default: true)
+     * Should be set to false if shader will overwrite all previous pixels.
+     */
+    autoClear: boolean;
+    /**
+     * Type of alpha mode to use when performing the post process (default: Engine.ALPHA_DISABLE)
+     */
+    alphaMode: number;
+    /**
+     * Animations to be used for the post processing
+     */
+    animations: any[];
+    /**
+     * Enable Pixel Perfect mode where texture is not scaled to be power of 2.
+     * Can only be used on a single postprocess or on the last one of a chain. (default: false)
+     */
+    enablePixelPerfectMode: boolean;
+    /**
+     * Force the postprocess to be applied without taking in account viewport
+     */
+    forceFullscreenViewport: boolean;
+    /**
+     * Scale mode for the post process (default: Engine.SCALEMODE_FLOOR)
+     *
+     * | Value | Type                                | Description |
+     * | ----- | ----------------------------------- | ----------- |
+     * | 1     | SCALEMODE_FLOOR                     | [engine.scalemode_floor](https://doc.babylonjs.com/api/classes/babylon.engine#scalemode_floor) |
+     * | 2     | SCALEMODE_NEAREST                   | [engine.scalemode_nearest](https://doc.babylonjs.com/api/classes/babylon.engine#scalemode_nearest) |
+     * | 3     | SCALEMODE_CEILING                   | [engine.scalemode_ceiling](https://doc.babylonjs.com/api/classes/babylon.engine#scalemode_ceiling) |
+     *
+     */
+    scaleMode: number;
+    /**
+     * Force textures to be a power of two (default: false)
+     */
+    alwaysForcePOT: boolean;
+    _samples: number;
+    /**
+     * Modify the scale of the post process to be the same as the viewport (default: false)
+     */
+    adaptScaleToCurrentViewport: boolean;
+    _reusable: any;
+    _renderId: number;
+    /**
+     * if externalTextureSamplerBinding is true, the "apply" method won't bind the textureSampler texture, it is expected to be done by the "outside" (by the onApplyObservable observer most probably).
+     * counter-productive in some cases because if the texture bound by "apply" is different from the currently texture bound, (the one set by the onApplyObservable observer, for eg) some
+     * internal structures (materialContext) will be dirtified, which may impact performances
+     */
+    externalTextureSamplerBinding: boolean;
+    /**
+     * Smart array of input and output textures for the post process.
+     * @internal
+     */
+    _textures: SmartArray<any>;
+    /**
+     * Smart array of input and output textures for the post process.
+     * @internal
+     */
+    _textureCache: any[];
+    /**
+     * The index in _textures that corresponds to the output texture.
+     * @internal
+     */
+    _currentRenderTextureInd: number;
+    _scaleRatio: Vector2;
+    _texelSize: Vector2;
+    /**
+     * An event triggered when the postprocess is activated.
+     */
+    onActivateObservable: Observable<any>;
+    /**
+     * An event triggered when the postprocess changes its size.
+     */
+    onSizeChangedObservable: Observable<any>;
+    /**
+     * An event triggered when the postprocess applies its effect.
+     */
+    onApplyObservable: Observable<any>;
+    /**
+     * An event triggered before rendering the postprocess
+     */
+    onBeforeRenderObservable: Observable<any>;
+    /**
+     * An event triggered after rendering the postprocess
+     */
+    onAfterRenderObservable: Observable<any>;
+    name: any;
+    _camera: any;
+    _scene: any;
+    _engine: any;
+    uniqueId: any;
+    _options: any;
+    renderTargetSamplingMode: number;
+    _textureType: number;
+    _textureFormat: number;
+    _samplers: any;
+    _fragmentUrl: any;
+    _vertexUrl: string;
+    _parameters: any;
+    _indexParameters: any;
+    _drawWrapper: DrawWrapper;
+    set samples(arg: number);
+    /**
+     * Number of sample textures (default: 1)
+     */
+    get samples(): number;
+    /**
+     * Returns the fragment url or shader name used in the post process.
+     * @returns the fragment url or name in the shader store.
+     */
+    getEffectName(): any;
+    /**
+     * A function that is added to the onActivateObservable
+     */
+    set onActivate(arg: any);
+    _onActivateObserver: import("@babylonjs/core").Nullable<import("../Misc/observable.js").Observer<any>> | undefined;
+    /**
+     * A function that is added to the onSizeChangedObservable
+     */
+    set onSizeChanged(arg: any);
+    _onSizeChangedObserver: import("@babylonjs/core").Nullable<import("../Misc/observable.js").Observer<any>> | undefined;
+    /**
+     * A function that is added to the onApplyObservable
+     */
+    set onApply(arg: any);
+    _onApplyObserver: import("@babylonjs/core").Nullable<import("../Misc/observable.js").Observer<any>> | undefined;
+    /**
+     * A function that is added to the onBeforeRenderObservable
+     */
+    set onBeforeRender(arg: any);
+    _onBeforeRenderObserver: import("@babylonjs/core").Nullable<import("../Misc/observable.js").Observer<any>> | undefined;
+    /**
+     * A function that is added to the onAfterRenderObservable
+     */
+    set onAfterRender(arg: any);
+    _onAfterRenderObserver: import("@babylonjs/core").Nullable<import("../Misc/observable.js").Observer<any>> | undefined;
+    set inputTexture(arg: any);
+    /**
+     * The input texture for this post process and the output texture of the previous post process. When added to a pipeline the previous post process will
+     * render it's output into this texture and this texture will be used as textureSampler in the fragment shader of this post process.
+     */
+    get inputTexture(): any;
+    _forcedOutputTexture: any;
+    /**
+     * Since inputTexture should always be defined, if we previously manually set `inputTexture`,
+     * the only way to unset it is to use this function to restore its internal state
+     */
+    restoreDefaultInputTexture(): void;
+    /**
+     * Gets the camera which post process is applied to.
+     * @returns The camera the post process is applied to.
+     */
+    getCamera(): any;
+    /**
+     * Gets the texel size of the postprocess.
+     * See https://en.wikipedia.org/wiki/Texel_(graphics)
+     */
+    get texelSize(): any;
+    /**
+     * Gets a string identifying the name of the class
+     * @returns "PostProcess" string
+     */
+    getClassName(): string;
+    /**
+     * Gets the engine which this post process belongs to.
+     * @returns The engine the post process was enabled with.
+     */
+    getEngine(): any;
+    /**
+     * The effect that is created when initializing the post process.
+     * @returns The created effect corresponding the the postprocess.
+     */
+    getEffect(): import("@babylonjs/core").Nullable<import("@babylonjs/core").Effect>;
+    /**
+     * To avoid multiple redundant textures for multiple post process, the output the output texture for this post process can be shared with another.
+     * @param postProcess The post process to share the output with.
+     * @returns This post process.
+     */
+    shareOutputWith(postProcess: any): PostProcess;
+    _shareOutputWithPostProcess: any;
+    /**
+     * Reverses the effect of calling shareOutputWith and returns the post process back to its original state.
+     * This should be called if the post process that shares output with this post process is disabled/disposed.
+     */
+    useOwnOutput(): void;
+    /**
+     * Updates the effect with the current post process compile time values and recompiles the shader.
+     * @param defines Define statements that should be added at the beginning of the shader. (default: null)
+     * @param uniforms Set of uniform variables that will be passed to the shader. (default: null)
+     * @param samplers Set of Texture2D variables that will be passed to the shader. (default: null)
+     * @param indexParameters The index parameters to be used for babylons include syntax "#include<kernelBlurVaryingDeclaration>[0..varyingCount]". (default: undefined) See usage in babylon.blurPostProcess.ts and kernelBlur.vertex.fx
+     * @param onCompiled Called when the shader has been compiled.
+     * @param onError Called if there is an error when compiling a shader.
+     * @param vertexUrl The url of the vertex shader to be used (default: the one given at construction time)
+     * @param fragmentUrl The url of the fragment shader to be used (default: the one given at construction time)
+     */
+    updateEffect(defines: null | undefined, uniforms: null | undefined, samplers: null | undefined, indexParameters: any, onCompiled: any, onError: any, vertexUrl: any, fragmentUrl: any): void;
+    _postProcessDefines: any;
+    /**
+     * The post process is reusable if it can be used multiple times within one frame.
+     * @returns If the post process is reusable
+     */
+    isReusable(): any;
+    /** invalidate frameBuffer to hint the postprocess to create a depth buffer */
+    markTextureDirty(): void;
+    _createRenderTargetTexture(textureSize: any, textureOptions: any, channel?: number): any;
+    _flushTextureCache(): void;
+    _resize(width: any, height: any, camera: any, needMipMaps: any, forceDepthStencil: any): void;
+    /**
+     * Activates the post process by intializing the textures to be used when executed. Notifies onActivateObservable.
+     * When this post process is used in a pipeline, this is call will bind the input texture of this post process to the output of the previous.
+     * @param camera The camera that will be used in the post process. This camera will be used when calling onActivateObservable.
+     * @param sourceTexture The source texture to be inspected to get the width and height if not specified in the post process constructor. (default: null)
+     * @param forceDepthStencil If true, a depth and stencil buffer will be generated. (default: false)
+     * @returns The render target wrapper that was bound to be written to.
+     */
+    activate(camera: any, sourceTexture: null | undefined, forceDepthStencil: any): any;
+    /**
+     * If the post process is supported.
+     */
+    get isSupported(): boolean;
+    /**
+     * The aspect ratio of the output texture.
+     */
+    get aspectRatio(): any;
+    /**
+     * Get a value indicating if the post-process is ready to be used
+     * @returns true if the post-process is ready (shader is compiled)
+     */
+    isReady(): boolean;
+    /**
+     * Binds all textures and uniforms to the shader, this will be run on every pass.
+     * @returns the effect corresponding to this post process. Null if not compiled or not ready.
+     */
+    apply(): import("@babylonjs/core").Nullable<import("@babylonjs/core").Effect>;
+    _disposeTextures(): void;
+    _disposeTextureCache(): void;
+    /**
+     * 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;
+    _prePassEffectConfiguration: any;
+    /**
+     * Disposes the post process.
+     * @param camera The camera to dispose the post process on.
+     */
+    dispose(camera: any): void;
+    /**
+     * Serializes the post process to a JSON object
+     * @returns the JSON object
+     */
+    serialize(): any;
+    /**
+     * Clones this post process
+     * @returns a new post process similar to this one
+     */
+    clone(): any;
+}
+import { SmartArray } from "../Misc/smartArray.js";
+import { Vector2 } from "../Maths/math.vector.js";
+import { Observable } from "../Misc/observable.js";
+import { DrawWrapper } from "../Materials/drawWrapper.js";

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

@@ -0,0 +1,54 @@
+/**
+ * PostProcessManager is used to manage one or more post processes or post process pipelines
+ * See https://doc.babylonjs.com/how_to/how_to_use_postprocesses
+ */
+export class PostProcessManager {
+    /**
+     * Creates a new instance PostProcess
+     * @param scene The scene that the post process is associated with.
+     */
+    constructor(scene: any);
+    _vertexBuffers: {};
+    _scene: any;
+    _prepareBuffers(): void;
+    _buildIndexBuffer(): void;
+    _indexBuffer: any;
+    /**
+     * Rebuilds the vertex buffers of the manager.
+     * @internal
+     */
+    _rebuild(): void;
+    /**
+     * Prepares a frame to be run through a post process.
+     * @param sourceTexture The input texture to the post processes. (default: null)
+     * @param postProcesses An array of post processes to be run. (default: null)
+     * @returns True if the post processes were able to be run.
+     * @internal
+     */
+    _prepareFrame(sourceTexture?: null, postProcesses?: null): boolean;
+    /**
+     * Manually render a set of post processes to a texture.
+     * Please note, the frame buffer won't be unbound after the call in case you have more render to do.
+     * @param postProcesses An array of post processes to be run.
+     * @param targetTexture The render target wrapper to render to.
+     * @param forceFullscreenViewport force gl.viewport to be full screen eg. 0,0,textureWidth,textureHeight
+     * @param faceIndex defines the face to render to if a cubemap is defined as the target
+     * @param lodLevel defines which lod of the texture to render to
+     * @param doNotBindFrambuffer If set to true, assumes that the framebuffer has been bound previously
+     */
+    directRender(postProcesses: any, targetTexture?: null, forceFullscreenViewport?: boolean, faceIndex?: number, lodLevel?: number, doNotBindFrambuffer?: boolean): void;
+    /**
+     * Finalize the result of the output of the postprocesses.
+     * @param doNotPresent If true the result will not be displayed to the screen.
+     * @param targetTexture The render target wrapper to render to.
+     * @param faceIndex The index of the face to bind the target texture to.
+     * @param postProcesses The array of post processes to render.
+     * @param forceFullscreenViewport force gl.viewport to be full screen eg. 0,0,textureWidth,textureHeight (default: false)
+     * @internal
+     */
+    _finalizeFrame(doNotPresent: any, targetTexture: any, faceIndex: any, postProcesses: any, forceFullscreenViewport?: boolean): void;
+    /**
+     * Disposes of the post process manager.
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * Post process which applies a refraction texture
+ * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses#refraction
+ */
+export class RefractionPostProcess extends PostProcess {
+    /**
+     * @internal
+     */
+    static _Parse(parsedPostProcess: any, targetCamera: any, scene: any, rootUrl: any): RefractionPostProcess;
+    /**
+     * Initializes the RefractionPostProcess
+     * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses#refraction
+     * @param name The name of the effect.
+     * @param refractionTextureUrl Url of the refraction texture to use
+     * @param color the base color of the refraction (used to taint the rendering)
+     * @param depth simulated refraction depth
+     * @param colorLevel the coefficient of the base color (0 to remove base color tainting)
+     * @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, refractionTextureUrl: any, color: any, depth: any, colorLevel: any, options: any, camera: any, samplingMode: any, engine: any, reusable: any);
+    _ownRefractionTexture: boolean;
+    color: any;
+    depth: any;
+    colorLevel: any;
+    refractionTextureUrl: any;
+    _refTexture: any;
+    set refractionTexture(arg: any);
+    /**
+     * Gets or sets the refraction texture
+     * Please note that you are responsible for disposing the texture if you set it manually
+     */
+    get refractionTexture(): any;
+    /**
+     * Disposes of the post process
+     * @param camera Camera to dispose post process on
+     */
+    dispose(camera: any): void;
+}
+import { PostProcess } from "./postProcess.js";

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

@@ -0,0 +1,36 @@
+/**
+ * The Screen Space curvature effect can help highlighting ridge and valley of a model.
+ */
+export class ScreenSpaceCurvaturePostProcess extends PostProcess {
+    /**
+     * Support test.
+     */
+    static get IsSupported(): boolean;
+    /**
+     * @internal
+     */
+    static _Parse(parsedPostProcess: any, targetCamera: any, scene: any, rootUrl: any): ScreenSpaceCurvaturePostProcess;
+    /**
+     * Creates a new instance ScreenSpaceCurvaturePostProcess
+     * @param name The name of the effect.
+     * @param scene The scene containing the objects to blur according to their velocity.
+     * @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)
+     * @param textureType Type of textures used when performing the post process. (default: 0)
+     * @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(name: any, scene: any, options: any, camera: any, samplingMode: any, engine: any, reusable: any, textureType?: number, blockCompilation?: boolean);
+    /**
+     * Defines how much ridge the curvature effect displays.
+     */
+    ridge: number;
+    /**
+     * Defines how much valley the curvature effect displays.
+     */
+    valley: number;
+    _geometryBufferRenderer: any;
+}
+import { PostProcess } from "./postProcess.js";

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

@@ -0,0 +1,84 @@
+/**
+ * The ScreenSpaceReflectionPostProcess performs realtime reflections using only and only the available informations on the screen (positions and normals).
+ * Basically, the screen space reflection post-process will compute reflections according the material's reflectivity.
+ */
+export class ScreenSpaceReflectionPostProcess extends PostProcess {
+    /**
+     * @internal
+     */
+    static _Parse(parsedPostProcess: any, targetCamera: any, scene: any, rootUrl: any): ScreenSpaceReflectionPostProcess;
+    /**
+     * Creates a new instance of ScreenSpaceReflectionPostProcess.
+     * @param name The name of the effect.
+     * @param scene The scene containing the objects to calculate reflections.
+     * @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)
+     * @param textureType Type of textures used when performing the post process. (default: 0)
+     * @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: true)
+     * @param forceGeometryBuffer If this post process should use geometry buffer instead of prepass (default: false)
+     */
+    constructor(name: any, scene: any, options: any, camera: any, samplingMode: any, engine: any, reusable: any, textureType?: number, blockCompilation?: boolean, forceGeometryBuffer?: boolean);
+    /**
+     * Gets or sets a reflection threshold mainly used to adjust the reflection's height.
+     */
+    threshold: number;
+    /**
+     * Gets or sets the current reflection strength. 1.0 is an ideal value but can be increased/decreased for particular results.
+     */
+    strength: number;
+    /**
+     * Gets or sets the falloff exponent used while computing fresnel. More the exponent is high, more the reflections will be discrete.
+     */
+    reflectionSpecularFalloffExponent: number;
+    /**
+     * Gets or sets the step size used to iterate until the effect finds the color of the reflection's pixel. Typically in interval [0.1, 1.0]
+     */
+    step: number;
+    /**
+     * Gets or sets the factor applied when computing roughness. Default value is 0.2.
+     */
+    roughnessFactor: number;
+    _forceGeometryBuffer: boolean;
+    _enableSmoothReflections: boolean;
+    _reflectionSamples: number;
+    _smoothSteps: number;
+    _prePassEffectConfiguration: ScreenSpaceReflectionsConfiguration;
+    onApply: (effect: any) => void;
+    _isSceneRightHanded: any;
+    get _geometryBufferRenderer(): import("@babylonjs/core").Nullable<GeometryBufferRenderer>;
+    get _prePassRenderer(): import("@babylonjs/core").Nullable<import("@babylonjs/core").PrePassRenderer>;
+    /**
+     * Sets whether or not smoothing reflections is enabled.
+     * Enabling smoothing will require more GPU power and can generate a drop in FPS.
+     */
+    set enableSmoothReflections(arg: boolean);
+    /**
+     * Gets whether or not smoothing reflections is enabled.
+     * Enabling smoothing will require more GPU power and can generate a drop in FPS.
+     */
+    get enableSmoothReflections(): boolean;
+    /**
+     * Sets the number of samples taken while computing reflections. More samples count is high,
+     * more the post-process wil require GPU power and can generate a drop in FPS. Basically in interval [25, 100].
+     */
+    set reflectionSamples(arg: number);
+    /**
+     * Gets the number of samples taken while computing reflections. More samples count is high,
+     * more the post-process wil require GPU power and can generate a drop in FPS. Basically in interval [25, 100].
+     */
+    get reflectionSamples(): number;
+    set smoothSteps(arg: number);
+    /**
+     * Gets the number of samples taken while smoothing reflections. More samples count is high,
+     * more the post-process will require GPU power and can generate a drop in FPS.
+     * Default value (5.0) work pretty well in all cases but can be adjusted.
+     */
+    get smoothSteps(): number;
+    _updateEffectDefines(): void;
+}
+import { PostProcess } from "./postProcess.js";
+import { ScreenSpaceReflectionsConfiguration } from "../Rendering/screenSpaceReflectionsConfiguration.js";
+import { GeometryBufferRenderer } from "../Rendering/geometryBufferRenderer.js";

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

@@ -0,0 +1,32 @@
+/**
+ * The SharpenPostProcess applies a sharpen kernel to every pixel
+ * See http://en.wikipedia.org/wiki/Kernel_(image_processing)
+ */
+export class SharpenPostProcess extends PostProcess {
+    /**
+     * @internal
+     */
+    static _Parse(parsedPostProcess: any, targetCamera: any, scene: any, rootUrl: any): SharpenPostProcess;
+    /**
+     * Creates a new instance ConvolutionPostProcess
+     * @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)
+     * @param textureType Type of textures used when performing the post process. (default: 0)
+     * @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(name: any, options: any, camera: any, samplingMode: any, engine: any, reusable: any, textureType?: number, blockCompilation?: boolean);
+    /**
+     * How much of the original color should be applied. Setting this to 0 will display edge detection. (default: 1)
+     */
+    colorAmount: number;
+    /**
+     * How much sharpness should be applied (default: 0.3)
+     */
+    edgeAmount: number;
+    onApply: (effect: any) => void;
+}
+import { PostProcess } from "./postProcess.js";

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

@@ -0,0 +1,37 @@
+/**
+ * StereoscopicInterlacePostProcessI used to render stereo views from a rigged camera with support for alternate line interlacing
+ */
+export class StereoscopicInterlacePostProcessI extends PostProcess {
+    /**
+     * Initializes a StereoscopicInterlacePostProcessI
+     * @param name The name of the effect.
+     * @param rigCameras The rig cameras to be applied to the post process
+     * @param isStereoscopicHoriz If the rendered results are horizontal or vertical
+     * @param isStereoscopicInterlaced If the rendered results are alternate line interlaced
+     * @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, rigCameras: any, isStereoscopicHoriz: any, isStereoscopicInterlaced: any, samplingMode: any, engine: any, reusable: any);
+    _passedProcess: any;
+    _stepSize: Vector2;
+}
+/**
+ * StereoscopicInterlacePostProcess used to render stereo views from a rigged camera
+ */
+export class StereoscopicInterlacePostProcess extends PostProcess {
+    /**
+     * Initializes a StereoscopicInterlacePostProcess
+     * @param name The name of the effect.
+     * @param rigCameras The rig cameras to be applied to the post process
+     * @param isStereoscopicHoriz If the rendered results are horizontal or vertical
+     * @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, rigCameras: any, isStereoscopicHoriz: any, samplingMode: any, engine: any, reusable: any);
+    _passedProcess: any;
+    _stepSize: Vector2;
+}
+import { PostProcess } from "./postProcess.js";
+import { Vector2 } from "../Maths/math.vector.js";

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

@@ -0,0 +1,8 @@
+/**
+ * Sub surface scattering post process
+ */
+export class SubSurfaceScatteringPostProcess extends PostProcess {
+    constructor(name: any, scene: any, options: any, camera: null | undefined, samplingMode: any, engine: any, reusable: any, textureType?: number);
+    _scene: any;
+}
+import { PostProcess } from "./postProcess.js";

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

@@ -0,0 +1,23 @@
+/** Defines operator used for tonemapping */
+export const TonemappingOperator: any;
+/**
+ * Defines a post process to apply tone mapping
+ */
+export class TonemapPostProcess extends PostProcess {
+    /**
+     * Creates a new TonemapPostProcess
+     * @param name defines the name of the postprocess
+     * @param _operator defines the operator to use
+     * @param exposureAdjustment defines the required exposure adjustment
+     * @param camera defines the camera to use (can be null)
+     * @param samplingMode defines the required sampling mode (BABYLON.Texture.BILINEAR_SAMPLINGMODE by default)
+     * @param engine defines the hosting engine (can be ignore if camera is set)
+     * @param textureFormat defines the texture format to use (BABYLON.Engine.TEXTURETYPE_UNSIGNED_INT by default)
+     * @param reusable If the post process can be reused on the same frame. (default: false)
+     */
+    constructor(name: any, _operator: any, exposureAdjustment: any, camera: any, samplingMode: number | undefined, engine: any, textureFormat: number | undefined, reusable: any);
+    _operator: any;
+    exposureAdjustment: any;
+    onApply: (effect: any) => void;
+}
+import { PostProcess } from "./postProcess.js";