@babylonjs/core
Version:
Getting started? Play directly with the Babylon.js API using our [playground](https://playground.babylonjs.com/). It also contains a lot of samples to learn how to use it.
250 lines (249 loc) • 11 kB
TypeScript
import type { Camera } from "../../Cameras/camera.js";
import type { AbstractEngine } from "../../Engines/abstractEngine.js";
import type { BaseTexture } from "../../Materials/Textures/baseTexture.js";
import type { InternalTexture } from "../../Materials/Textures/internalTexture.js";
import { Color3, Color4 } from "../../Maths/math.color.js";
import { Matrix, Vector3 } from "../../Maths/math.vector.js";
import { Observable } from "../../Misc/observable.js";
import { PostProcess } from "../../PostProcesses/postProcess.js";
import type { Scene } from "../../scene.js";
import type { Nullable } from "../../types.js";
import type { FluidRenderingObject } from "./fluidRenderingObject.js";
import { FluidRenderingTextures } from "./fluidRenderingTextures.js";
import { ShaderLanguage } from "../../Materials/shaderLanguage.js";
/**
* Textures that can be displayed as a debugging tool
*/
export declare enum FluidRenderingDebug {
DepthTexture = 0,
DepthBlurredTexture = 1,
ThicknessTexture = 2,
ThicknessBlurredTexture = 3,
DiffuseTexture = 4,
Normals = 5,
DiffuseRendering = 6
}
/**
* Class used to render an object as a fluid thanks to different render target textures (depth, thickness, diffuse)
*/
export declare class FluidRenderingTargetRenderer {
protected _scene: Scene;
protected _camera: Nullable<Camera>;
protected _engine: AbstractEngine;
protected _invProjectionMatrix: Matrix;
protected _depthClearColor: Color4;
protected _thicknessClearColor: Color4;
protected _needInitialization: boolean;
/**
* Returns true if the class needs to be reinitialized (because of changes in parameterization)
*/
get needInitialization(): boolean;
private _generateDiffuseTexture;
/**
* Gets or sets a boolean indicating that the diffuse texture should be generated and used for the rendering
*/
get generateDiffuseTexture(): boolean;
set generateDiffuseTexture(generate: boolean);
/**
* Fluid color. Not used if generateDiffuseTexture is true
*/
fluidColor: Color3;
/**
* Density of the fluid (positive number). The higher the value, the more opaque the fluid.
*/
density: number;
/**
* Strength of the refraction (positive number, but generally between 0 and 0.3).
*/
refractionStrength: number;
/**
* Strength of the fresnel effect (value between 0 and 1). Lower the value if you want to soften the specular effect
*/
fresnelClamp: number;
/**
* Strength of the specular power (positive number). Increase the value to make the specular effect more concentrated
*/
specularPower: number;
/**
* Minimum thickness of the particles (positive number). If useFixedThickness is true, minimumThickness is the thickness used
*/
minimumThickness: number;
/**
* Direction of the light. The fluid is assumed to be lit by a directional light
*/
dirLight: Vector3;
private _debugFeature;
/**
* Gets or sets the feature (texture) to be debugged. Not used if debug is false
*/
get debugFeature(): FluidRenderingDebug;
set debugFeature(feature: FluidRenderingDebug);
private _debug;
/**
* Gets or sets a boolean indicating if we should display a specific texture (given by debugFeature) for debugging purpose
*/
get debug(): boolean;
set debug(debug: boolean);
private _environmentMap?;
/**
* Gets or sets the environment map used for the reflection part of the shading
* If null, no map will be used. If undefined, the scene.environmentMap will be used (if defined)
*/
get environmentMap(): Nullable<BaseTexture> | undefined;
set environmentMap(map: Nullable<BaseTexture> | undefined);
private _enableBlurDepth;
/**
* Gets or sets a boolean indicating that the depth texture should be blurred
*/
get enableBlurDepth(): boolean;
set enableBlurDepth(enable: boolean);
private _blurDepthSizeDivisor;
/**
* Gets or sets the depth size divisor (positive number, generally between 1 and 4), which is used as a divisor when creating the texture used for blurring the depth
* For eg. if blurDepthSizeDivisor=2, the texture used to blur the depth will be half the size of the depth texture
*/
get blurDepthSizeDivisor(): number;
set blurDepthSizeDivisor(scale: number);
private _blurDepthFilterSize;
/**
* Size of the kernel used to filter the depth blur texture (positive number, generally between 1 and 20 - higher values will require more processing power from the GPU)
*/
get blurDepthFilterSize(): number;
set blurDepthFilterSize(filterSize: number);
private _blurDepthNumIterations;
/**
* Number of blurring iterations used to generate the depth blur texture (positive number, generally between 1 and 10 - higher values will require more processing power from the GPU)
*/
get blurDepthNumIterations(): number;
set blurDepthNumIterations(numIterations: number);
private _blurDepthMaxFilterSize;
/**
* Maximum size of the kernel used to blur the depth texture (positive number, generally between 1 and 200 - higher values will require more processing power from the GPU when the particles are larger on screen)
*/
get blurDepthMaxFilterSize(): number;
set blurDepthMaxFilterSize(maxFilterSize: number);
private _blurDepthDepthScale;
/**
* Depth weight in the calculation when applying the bilateral blur to generate the depth blur texture (positive number, generally between 0 and 100)
*/
get blurDepthDepthScale(): number;
set blurDepthDepthScale(scale: number);
private _enableBlurThickness;
/**
* Gets or sets a boolean indicating that the thickness texture should be blurred
*/
get enableBlurThickness(): boolean;
set enableBlurThickness(enable: boolean);
private _blurThicknessSizeDivisor;
/**
* Gets or sets the thickness size divisor (positive number, generally between 1 and 4), which is used as a divisor when creating the texture used for blurring the thickness
* For eg. if blurThicknessSizeDivisor=2, the texture used to blur the thickness will be half the size of the thickness texture
*/
get blurThicknessSizeDivisor(): number;
set blurThicknessSizeDivisor(scale: number);
private _blurThicknessFilterSize;
/**
* Size of the kernel used to filter the thickness blur texture (positive number, generally between 1 and 20 - higher values will require more processing power from the GPU)
*/
get blurThicknessFilterSize(): number;
set blurThicknessFilterSize(filterSize: number);
private _blurThicknessNumIterations;
/**
* Number of blurring iterations used to generate the thickness blur texture (positive number, generally between 1 and 10 - higher values will require more processing power from the GPU)
*/
get blurThicknessNumIterations(): number;
set blurThicknessNumIterations(numIterations: number);
private _useFixedThickness;
/**
* Gets or sets a boolean indicating that a fixed thickness should be used instead of generating a thickness texture
*/
get useFixedThickness(): boolean;
set useFixedThickness(use: boolean);
/** @internal */
_bgDepthTexture: Nullable<InternalTexture>;
/** @internal */
_onUseVelocityChanged: Observable<FluidRenderingTargetRenderer>;
private _useVelocity;
/**
* Gets or sets a boolean indicating that the velocity should be used when rendering the particles as a fluid.
* Note: the vertex buffers must contain a "velocity" buffer for this to work!
*/
get useVelocity(): boolean;
set useVelocity(use: boolean);
private _depthMapSize;
/**
* Defines the size of the depth texture.
* If null, the texture will have the size of the screen
*/
get depthMapSize(): Nullable<number>;
set depthMapSize(size: Nullable<number>);
private _thicknessMapSize;
/**
* Defines the size of the thickness texture.
* If null, the texture will have the size of the screen
*/
get thicknessMapSize(): Nullable<number>;
set thicknessMapSize(size: Nullable<number>);
private _diffuseMapSize;
/**
* Defines the size of the diffuse texture.
* If null, the texture will have the size of the screen
*/
get diffuseMapSize(): Nullable<number>;
set diffuseMapSize(size: Nullable<number>);
private _samples;
/**
* Gets or sets the number of samples used by MSAA
* Note: changing this value in WebGL does not work because depth/stencil textures can't be created with MSAA (see https://github.com/BabylonJS/Babylon.js/issues/12444)
*/
get samples(): number;
set samples(samples: number);
private _compositeMode;
/**
* If compositeMode is true (default: false), when the alpha value of the background (the scene rendered without the fluid objects) is 0, the final alpha value of the pixel will be set to the thickness value.
* This way, it is possible to composite the fluid rendering on top of the HTML background.
*/
get compositeMode(): boolean;
set compositeMode(value: boolean);
/**
* Gets the camera used for the rendering
*/
get camera(): Nullable<Camera>;
/** @internal */
_renderPostProcess: Nullable<PostProcess>;
/** @internal */
_depthRenderTarget: Nullable<FluidRenderingTextures>;
/** @internal */
_diffuseRenderTarget: Nullable<FluidRenderingTextures>;
/** @internal */
_thicknessRenderTarget: Nullable<FluidRenderingTextures>;
/** Shader language used by the renderer */
protected _shaderLanguage: ShaderLanguage;
/**
* Gets the shader language used in this renderer
*/
get shaderLanguage(): ShaderLanguage;
/**
* Creates an instance of the class
* @param scene Scene used to render the fluid object into
* @param camera Camera used to render the fluid object. If not provided, use the active camera of the scene instead
* @param shaderLanguage The shader language to use
*/
constructor(scene: Scene, camera?: Camera, shaderLanguage?: ShaderLanguage);
/** @internal */
_initialize(): void;
protected _setBlurParameters(renderTarget?: Nullable<FluidRenderingTextures>): void;
protected _setBlurDepthParameters(): void;
protected _setBlurThicknessParameters(): void;
protected _initializeRenderTarget(renderTarget: FluidRenderingTextures): void;
protected _createLiquidRenderingPostProcess(): void;
/** @internal */
_clearTargets(): void;
/** @internal */
_render(fluidObject: FluidRenderingObject): void;
/**
* Releases all the ressources used by the class
* @param onlyPostProcesses If true, releases only the ressources used by the render post processes
*/
dispose(onlyPostProcesses?: boolean): void;
}