@babylonjs/core 5.35.0 → 5.36.0

package/Rendering/fluidRenderer/fluidRenderingObjectParticleSystem.js

@@ -0,0 +1,104 @@
+
+import { FluidRenderingObject } from "./fluidRenderingObject.js";
+/**
+ * Defines a rendering object based on a particle system
+ */
+export class FluidRenderingObjectParticleSystem extends FluidRenderingObject {
+    /**
+     * Creates a new instance of the class
+     * @param scene The scene the particle system is part of
+     * @param ps The particle system
+     */
+    constructor(scene, ps) {
+        super(scene);
+        this._useTrueRenderingForDiffuseTexture = true;
+        this._particleSystem = ps;
+        this._originalRender = ps.render.bind(ps);
+        this._blendMode = ps.blendMode;
+        this._onBeforeDrawParticleObserver = null;
+        this._updateInAnimate = this._particleSystem.updateInAnimate;
+        this._particleSystem.updateInAnimate = true;
+        this._particleSystem.render = () => 0;
+        this.particleSize = (ps.minSize + ps.maxSize) / 2;
+        this.useTrueRenderingForDiffuseTexture = false;
+    }
+    /** Gets the particle system */
+    get particleSystem() {
+        return this._particleSystem;
+    }
+    /**
+     * Gets the name of the class
+     */
+    getClassName() {
+        return "FluidRenderingObjectParticleSystem";
+    }
+    /**
+     * Gets or sets a boolean indicating that the diffuse texture should be generated based on the regular rendering of the particle system (default: true).
+     * Sometimes, generating the diffuse texture this way may be sub-optimal. In that case, you can disable this property, in which case the particle system will be
+     * rendered using a ALPHA_COMBINE mode instead of the one used by the particle system.
+     */
+    get useTrueRenderingForDiffuseTexture() {
+        return this._useTrueRenderingForDiffuseTexture;
+    }
+    set useTrueRenderingForDiffuseTexture(use) {
+        if (this._useTrueRenderingForDiffuseTexture === use) {
+            return;
+        }
+        this._useTrueRenderingForDiffuseTexture = use;
+        if (use) {
+            this._particleSystem.blendMode = this._blendMode;
+            this._particleSystem.onBeforeDrawParticlesObservable.remove(this._onBeforeDrawParticleObserver);
+            this._onBeforeDrawParticleObserver = null;
+        }
+        else {
+            this._particleSystem.blendMode = -1;
+            this._onBeforeDrawParticleObserver = this._particleSystem.onBeforeDrawParticlesObservable.add(() => {
+                this._engine.setAlphaMode(2);
+            });
+        }
+    }
+    /**
+     * Gets the vertex buffers
+     */
+    get vertexBuffers() {
+        return this._particleSystem.vertexBuffers;
+    }
+    /**
+     * Gets the index buffer (or null if the object is using instancing)
+     */
+    get indexBuffer() {
+        return this._particleSystem.indexBuffer;
+    }
+    /**
+     * Indicates if the object is ready to be rendered
+     * @returns True if everything is ready for the object to be rendered, otherwise false
+     */
+    isReady() {
+        return super.isReady() && this._particleSystem.isReady();
+    }
+    /**
+     * Gets the number of particles in this particle system
+     * @returns The number of particles
+     */
+    get numParticles() {
+        return this._particleSystem.getActiveCount();
+    }
+    /**
+     * Render the diffuse texture for this object
+     */
+    renderDiffuseTexture() {
+        this._originalRender();
+    }
+    /**
+     * Releases the ressources used by the class
+     */
+    dispose() {
+        super.dispose();
+        this._particleSystem.onBeforeDrawParticlesObservable.remove(this._onBeforeDrawParticleObserver);
+        this._onBeforeDrawParticleObserver = null;
+        this._particleSystem.render = this._originalRender;
+        this._particleSystem.blendMode = this._blendMode;
+        this._particleSystem.updateInAnimate = this._updateInAnimate;
+    }
+}
+//# sourceMappingURL=fluidRenderingObjectParticleSystem.js.map

package/Rendering/fluidRenderer/fluidRenderingObjectParticleSystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluidRenderingObjectParticleSystem.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Rendering/fluidRenderer/fluidRenderingObjectParticleSystem.ts"],"names":[],"mappings":"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","sourcesContent":["import type { VertexBuffer } from \"core/Buffers/buffer\";\r\nimport type { DataBuffer } from \"core/Buffers/dataBuffer\";\r\nimport { Constants } from \"core/Engines/constants\";\r\nimport type { Effect } from \"core/Materials/effect\";\r\nimport type { Observer } from \"core/Misc/observable\";\r\nimport type { IParticleSystem } from \"core/Particles/IParticleSystem\";\r\nimport type { Scene } from \"core/scene\";\r\nimport type { Nullable } from \"core/types\";\r\n\r\nimport { FluidRenderingObject } from \"./fluidRenderingObject\";\r\n\r\n/**\r\n * Defines a rendering object based on a particle system\r\n */\r\nexport class FluidRenderingObjectParticleSystem extends FluidRenderingObject {\r\n    private _particleSystem: IParticleSystem;\r\n    private _originalRender: () => number;\r\n    private _blendMode: number;\r\n    private _onBeforeDrawParticleObserver: Nullable<Observer<Nullable<Effect>>>;\r\n    private _updateInAnimate: boolean;\r\n\r\n    /** Gets the particle system */\r\n    public get particleSystem() {\r\n        return this._particleSystem;\r\n    }\r\n\r\n    /**\r\n     * Gets the name of the class\r\n     */\r\n    public getClassName(): string {\r\n        return \"FluidRenderingObjectParticleSystem\";\r\n    }\r\n\r\n    private _useTrueRenderingForDiffuseTexture = true;\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating that the diffuse texture should be generated based on the regular rendering of the particle system (default: true).\r\n     * Sometimes, generating the diffuse texture this way may be sub-optimal. In that case, you can disable this property, in which case the particle system will be\r\n     * rendered using a ALPHA_COMBINE mode instead of the one used by the particle system.\r\n     */\r\n    public get useTrueRenderingForDiffuseTexture() {\r\n        return this._useTrueRenderingForDiffuseTexture;\r\n    }\r\n\r\n    public set useTrueRenderingForDiffuseTexture(use: boolean) {\r\n        if (this._useTrueRenderingForDiffuseTexture === use) {\r\n            return;\r\n        }\r\n\r\n        this._useTrueRenderingForDiffuseTexture = use;\r\n\r\n        if (use) {\r\n            this._particleSystem.blendMode = this._blendMode;\r\n            this._particleSystem.onBeforeDrawParticlesObservable.remove(this._onBeforeDrawParticleObserver);\r\n            this._onBeforeDrawParticleObserver = null;\r\n        } else {\r\n            this._particleSystem.blendMode = -1;\r\n            this._onBeforeDrawParticleObserver = this._particleSystem.onBeforeDrawParticlesObservable.add(() => {\r\n                this._engine.setAlphaMode(Constants.ALPHA_COMBINE);\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets the vertex buffers\r\n     */\r\n    public get vertexBuffers(): { [key: string]: VertexBuffer } {\r\n        return this._particleSystem.vertexBuffers as { [key: string]: VertexBuffer };\r\n    }\r\n\r\n    /**\r\n     * Gets the index buffer (or null if the object is using instancing)\r\n     */\r\n    public get indexBuffer(): Nullable<DataBuffer> {\r\n        return this._particleSystem.indexBuffer;\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance of the class\r\n     * @param scene The scene the particle system is part of\r\n     * @param ps The particle system\r\n     */\r\n    constructor(scene: Scene, ps: IParticleSystem) {\r\n        super(scene);\r\n\r\n        this._particleSystem = ps;\r\n\r\n        this._originalRender = ps.render.bind(ps);\r\n        this._blendMode = ps.blendMode;\r\n        this._onBeforeDrawParticleObserver = null;\r\n        this._updateInAnimate = this._particleSystem.updateInAnimate;\r\n        this._particleSystem.updateInAnimate = true;\r\n        this._particleSystem.render = () => 0;\r\n\r\n        this.particleSize = (ps.minSize + ps.maxSize) / 2;\r\n\r\n        this.useTrueRenderingForDiffuseTexture = false;\r\n    }\r\n\r\n    /**\r\n     * Indicates if the object is ready to be rendered\r\n     * @returns True if everything is ready for the object to be rendered, otherwise false\r\n     */\r\n    public isReady(): boolean {\r\n        return super.isReady() && this._particleSystem.isReady();\r\n    }\r\n\r\n    /**\r\n     * Gets the number of particles in this particle system\r\n     * @returns The number of particles\r\n     */\r\n    public get numParticles(): number {\r\n        return this._particleSystem.getActiveCount();\r\n    }\r\n\r\n    /**\r\n     * Render the diffuse texture for this object\r\n     */\r\n    public renderDiffuseTexture(): void {\r\n        this._originalRender();\r\n    }\r\n\r\n    /**\r\n     * Releases the ressources used by the class\r\n     */\r\n    public dispose() {\r\n        super.dispose();\r\n\r\n        this._particleSystem.onBeforeDrawParticlesObservable.remove(this._onBeforeDrawParticleObserver);\r\n        this._onBeforeDrawParticleObserver = null;\r\n        this._particleSystem.render = this._originalRender;\r\n        this._particleSystem.blendMode = this._blendMode;\r\n        this._particleSystem.updateInAnimate = this._updateInAnimate;\r\n    }\r\n}\r\n"]}

package/Rendering/fluidRenderer/fluidRenderingTargetRenderer.d.ts

@@ -0,0 +1,234 @@
+import type { Camera } from "../../Cameras/camera.js";
+import type { Engine } from "../../Engines/engine.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";
+import { FluidRenderingTextures } from "./fluidRenderingTextures";
+/**
+ * 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: Engine;
+    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);
+    /**
+     * 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>;
+    /**
+     * 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
+     */
+    constructor(scene: Scene, camera?: Camera);
+    /** @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;
+}