@babylonjs/materials 9.15.0 → 9.16.1

package/water/waterMaterial.js

@@ -1,4 +1,4 @@
-import { __decorate } from "@babylonjs/core/tslib.es6.js";
+import { __classPrivateFieldGet, __classPrivateFieldSet, __esDecorate, __runInitializers } from "@babylonjs/core/tslib.es6.js";
 import { serializeAsVector2, serializeAsTexture, serialize, expandToProperty, serializeAsColor3 } from "@babylonjs/core/Misc/decorators.js";
 import { SerializationHelper } from "@babylonjs/core/Misc/decorators.serialization.js";
 import { Matrix, TmpVectors, Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
@@ -70,691 +70,791 @@ class WaterMaterialDefines extends MaterialDefines {
         this.rebuild();
     }
 }
-export class WaterMaterial extends PushMaterial {
-    /**
-     * Gets a boolean indicating that current material needs to register RTT
-     */
-    get hasRenderTargetTextures() {
-        return true;
-    }
-    /**
-     * Constructor
-     * @param name
-     * @param scene
-     * @param renderTargetSize
-     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
-     */
-    constructor(name, scene, renderTargetSize = new Vector2(512, 512), forceGLSL = false) {
-        super(name, scene, undefined, forceGLSL);
-        this.renderTargetSize = renderTargetSize;
-        this.diffuseColor = new Color3(1, 1, 1);
-        this.specularColor = new Color3(0, 0, 0);
-        this.specularPower = 64;
-        this._disableLighting = false;
-        this._maxSimultaneousLights = 4;
-        /**
-         * Defines the wind force.
-         */
-        this.windForce = 6;
-        /**
-         * Defines the direction of the wind in the plane (X, Z).
-         */
-        this.windDirection = new Vector2(0, 1);
-        /**
-         * Defines the height of the waves.
-         */
-        this.waveHeight = 0.4;
-        /**
-         * Defines the bump height related to the bump map.
-         */
-        this.bumpHeight = 0.4;
-        /**
-         * Defines wether or not: to add a smaller moving bump to less steady waves.
-         */
-        this._bumpSuperimpose = false;
-        /**
-         * Defines wether or not color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
-         */
-        this._fresnelSeparate = false;
-        /**
-         * Defines wether or not bump Wwves modify the reflection.
-         */
-        this._bumpAffectsReflection = false;
-        /**
-         * Defines the water color blended with the refraction (near).
-         */
-        this.waterColor = new Color3(0.1, 0.1, 0.6);
-        /**
-         * Defines the blend factor related to the water color.
-         */
-        this.colorBlendFactor = 0.2;
-        /**
-         * Defines the water color blended with the reflection (far).
-         */
-        this.waterColor2 = new Color3(0.1, 0.1, 0.6);
-        /**
-         * Defines the blend factor related to the water color (reflection, far).
-         */
-        this.colorBlendFactor2 = 0.2;
-        /**
-         * Defines the maximum length of a wave.
-         */
-        this.waveLength = 0.1;
-        /**
-         * Defines the waves speed.
-         */
-        this.waveSpeed = 1.0;
-        /**
-         * Defines the number of times waves are repeated. This is typically used to adjust waves count according to the ground's size where the material is applied on.
-         */
-        this.waveCount = 20;
-        /**
-         * Sets or gets whether or not automatic clipping should be enabled or not. Setting to true will save performances and
-         * will avoid calculating useless pixels in the pixel shader of the water material.
-         */
-        this.disableClipPlane = false;
-        /**
-         * Defines whether or not to use world coordinates for wave deformations.
-         * The default value is false, meaning that the deformation is applied in object (local) space.
-         * You will probably need to set it to true if you are using instances or thin instances for your water objects.
-         */
-        this._useWorldCoordinatesForWaveDeformation = false;
-        this._renderTargets = new SmartArray(16);
-        /*
-         * Private members
-         */
-        this._mesh = null;
-        this._reflectionTransform = Matrix.Zero();
-        this._offsetMirror = Matrix.Zero();
-        this._tempPlane = new Plane(0, 0, 0, 0);
-        this._lastTime = 0;
-        this._shadersLoaded = false;
-        this._lastDeltaTime = 0;
-        this._createRenderTargets(this.getScene(), renderTargetSize);
-        // Create render targets
-        this.getRenderTargetTextures = () => {
-            this._renderTargets.reset();
-            this._renderTargets.push(this._reflectionRTT);
-            this._renderTargets.push(this._refractionRTT);
-            return this._renderTargets;
-        };
-        this._imageProcessingConfiguration = this.getScene().imageProcessingConfiguration;
-        if (this._imageProcessingConfiguration) {
-            this._imageProcessingObserver = this._imageProcessingConfiguration.onUpdateParameters.add(() => {
-                this._markAllSubMeshesAsImageProcessingDirty();
-            });
-        }
-    }
-    // Get / Set
-    get refractionTexture() {
-        return this._refractionRTT;
-    }
-    get reflectionTexture() {
-        return this._reflectionRTT;
-    }
-    // Methods
-    addToRenderList(node) {
-        if (this._refractionRTT && this._refractionRTT.renderList) {
-            this._refractionRTT.renderList.push(node);
-        }
-        if (this._reflectionRTT && this._reflectionRTT.renderList) {
-            this._reflectionRTT.renderList.push(node);
-        }
-    }
-    removeFromRenderList(node) {
-        if (this._refractionRTT && this._refractionRTT.renderList) {
-            const idx = this._refractionRTT.renderList.indexOf(node);
-            if (idx !== -1) {
-                this._refractionRTT.renderList.splice(idx, 1);
-            }
-        }
-        if (this._reflectionRTT && this._reflectionRTT.renderList) {
-            const idx = this._reflectionRTT.renderList.indexOf(node);
-            if (idx !== -1) {
-                this._reflectionRTT.renderList.splice(idx, 1);
-            }
-        }
-    }
-    enableRenderTargets(enable) {
-        const refreshRate = enable ? 1 : 0;
-        if (this._refractionRTT) {
-            this._refractionRTT.refreshRate = refreshRate;
-        }
-        if (this._reflectionRTT) {
-            this._reflectionRTT.refreshRate = refreshRate;
-        }
-    }
-    getRenderList() {
-        return this._refractionRTT ? this._refractionRTT.renderList : [];
-    }
-    get renderTargetsEnabled() {
-        return !(this._refractionRTT && this._refractionRTT.refreshRate === 0);
-    }
-    needAlphaBlending() {
-        return this.alpha < 1.0;
-    }
-    needAlphaTesting() {
-        return false;
-    }
-    getAlphaTestTexture() {
-        return null;
-    }
-    isReadyForSubMesh(mesh, subMesh, useInstances) {
-        const drawWrapper = subMesh._drawWrapper;
-        if (this.isFrozen) {
-            if (drawWrapper.effect && drawWrapper._wasPreviouslyReady && drawWrapper._wasPreviouslyUsingInstances === useInstances) {
+let WaterMaterial = (() => {
+    var _a, _WaterMaterial_bumpTexture_accessor_storage, _WaterMaterial_disableLighting_accessor_storage, _WaterMaterial_maxSimultaneousLights_accessor_storage, _WaterMaterial_bumpSuperimpose_accessor_storage, _WaterMaterial_fresnelSeparate_accessor_storage, _WaterMaterial_bumpAffectsReflection_accessor_storage, _WaterMaterial_useWorldCoordinatesForWaveDeformation_accessor_storage;
+    let _classSuper = PushMaterial;
+    let __bumpTexture_decorators;
+    let __bumpTexture_initializers = [];
+    let __bumpTexture_extraInitializers = [];
+    let _bumpTexture_decorators;
+    let _bumpTexture_initializers = [];
+    let _bumpTexture_extraInitializers = [];
+    let _diffuseColor_decorators;
+    let _diffuseColor_initializers = [];
+    let _diffuseColor_extraInitializers = [];
+    let _specularColor_decorators;
+    let _specularColor_initializers = [];
+    let _specularColor_extraInitializers = [];
+    let _specularPower_decorators;
+    let _specularPower_initializers = [];
+    let _specularPower_extraInitializers = [];
+    let __disableLighting_decorators;
+    let __disableLighting_initializers = [];
+    let __disableLighting_extraInitializers = [];
+    let _disableLighting_decorators;
+    let _disableLighting_initializers = [];
+    let _disableLighting_extraInitializers = [];
+    let __maxSimultaneousLights_decorators;
+    let __maxSimultaneousLights_initializers = [];
+    let __maxSimultaneousLights_extraInitializers = [];
+    let _maxSimultaneousLights_decorators;
+    let _maxSimultaneousLights_initializers = [];
+    let _maxSimultaneousLights_extraInitializers = [];
+    let _windForce_decorators;
+    let _windForce_initializers = [];
+    let _windForce_extraInitializers = [];
+    let _windDirection_decorators;
+    let _windDirection_initializers = [];
+    let _windDirection_extraInitializers = [];
+    let _waveHeight_decorators;
+    let _waveHeight_initializers = [];
+    let _waveHeight_extraInitializers = [];
+    let _bumpHeight_decorators;
+    let _bumpHeight_initializers = [];
+    let _bumpHeight_extraInitializers = [];
+    let __bumpSuperimpose_decorators;
+    let __bumpSuperimpose_initializers = [];
+    let __bumpSuperimpose_extraInitializers = [];
+    let _bumpSuperimpose_decorators;
+    let _bumpSuperimpose_initializers = [];
+    let _bumpSuperimpose_extraInitializers = [];
+    let __fresnelSeparate_decorators;
+    let __fresnelSeparate_initializers = [];
+    let __fresnelSeparate_extraInitializers = [];
+    let _fresnelSeparate_decorators;
+    let _fresnelSeparate_initializers = [];
+    let _fresnelSeparate_extraInitializers = [];
+    let __bumpAffectsReflection_decorators;
+    let __bumpAffectsReflection_initializers = [];
+    let __bumpAffectsReflection_extraInitializers = [];
+    let _bumpAffectsReflection_decorators;
+    let _bumpAffectsReflection_initializers = [];
+    let _bumpAffectsReflection_extraInitializers = [];
+    let _waterColor_decorators;
+    let _waterColor_initializers = [];
+    let _waterColor_extraInitializers = [];
+    let _colorBlendFactor_decorators;
+    let _colorBlendFactor_initializers = [];
+    let _colorBlendFactor_extraInitializers = [];
+    let _waterColor2_decorators;
+    let _waterColor2_initializers = [];
+    let _waterColor2_extraInitializers = [];
+    let _colorBlendFactor2_decorators;
+    let _colorBlendFactor2_initializers = [];
+    let _colorBlendFactor2_extraInitializers = [];
+    let _waveLength_decorators;
+    let _waveLength_initializers = [];
+    let _waveLength_extraInitializers = [];
+    let _waveSpeed_decorators;
+    let _waveSpeed_initializers = [];
+    let _waveSpeed_extraInitializers = [];
+    let _waveCount_decorators;
+    let _waveCount_initializers = [];
+    let _waveCount_extraInitializers = [];
+    let _disableClipPlane_decorators;
+    let _disableClipPlane_initializers = [];
+    let _disableClipPlane_extraInitializers = [];
+    let __useWorldCoordinatesForWaveDeformation_decorators;
+    let __useWorldCoordinatesForWaveDeformation_initializers = [];
+    let __useWorldCoordinatesForWaveDeformation_extraInitializers = [];
+    let _useWorldCoordinatesForWaveDeformation_decorators;
+    let _useWorldCoordinatesForWaveDeformation_initializers = [];
+    let _useWorldCoordinatesForWaveDeformation_extraInitializers = [];
+    return _a = class WaterMaterial extends _classSuper {
+            get bumpTexture() { return __classPrivateFieldGet(this, _WaterMaterial_bumpTexture_accessor_storage, "f"); }
+            set bumpTexture(value) { __classPrivateFieldSet(this, _WaterMaterial_bumpTexture_accessor_storage, value, "f"); }
+            get disableLighting() { return __classPrivateFieldGet(this, _WaterMaterial_disableLighting_accessor_storage, "f"); }
+            set disableLighting(value) { __classPrivateFieldSet(this, _WaterMaterial_disableLighting_accessor_storage, value, "f"); }
+            get maxSimultaneousLights() { return __classPrivateFieldGet(this, _WaterMaterial_maxSimultaneousLights_accessor_storage, "f"); }
+            set maxSimultaneousLights(value) { __classPrivateFieldSet(this, _WaterMaterial_maxSimultaneousLights_accessor_storage, value, "f"); }
+            get bumpSuperimpose() { return __classPrivateFieldGet(this, _WaterMaterial_bumpSuperimpose_accessor_storage, "f"); }
+            set bumpSuperimpose(value) { __classPrivateFieldSet(this, _WaterMaterial_bumpSuperimpose_accessor_storage, value, "f"); }
+            get fresnelSeparate() { return __classPrivateFieldGet(this, _WaterMaterial_fresnelSeparate_accessor_storage, "f"); }
+            set fresnelSeparate(value) { __classPrivateFieldSet(this, _WaterMaterial_fresnelSeparate_accessor_storage, value, "f"); }
+            get bumpAffectsReflection() { return __classPrivateFieldGet(this, _WaterMaterial_bumpAffectsReflection_accessor_storage, "f"); }
+            set bumpAffectsReflection(value) { __classPrivateFieldSet(this, _WaterMaterial_bumpAffectsReflection_accessor_storage, value, "f"); }
+            get useWorldCoordinatesForWaveDeformation() { return __classPrivateFieldGet(this, _WaterMaterial_useWorldCoordinatesForWaveDeformation_accessor_storage, "f"); }
+            set useWorldCoordinatesForWaveDeformation(value) { __classPrivateFieldSet(this, _WaterMaterial_useWorldCoordinatesForWaveDeformation_accessor_storage, value, "f"); }
+            /**
+             * Gets a boolean indicating that current material needs to register RTT
+             */
+            get hasRenderTargetTextures() {
                 return true;
             }
-        }
-        if (!subMesh.materialDefines) {
-            subMesh.materialDefines = new WaterMaterialDefines();
-        }
-        const defines = subMesh.materialDefines;
-        const scene = this.getScene();
-        if (this._isReadyForSubMesh(subMesh)) {
-            return true;
-        }
-        const engine = scene.getEngine();
-        // Textures
-        if (defines._areTexturesDirty) {
-            defines._needUVs = false;
-            if (scene.texturesEnabled) {
-                if (this.bumpTexture && MaterialFlags.BumpTextureEnabled) {
-                    if (!this.bumpTexture.isReady()) {
-                        return false;
-                    }
-                    else {
-                        defines._needUVs = true;
-                        defines.BUMP = true;
-                    }
-                }
-                if (MaterialFlags.ReflectionTextureEnabled) {
-                    defines.REFLECTION = true;
+            /**
+             * Constructor
+             * @param name
+             * @param scene
+             * @param renderTargetSize
+             * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+             */
+            constructor(name, scene, renderTargetSize = new Vector2(512, 512), forceGLSL = false) {
+                super(name, scene, undefined, forceGLSL);
+                this.renderTargetSize = renderTargetSize;
+                /*
+                 * Public members
+                 */
+                this._bumpTexture = __runInitializers(this, __bumpTexture_initializers, void 0);
+                _WaterMaterial_bumpTexture_accessor_storage.set(this, (__runInitializers(this, __bumpTexture_extraInitializers), __runInitializers(this, _bumpTexture_initializers, void 0)));
+                this.diffuseColor = (__runInitializers(this, _bumpTexture_extraInitializers), __runInitializers(this, _diffuseColor_initializers, new Color3(1, 1, 1)));
+                this.specularColor = (__runInitializers(this, _diffuseColor_extraInitializers), __runInitializers(this, _specularColor_initializers, new Color3(0, 0, 0)));
+                this.specularPower = (__runInitializers(this, _specularColor_extraInitializers), __runInitializers(this, _specularPower_initializers, 64));
+                this._disableLighting = (__runInitializers(this, _specularPower_extraInitializers), __runInitializers(this, __disableLighting_initializers, false));
+                _WaterMaterial_disableLighting_accessor_storage.set(this, (__runInitializers(this, __disableLighting_extraInitializers), __runInitializers(this, _disableLighting_initializers, void 0)));
+                this._maxSimultaneousLights = (__runInitializers(this, _disableLighting_extraInitializers), __runInitializers(this, __maxSimultaneousLights_initializers, 4));
+                _WaterMaterial_maxSimultaneousLights_accessor_storage.set(this, (__runInitializers(this, __maxSimultaneousLights_extraInitializers), __runInitializers(this, _maxSimultaneousLights_initializers, void 0)));
+                /**
+                 * Defines the wind force.
+                 */
+                this.windForce = (__runInitializers(this, _maxSimultaneousLights_extraInitializers), __runInitializers(this, _windForce_initializers, 6));
+                /**
+                 * Defines the direction of the wind in the plane (X, Z).
+                 */
+                this.windDirection = (__runInitializers(this, _windForce_extraInitializers), __runInitializers(this, _windDirection_initializers, new Vector2(0, 1)));
+                /**
+                 * Defines the height of the waves.
+                 */
+                this.waveHeight = (__runInitializers(this, _windDirection_extraInitializers), __runInitializers(this, _waveHeight_initializers, 0.4));
+                /**
+                 * Defines the bump height related to the bump map.
+                 */
+                this.bumpHeight = (__runInitializers(this, _waveHeight_extraInitializers), __runInitializers(this, _bumpHeight_initializers, 0.4));
+                /**
+                 * Defines wether or not: to add a smaller moving bump to less steady waves.
+                 */
+                this._bumpSuperimpose = (__runInitializers(this, _bumpHeight_extraInitializers), __runInitializers(this, __bumpSuperimpose_initializers, false));
+                _WaterMaterial_bumpSuperimpose_accessor_storage.set(this, (__runInitializers(this, __bumpSuperimpose_extraInitializers), __runInitializers(this, _bumpSuperimpose_initializers, void 0)));
+                /**
+                 * Defines wether or not color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
+                 */
+                this._fresnelSeparate = (__runInitializers(this, _bumpSuperimpose_extraInitializers), __runInitializers(this, __fresnelSeparate_initializers, false));
+                _WaterMaterial_fresnelSeparate_accessor_storage.set(this, (__runInitializers(this, __fresnelSeparate_extraInitializers), __runInitializers(this, _fresnelSeparate_initializers, void 0)));
+                /**
+                 * Defines wether or not bump Wwves modify the reflection.
+                 */
+                this._bumpAffectsReflection = (__runInitializers(this, _fresnelSeparate_extraInitializers), __runInitializers(this, __bumpAffectsReflection_initializers, false));
+                _WaterMaterial_bumpAffectsReflection_accessor_storage.set(this, (__runInitializers(this, __bumpAffectsReflection_extraInitializers), __runInitializers(this, _bumpAffectsReflection_initializers, void 0)));
+                /**
+                 * Defines the water color blended with the refraction (near).
+                 */
+                this.waterColor = (__runInitializers(this, _bumpAffectsReflection_extraInitializers), __runInitializers(this, _waterColor_initializers, new Color3(0.1, 0.1, 0.6)));
+                /**
+                 * Defines the blend factor related to the water color.
+                 */
+                this.colorBlendFactor = (__runInitializers(this, _waterColor_extraInitializers), __runInitializers(this, _colorBlendFactor_initializers, 0.2));
+                /**
+                 * Defines the water color blended with the reflection (far).
+                 */
+                this.waterColor2 = (__runInitializers(this, _colorBlendFactor_extraInitializers), __runInitializers(this, _waterColor2_initializers, new Color3(0.1, 0.1, 0.6)));
+                /**
+                 * Defines the blend factor related to the water color (reflection, far).
+                 */
+                this.colorBlendFactor2 = (__runInitializers(this, _waterColor2_extraInitializers), __runInitializers(this, _colorBlendFactor2_initializers, 0.2));
+                /**
+                 * Defines the maximum length of a wave.
+                 */
+                this.waveLength = (__runInitializers(this, _colorBlendFactor2_extraInitializers), __runInitializers(this, _waveLength_initializers, 0.1));
+                /**
+                 * Defines the waves speed.
+                 */
+                this.waveSpeed = (__runInitializers(this, _waveLength_extraInitializers), __runInitializers(this, _waveSpeed_initializers, 1.0));
+                /**
+                 * Defines the number of times waves are repeated. This is typically used to adjust waves count according to the ground's size where the material is applied on.
+                 */
+                this.waveCount = (__runInitializers(this, _waveSpeed_extraInitializers), __runInitializers(this, _waveCount_initializers, 20));
+                /**
+                 * Sets or gets whether or not automatic clipping should be enabled or not. Setting to true will save performances and
+                 * will avoid calculating useless pixels in the pixel shader of the water material.
+                 */
+                this.disableClipPlane = (__runInitializers(this, _waveCount_extraInitializers), __runInitializers(this, _disableClipPlane_initializers, false));
+                /**
+                 * Defines whether or not to use world coordinates for wave deformations.
+                 * The default value is false, meaning that the deformation is applied in object (local) space.
+                 * You will probably need to set it to true if you are using instances or thin instances for your water objects.
+                 */
+                this._useWorldCoordinatesForWaveDeformation = (__runInitializers(this, _disableClipPlane_extraInitializers), __runInitializers(this, __useWorldCoordinatesForWaveDeformation_initializers, false));
+                _WaterMaterial_useWorldCoordinatesForWaveDeformation_accessor_storage.set(this, (__runInitializers(this, __useWorldCoordinatesForWaveDeformation_extraInitializers), __runInitializers(this, _useWorldCoordinatesForWaveDeformation_initializers, void 0)));
+                this._renderTargets = (__runInitializers(this, _useWorldCoordinatesForWaveDeformation_extraInitializers), new SmartArray(16));
+                /*
+                 * Private members
+                 */
+                this._mesh = null;
+                this._reflectionTransform = Matrix.Zero();
+                this._offsetMirror = Matrix.Zero();
+                this._tempPlane = new Plane(0, 0, 0, 0);
+                this._lastTime = 0;
+                this._shadersLoaded = false;
+                this._lastDeltaTime = 0;
+                this._createRenderTargets(this.getScene(), renderTargetSize);
+                // Create render targets
+                this.getRenderTargetTextures = () => {
+                    this._renderTargets.reset();
+                    this._renderTargets.push(this._reflectionRTT);
+                    this._renderTargets.push(this._refractionRTT);
+                    return this._renderTargets;
+                };
+                this._imageProcessingConfiguration = this.getScene().imageProcessingConfiguration;
+                if (this._imageProcessingConfiguration) {
+                    this._imageProcessingObserver = this._imageProcessingConfiguration.onUpdateParameters.add(() => {
+                        this._markAllSubMeshesAsImageProcessingDirty();
+                    });
                 }
             }
-        }
-        PrepareDefinesForFrameBoundValues(scene, engine, this, defines, useInstances ? true : false);
-        PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, this.needAlphaTestingForMesh(mesh), defines, undefined, undefined, undefined, this._isVertexOutputInvariant);
-        if (defines._areMiscDirty) {
-            defines.FRESNELSEPARATE = this._fresnelSeparate;
-            defines.BUMPSUPERIMPOSE = this._bumpSuperimpose;
-            defines.BUMPAFFECTSREFLECTION = this._bumpAffectsReflection;
-            defines.USE_WORLD_COORDINATES = this._useWorldCoordinatesForWaveDeformation;
-        }
-        // Lights
-        defines._needNormals = PrepareDefinesForLights(scene, mesh, defines, true, this._maxSimultaneousLights, this._disableLighting);
-        // Image processing
-        if (defines._areImageProcessingDirty && this._imageProcessingConfiguration) {
-            if (!this._imageProcessingConfiguration.isReady()) {
-                return false;
+            // Get / Set
+            get refractionTexture() {
+                return this._refractionRTT;
             }
-            this._imageProcessingConfiguration.prepareDefines(defines);
-            defines.IS_REFLECTION_LINEAR = this.reflectionTexture != null && !this.reflectionTexture.gammaSpace;
-            defines.IS_REFRACTION_LINEAR = this.refractionTexture != null && !this.refractionTexture.gammaSpace;
-        }
-        // Attribs
-        PrepareDefinesForAttributes(mesh, defines, true, true);
-        // Configure this
-        this._mesh = mesh;
-        if (this._waitingRenderList) {
-            for (let i = 0; i < this._waitingRenderList.length; i++) {
-                this.addToRenderList(scene.getNodeById(this._waitingRenderList[i]));
+            get reflectionTexture() {
+                return this._reflectionRTT;
             }
-            this._waitingRenderList = null;
-        }
-        // Get correct effect
-        if (defines.isDirty) {
-            defines.markAsProcessed();
-            scene.resetCachedMaterial();
-            // Fallbacks
-            const fallbacks = new EffectFallbacks();
-            if (defines.FOG) {
-                fallbacks.addFallback(1, "FOG");
+            // Methods
+            addToRenderList(node) {
+                if (this._refractionRTT && this._refractionRTT.renderList) {
+                    this._refractionRTT.renderList.push(node);
+                }
+                if (this._reflectionRTT && this._reflectionRTT.renderList) {
+                    this._reflectionRTT.renderList.push(node);
+                }
             }
-            if (defines.LOGARITHMICDEPTH) {
-                fallbacks.addFallback(0, "LOGARITHMICDEPTH");
+            removeFromRenderList(node) {
+                if (this._refractionRTT && this._refractionRTT.renderList) {
+                    const idx = this._refractionRTT.renderList.indexOf(node);
+                    if (idx !== -1) {
+                        this._refractionRTT.renderList.splice(idx, 1);
+                    }
+                }
+                if (this._reflectionRTT && this._reflectionRTT.renderList) {
+                    const idx = this._reflectionRTT.renderList.indexOf(node);
+                    if (idx !== -1) {
+                        this._reflectionRTT.renderList.splice(idx, 1);
+                    }
+                }
             }
-            HandleFallbacksForShadows(defines, fallbacks, this.maxSimultaneousLights);
-            if (defines.NUM_BONE_INFLUENCERS > 0) {
-                fallbacks.addCPUSkinningFallback(0, mesh);
+            enableRenderTargets(enable) {
+                const refreshRate = enable ? 1 : 0;
+                if (this._refractionRTT) {
+                    this._refractionRTT.refreshRate = refreshRate;
+                }
+                if (this._reflectionRTT) {
+                    this._reflectionRTT.refreshRate = refreshRate;
+                }
             }
-            //Attributes
-            const attribs = [VertexBuffer.PositionKind];
-            if (defines.NORMAL) {
-                attribs.push(VertexBuffer.NormalKind);
+            getRenderList() {
+                return this._refractionRTT ? this._refractionRTT.renderList : [];
             }
-            if (defines.UV1) {
-                attribs.push(VertexBuffer.UVKind);
+            get renderTargetsEnabled() {
+                return !(this._refractionRTT && this._refractionRTT.refreshRate === 0);
             }
-            if (defines.UV2) {
-                attribs.push(VertexBuffer.UV2Kind);
+            needAlphaBlending() {
+                return this.alpha < 1.0;
             }
-            if (defines.VERTEXCOLOR) {
-                attribs.push(VertexBuffer.ColorKind);
+            needAlphaTesting() {
+                return false;
             }
-            PrepareAttributesForBones(attribs, mesh, defines, fallbacks);
-            PrepareAttributesForInstances(attribs, defines);
-            // Legacy browser patch
-            const shaderName = "water";
-            const join = defines.toString();
-            const uniforms = [
-                "world",
-                "view",
-                "viewProjection",
-                "vEyePosition",
-                "vLightsType",
-                "vDiffuseColor",
-                "vSpecularColor",
-                "vFogInfos",
-                "vFogColor",
-                "pointSize",
-                "vNormalInfos",
-                "mBones",
-                "normalMatrix",
-                "logarithmicDepthConstant",
-                // Water
-                "reflectionViewProjection",
-                "windDirection",
-                "waveLength",
-                "time",
-                "windForce",
-                "cameraPosition",
-                "bumpHeight",
-                "waveHeight",
-                "waterColor",
-                "waterColor2",
-                "colorBlendFactor",
-                "colorBlendFactor2",
-                "waveSpeed",
-                "waveCount",
-            ];
-            const samplers = [
-                "normalSampler",
-                // Water
-                "refractionSampler",
-                "reflectionSampler",
-            ];
-            const uniformBuffers = [];
-            if (ImageProcessingConfiguration) {
-                ImageProcessingConfiguration.PrepareUniforms(uniforms, defines);
-                ImageProcessingConfiguration.PrepareSamplers(samplers, defines);
+            getAlphaTestTexture() {
+                return null;
             }
-            AddClipPlaneUniforms(uniforms);
-            PrepareUniformsAndSamplersList({
-                uniformsNames: uniforms,
-                uniformBuffersNames: uniformBuffers,
-                samplers: samplers,
-                defines: defines,
-                maxSimultaneousLights: this.maxSimultaneousLights,
-                shaderLanguage: this._shaderLanguage,
-            });
-            subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
-                attributes: attribs,
-                uniformsNames: uniforms,
-                uniformBuffersNames: uniformBuffers,
-                samplers: samplers,
-                defines: join,
-                fallbacks: fallbacks,
-                onCompiled: this.onCompiled,
-                onError: this.onError,
-                indexParameters: { maxSimultaneousLights: this._maxSimultaneousLights },
-                shaderLanguage: this._shaderLanguage,
-                extraInitializationsAsync: this._shadersLoaded
-                    ? undefined
-                    : async () => {
-                        if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
-                            await Promise.all([import("./wgsl/water.vertex.js"), import("./wgsl/water.fragment.js")]);
+            isReadyForSubMesh(mesh, subMesh, useInstances) {
+                const drawWrapper = subMesh._drawWrapper;
+                if (this.isFrozen) {
+                    if (drawWrapper.effect && drawWrapper._wasPreviouslyReady && drawWrapper._wasPreviouslyUsingInstances === useInstances) {
+                        return true;
+                    }
+                }
+                if (!subMesh.materialDefines) {
+                    subMesh.materialDefines = new WaterMaterialDefines();
+                }
+                const defines = subMesh.materialDefines;
+                const scene = this.getScene();
+                if (this._isReadyForSubMesh(subMesh)) {
+                    return true;
+                }
+                const engine = scene.getEngine();
+                // Textures
+                if (defines._areTexturesDirty) {
+                    defines._needUVs = false;
+                    if (scene.texturesEnabled) {
+                        if (this.bumpTexture && MaterialFlags.BumpTextureEnabled) {
+                            if (!this.bumpTexture.isReady()) {
+                                return false;
+                            }
+                            else {
+                                defines._needUVs = true;
+                                defines.BUMP = true;
+                            }
                         }
-                        else {
-                            await Promise.all([import("./water.vertex.js"), import("./water.fragment.js")]);
+                        if (MaterialFlags.ReflectionTextureEnabled) {
+                            defines.REFLECTION = true;
                         }
-                        this._shadersLoaded = true;
-                    },
-            }, engine), defines, this._materialContext);
-        }
-        if (!subMesh.effect || !subMesh.effect.isReady()) {
-            return false;
-        }
-        defines._renderId = scene.getRenderId();
-        drawWrapper._wasPreviouslyReady = true;
-        drawWrapper._wasPreviouslyUsingInstances = !!useInstances;
-        return true;
-    }
-    bindForSubMesh(world, mesh, subMesh) {
-        const scene = this.getScene();
-        const defines = subMesh.materialDefines;
-        if (!defines) {
-            return;
-        }
-        const effect = subMesh.effect;
-        if (!effect || !this._mesh) {
-            return;
-        }
-        this._activeEffect = effect;
-        // Matrices
-        this.bindOnlyWorldMatrix(world);
-        this._activeEffect.setMatrix("viewProjection", scene.getTransformMatrix());
-        // Bones
-        BindBonesParameters(mesh, this._activeEffect);
-        if (this._mustRebind(scene, effect, subMesh)) {
-            // Textures
-            if (this.bumpTexture && MaterialFlags.BumpTextureEnabled) {
-                this._activeEffect.setTexture("normalSampler", this.bumpTexture);
-                this._activeEffect.setFloat2("vNormalInfos", this.bumpTexture.coordinatesIndex, this.bumpTexture.level);
-                this._activeEffect.setMatrix("normalMatrix", this.bumpTexture.getTextureMatrix());
+                    }
+                }
+                PrepareDefinesForFrameBoundValues(scene, engine, this, defines, useInstances ? true : false);
+                PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, this.needAlphaTestingForMesh(mesh), defines, undefined, undefined, undefined, this._isVertexOutputInvariant);
+                if (defines._areMiscDirty) {
+                    defines.FRESNELSEPARATE = this._fresnelSeparate;
+                    defines.BUMPSUPERIMPOSE = this._bumpSuperimpose;
+                    defines.BUMPAFFECTSREFLECTION = this._bumpAffectsReflection;
+                    defines.USE_WORLD_COORDINATES = this._useWorldCoordinatesForWaveDeformation;
+                }
+                // Lights
+                defines._needNormals = PrepareDefinesForLights(scene, mesh, defines, true, this._maxSimultaneousLights, this._disableLighting);
+                // Image processing
+                if (defines._areImageProcessingDirty && this._imageProcessingConfiguration) {
+                    if (!this._imageProcessingConfiguration.isReady()) {
+                        return false;
+                    }
+                    this._imageProcessingConfiguration.prepareDefines(defines);
+                    defines.IS_REFLECTION_LINEAR = this.reflectionTexture != null && !this.reflectionTexture.gammaSpace;
+                    defines.IS_REFRACTION_LINEAR = this.refractionTexture != null && !this.refractionTexture.gammaSpace;
+                }
+                // Attribs
+                PrepareDefinesForAttributes(mesh, defines, true, true);
+                // Configure this
+                this._mesh = mesh;
+                if (this._waitingRenderList) {
+                    for (let i = 0; i < this._waitingRenderList.length; i++) {
+                        this.addToRenderList(scene.getNodeById(this._waitingRenderList[i]));
+                    }
+                    this._waitingRenderList = null;
+                }
+                // Get correct effect
+                if (defines.isDirty) {
+                    defines.markAsProcessed();
+                    scene.resetCachedMaterial();
+                    // Fallbacks
+                    const fallbacks = new EffectFallbacks();
+                    if (defines.FOG) {
+                        fallbacks.addFallback(1, "FOG");
+                    }
+                    if (defines.LOGARITHMICDEPTH) {
+                        fallbacks.addFallback(0, "LOGARITHMICDEPTH");
+                    }
+                    HandleFallbacksForShadows(defines, fallbacks, this.maxSimultaneousLights);
+                    if (defines.NUM_BONE_INFLUENCERS > 0) {
+                        fallbacks.addCPUSkinningFallback(0, mesh);
+                    }
+                    //Attributes
+                    const attribs = [VertexBuffer.PositionKind];
+                    if (defines.NORMAL) {
+                        attribs.push(VertexBuffer.NormalKind);
+                    }
+                    if (defines.UV1) {
+                        attribs.push(VertexBuffer.UVKind);
+                    }
+                    if (defines.UV2) {
+                        attribs.push(VertexBuffer.UV2Kind);
+                    }
+                    if (defines.VERTEXCOLOR) {
+                        attribs.push(VertexBuffer.ColorKind);
+                    }
+                    PrepareAttributesForBones(attribs, mesh, defines, fallbacks);
+                    PrepareAttributesForInstances(attribs, defines);
+                    // Legacy browser patch
+                    const shaderName = "water";
+                    const join = defines.toString();
+                    const uniforms = [
+                        "world",
+                        "view",
+                        "viewProjection",
+                        "vEyePosition",
+                        "vLightsType",
+                        "vDiffuseColor",
+                        "vSpecularColor",
+                        "vFogInfos",
+                        "vFogColor",
+                        "pointSize",
+                        "vNormalInfos",
+                        "mBones",
+                        "normalMatrix",
+                        "logarithmicDepthConstant",
+                        // Water
+                        "reflectionViewProjection",
+                        "windDirection",
+                        "waveLength",
+                        "time",
+                        "windForce",
+                        "cameraPosition",
+                        "bumpHeight",
+                        "waveHeight",
+                        "waterColor",
+                        "waterColor2",
+                        "colorBlendFactor",
+                        "colorBlendFactor2",
+                        "waveSpeed",
+                        "waveCount",
+                    ];
+                    const samplers = [
+                        "normalSampler",
+                        // Water
+                        "refractionSampler",
+                        "reflectionSampler",
+                    ];
+                    const uniformBuffers = [];
+                    if (ImageProcessingConfiguration) {
+                        ImageProcessingConfiguration.PrepareUniforms(uniforms, defines);
+                        ImageProcessingConfiguration.PrepareSamplers(samplers, defines);
+                    }
+                    AddClipPlaneUniforms(uniforms);
+                    PrepareUniformsAndSamplersList({
+                        uniformsNames: uniforms,
+                        uniformBuffersNames: uniformBuffers,
+                        samplers: samplers,
+                        defines: defines,
+                        maxSimultaneousLights: this.maxSimultaneousLights,
+                        shaderLanguage: this._shaderLanguage,
+                    });
+                    subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
+                        attributes: attribs,
+                        uniformsNames: uniforms,
+                        uniformBuffersNames: uniformBuffers,
+                        samplers: samplers,
+                        defines: join,
+                        fallbacks: fallbacks,
+                        onCompiled: this.onCompiled,
+                        onError: this.onError,
+                        indexParameters: { maxSimultaneousLights: this._maxSimultaneousLights },
+                        shaderLanguage: this._shaderLanguage,
+                        extraInitializationsAsync: this._shadersLoaded
+                            ? undefined
+                            : async () => {
+                                if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
+                                    await Promise.all([import("./wgsl/water.vertex.js"), import("./wgsl/water.fragment.js")]);
+                                }
+                                else {
+                                    await Promise.all([import("./water.vertex.js"), import("./water.fragment.js")]);
+                                }
+                                this._shadersLoaded = true;
+                            },
+                    }, engine), defines, this._materialContext);
+                }
+                if (!subMesh.effect || !subMesh.effect.isReady()) {
+                    return false;
+                }
+                defines._renderId = scene.getRenderId();
+                drawWrapper._wasPreviouslyReady = true;
+                drawWrapper._wasPreviouslyUsingInstances = !!useInstances;
+                return true;
             }
-            // Clip plane
-            BindClipPlane(effect, this, scene);
-            // Point size
-            if (this.pointsCloud) {
-                this._activeEffect.setFloat("pointSize", this.pointSize);
+            bindForSubMesh(world, mesh, subMesh) {
+                const scene = this.getScene();
+                const defines = subMesh.materialDefines;
+                if (!defines) {
+                    return;
+                }
+                const effect = subMesh.effect;
+                if (!effect || !this._mesh) {
+                    return;
+                }
+                this._activeEffect = effect;
+                // Matrices
+                this.bindOnlyWorldMatrix(world);
+                this._activeEffect.setMatrix("viewProjection", scene.getTransformMatrix());
+                // Bones
+                BindBonesParameters(mesh, this._activeEffect);
+                if (this._mustRebind(scene, effect, subMesh)) {
+                    // Textures
+                    if (this.bumpTexture && MaterialFlags.BumpTextureEnabled) {
+                        this._activeEffect.setTexture("normalSampler", this.bumpTexture);
+                        this._activeEffect.setFloat2("vNormalInfos", this.bumpTexture.coordinatesIndex, this.bumpTexture.level);
+                        this._activeEffect.setMatrix("normalMatrix", this.bumpTexture.getTextureMatrix());
+                    }
+                    // Clip plane
+                    BindClipPlane(effect, this, scene);
+                    // Point size
+                    if (this.pointsCloud) {
+                        this._activeEffect.setFloat("pointSize", this.pointSize);
+                    }
+                    // Log. depth
+                    if (this._useLogarithmicDepth) {
+                        BindLogDepth(defines, effect, scene);
+                    }
+                    scene.bindEyePosition(effect);
+                }
+                this._activeEffect.setColor4("vDiffuseColor", this.diffuseColor, this.alpha * mesh.visibility);
+                if (defines.SPECULARTERM) {
+                    this._activeEffect.setColor4("vSpecularColor", this.specularColor, this.specularPower);
+                }
+                if (scene.lightsEnabled && !this.disableLighting) {
+                    BindLights(scene, mesh, this._activeEffect, defines, this.maxSimultaneousLights);
+                }
+                // View
+                if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
+                    this._activeEffect.setMatrix("view", scene.getViewMatrix());
+                }
+                // Fog
+                BindFogParameters(scene, mesh, this._activeEffect);
+                // Log. depth
+                BindLogDepth(defines, this._activeEffect, scene);
+                // Water
+                if (MaterialFlags.ReflectionTextureEnabled) {
+                    this._activeEffect.setTexture("refractionSampler", this._refractionRTT);
+                    this._activeEffect.setTexture("reflectionSampler", this._reflectionRTT);
+                }
+                const wrvp = TmpVectors.Matrix[3].copyFrom(this._reflectionTransform);
+                // Handle floating origin for reflection
+                if (scene.floatingOriginMode) {
+                    // Recalculate reflection transform using offset mirror matrix
+                    const offsetView = OffsetViewToRef(scene.floatingOriginOffset, scene.getViewMatrix(), TmpVectors.Matrix[1]);
+                    MultiplyMatricesToRef(this._offsetMirror, offsetView, wrvp);
+                }
+                wrvp.multiplyToRef(scene.getProjectionMatrix(), wrvp);
+                // Add delta time. Prevent adding delta time if it hasn't changed.
+                const deltaTime = scene.getEngine().getDeltaTime();
+                if (deltaTime !== this._lastDeltaTime) {
+                    this._lastDeltaTime = deltaTime;
+                    this._lastTime += this._lastDeltaTime;
+                }
+                this._activeEffect.setMatrix("reflectionViewProjection", wrvp);
+                this._activeEffect.setVector2("windDirection", this.windDirection);
+                this._activeEffect.setFloat("waveLength", this.waveLength);
+                this._activeEffect.setFloat("time", this._lastTime / 100000);
+                this._activeEffect.setFloat("windForce", this.windForce);
+                this._activeEffect.setFloat("waveHeight", this.waveHeight);
+                this._activeEffect.setFloat("bumpHeight", this.bumpHeight);
+                this._activeEffect.setColor4("waterColor", this.waterColor, 1.0);
+                this._activeEffect.setFloat("colorBlendFactor", this.colorBlendFactor);
+                this._activeEffect.setColor4("waterColor2", this.waterColor2, 1.0);
+                this._activeEffect.setFloat("colorBlendFactor2", this.colorBlendFactor2);
+                this._activeEffect.setFloat("waveSpeed", this.waveSpeed);
+                this._activeEffect.setFloat("waveCount", this.waveCount);
+                // image processing
+                if (this._imageProcessingConfiguration && !this._imageProcessingConfiguration.applyByPostProcess) {
+                    this._imageProcessingConfiguration.bind(this._activeEffect);
+                }
+                this._afterBind(mesh, this._activeEffect, subMesh);
             }
-            // Log. depth
-            if (this._useLogarithmicDepth) {
-                BindLogDepth(defines, effect, scene);
+            _createRenderTargets(scene, renderTargetSize) {
+                // Render targets
+                this._refractionRTT = new RenderTargetTexture(name + "_refraction", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
+                this._refractionRTT.wrapU = Constants.TEXTURE_MIRROR_ADDRESSMODE;
+                this._refractionRTT.wrapV = Constants.TEXTURE_MIRROR_ADDRESSMODE;
+                this._refractionRTT.ignoreCameraViewport = true;
+                let boundingBoxRendererEnabled = false;
+                this._refractionRTT.onBeforeRenderObservable.add(() => {
+                    boundingBoxRendererEnabled = scene.getBoundingBoxRenderer().enabled;
+                    scene.getBoundingBoxRenderer().enabled = false;
+                });
+                this._refractionRTT.onAfterRenderObservable.add(() => {
+                    scene.getBoundingBoxRenderer().enabled = boundingBoxRendererEnabled;
+                });
+                this._reflectionRTT = new RenderTargetTexture(name + "_reflection", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
+                this._reflectionRTT.wrapU = Constants.TEXTURE_MIRROR_ADDRESSMODE;
+                this._reflectionRTT.wrapV = Constants.TEXTURE_MIRROR_ADDRESSMODE;
+                this._reflectionRTT.ignoreCameraViewport = true;
+                let isVisible;
+                let clipPlane = null;
+                let savedViewMatrix;
+                const mirrorMatrix = Matrix.Zero();
+                this._refractionRTT.onBeforeRender = () => {
+                    if (this._mesh) {
+                        isVisible = this._mesh.isVisible;
+                        this._mesh.isVisible = false;
+                    }
+                    // Clip plane
+                    if (!this.disableClipPlane) {
+                        clipPlane = scene.clipPlane;
+                        const positiony = this._mesh ? this._mesh.absolutePosition.y : 0.0;
+                        scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony + 0.05, 0), new Vector3(0, 1, 0));
+                    }
+                };
+                this._refractionRTT.onAfterRender = () => {
+                    if (this._mesh) {
+                        this._mesh.isVisible = isVisible;
+                    }
+                    // Clip plane
+                    if (!this.disableClipPlane) {
+                        scene.clipPlane = clipPlane;
+                    }
+                };
+                this._reflectionRTT.onBeforeRender = () => {
+                    if (this._mesh) {
+                        isVisible = this._mesh.isVisible;
+                        this._mesh.isVisible = false;
+                    }
+                    // Clip plane
+                    if (!this.disableClipPlane) {
+                        clipPlane = scene.clipPlane;
+                        const positiony = this._mesh ? this._mesh.absolutePosition.y : 0.0;
+                        scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony - 0.05, 0), new Vector3(0, -1, 0));
+                        Matrix.ReflectionToRef(scene.clipPlane, mirrorMatrix);
+                        this._offsetMirror.copyFrom(mirrorMatrix);
+                        if (scene.floatingOriginMode) {
+                            OffsetClipPlaneToRef(scene.floatingOriginOffset, scene.clipPlane, this._tempPlane);
+                            Matrix.ReflectionToRef(this._tempPlane, this._offsetMirror);
+                        }
+                    }
+                    // Transform
+                    savedViewMatrix = scene.getViewMatrix();
+                    mirrorMatrix.multiplyToRef(savedViewMatrix, this._reflectionTransform);
+                    scene.setTransformMatrix(this._reflectionTransform, scene.getProjectionMatrix());
+                    const cameraPos = Vector3.TransformCoordinates(scene.activeCamera.position, mirrorMatrix);
+                    scene._mirroredCameraPosition = cameraPos;
+                    scene._forcedViewPosition = cameraPos; // More performant to set 2 properties here than to check both mirroredCameraPos and forcedViewPos within eye binding (which happens on critical rendering path)
+                };
+                this._reflectionRTT.onAfterRender = () => {
+                    if (this._mesh) {
+                        this._mesh.isVisible = isVisible;
+                    }
+                    // Clip plane
+                    scene.clipPlane = clipPlane;
+                    // Transform
+                    scene.setTransformMatrix(savedViewMatrix, scene.getProjectionMatrix());
+                    scene._mirroredCameraPosition = null;
+                    scene._forcedViewPosition = null;
+                };
             }
-            scene.bindEyePosition(effect);
-        }
-        this._activeEffect.setColor4("vDiffuseColor", this.diffuseColor, this.alpha * mesh.visibility);
-        if (defines.SPECULARTERM) {
-            this._activeEffect.setColor4("vSpecularColor", this.specularColor, this.specularPower);
-        }
-        if (scene.lightsEnabled && !this.disableLighting) {
-            BindLights(scene, mesh, this._activeEffect, defines, this.maxSimultaneousLights);
-        }
-        // View
-        if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
-            this._activeEffect.setMatrix("view", scene.getViewMatrix());
-        }
-        // Fog
-        BindFogParameters(scene, mesh, this._activeEffect);
-        // Log. depth
-        BindLogDepth(defines, this._activeEffect, scene);
-        // Water
-        if (MaterialFlags.ReflectionTextureEnabled) {
-            this._activeEffect.setTexture("refractionSampler", this._refractionRTT);
-            this._activeEffect.setTexture("reflectionSampler", this._reflectionRTT);
-        }
-        const wrvp = TmpVectors.Matrix[3].copyFrom(this._reflectionTransform);
-        // Handle floating origin for reflection
-        if (scene.floatingOriginMode) {
-            // Recalculate reflection transform using offset mirror matrix
-            const offsetView = OffsetViewToRef(scene.floatingOriginOffset, scene.getViewMatrix(), TmpVectors.Matrix[1]);
-            MultiplyMatricesToRef(this._offsetMirror, offsetView, wrvp);
-        }
-        wrvp.multiplyToRef(scene.getProjectionMatrix(), wrvp);
-        // Add delta time. Prevent adding delta time if it hasn't changed.
-        const deltaTime = scene.getEngine().getDeltaTime();
-        if (deltaTime !== this._lastDeltaTime) {
-            this._lastDeltaTime = deltaTime;
-            this._lastTime += this._lastDeltaTime;
-        }
-        this._activeEffect.setMatrix("reflectionViewProjection", wrvp);
-        this._activeEffect.setVector2("windDirection", this.windDirection);
-        this._activeEffect.setFloat("waveLength", this.waveLength);
-        this._activeEffect.setFloat("time", this._lastTime / 100000);
-        this._activeEffect.setFloat("windForce", this.windForce);
-        this._activeEffect.setFloat("waveHeight", this.waveHeight);
-        this._activeEffect.setFloat("bumpHeight", this.bumpHeight);
-        this._activeEffect.setColor4("waterColor", this.waterColor, 1.0);
-        this._activeEffect.setFloat("colorBlendFactor", this.colorBlendFactor);
-        this._activeEffect.setColor4("waterColor2", this.waterColor2, 1.0);
-        this._activeEffect.setFloat("colorBlendFactor2", this.colorBlendFactor2);
-        this._activeEffect.setFloat("waveSpeed", this.waveSpeed);
-        this._activeEffect.setFloat("waveCount", this.waveCount);
-        // image processing
-        if (this._imageProcessingConfiguration && !this._imageProcessingConfiguration.applyByPostProcess) {
-            this._imageProcessingConfiguration.bind(this._activeEffect);
-        }
-        this._afterBind(mesh, this._activeEffect, subMesh);
-    }
-    _createRenderTargets(scene, renderTargetSize) {
-        // Render targets
-        this._refractionRTT = new RenderTargetTexture(name + "_refraction", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
-        this._refractionRTT.wrapU = Constants.TEXTURE_MIRROR_ADDRESSMODE;
-        this._refractionRTT.wrapV = Constants.TEXTURE_MIRROR_ADDRESSMODE;
-        this._refractionRTT.ignoreCameraViewport = true;
-        let boundingBoxRendererEnabled = false;
-        this._refractionRTT.onBeforeRenderObservable.add(() => {
-            boundingBoxRendererEnabled = scene.getBoundingBoxRenderer().enabled;
-            scene.getBoundingBoxRenderer().enabled = false;
-        });
-        this._refractionRTT.onAfterRenderObservable.add(() => {
-            scene.getBoundingBoxRenderer().enabled = boundingBoxRendererEnabled;
-        });
-        this._reflectionRTT = new RenderTargetTexture(name + "_reflection", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
-        this._reflectionRTT.wrapU = Constants.TEXTURE_MIRROR_ADDRESSMODE;
-        this._reflectionRTT.wrapV = Constants.TEXTURE_MIRROR_ADDRESSMODE;
-        this._reflectionRTT.ignoreCameraViewport = true;
-        let isVisible;
-        let clipPlane = null;
-        let savedViewMatrix;
-        const mirrorMatrix = Matrix.Zero();
-        this._refractionRTT.onBeforeRender = () => {
-            if (this._mesh) {
-                isVisible = this._mesh.isVisible;
-                this._mesh.isVisible = false;
+            getAnimatables() {
+                const results = [];
+                if (this.bumpTexture && this.bumpTexture.animations && this.bumpTexture.animations.length > 0) {
+                    results.push(this.bumpTexture);
+                }
+                if (this._reflectionRTT && this._reflectionRTT.animations && this._reflectionRTT.animations.length > 0) {
+                    results.push(this._reflectionRTT);
+                }
+                if (this._refractionRTT && this._refractionRTT.animations && this._refractionRTT.animations.length > 0) {
+                    results.push(this._refractionRTT);
+                }
+                return results;
             }
-            // Clip plane
-            if (!this.disableClipPlane) {
-                clipPlane = scene.clipPlane;
-                const positiony = this._mesh ? this._mesh.absolutePosition.y : 0.0;
-                scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony + 0.05, 0), new Vector3(0, 1, 0));
+            getActiveTextures() {
+                const activeTextures = super.getActiveTextures();
+                if (this._bumpTexture) {
+                    activeTextures.push(this._bumpTexture);
+                }
+                return activeTextures;
             }
-        };
-        this._refractionRTT.onAfterRender = () => {
-            if (this._mesh) {
-                this._mesh.isVisible = isVisible;
+            hasTexture(texture) {
+                if (super.hasTexture(texture)) {
+                    return true;
+                }
+                if (this._bumpTexture === texture) {
+                    return true;
+                }
+                return false;
             }
-            // Clip plane
-            if (!this.disableClipPlane) {
-                scene.clipPlane = clipPlane;
+            dispose(forceDisposeEffect) {
+                if (this.bumpTexture) {
+                    this.bumpTexture.dispose();
+                }
+                let index = this.getScene().customRenderTargets.indexOf(this._refractionRTT);
+                if (index != -1) {
+                    this.getScene().customRenderTargets.splice(index, 1);
+                }
+                index = this.getScene().customRenderTargets.indexOf(this._reflectionRTT);
+                if (index != -1) {
+                    this.getScene().customRenderTargets.splice(index, 1);
+                }
+                if (this._reflectionRTT) {
+                    this._reflectionRTT.dispose();
+                }
+                if (this._refractionRTT) {
+                    this._refractionRTT.dispose();
+                }
+                // Remove image-processing observer
+                if (this._imageProcessingConfiguration && this._imageProcessingObserver) {
+                    this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver);
+                }
+                super.dispose(forceDisposeEffect);
             }
-        };
-        this._reflectionRTT.onBeforeRender = () => {
-            if (this._mesh) {
-                isVisible = this._mesh.isVisible;
-                this._mesh.isVisible = false;
+            clone(name) {
+                return SerializationHelper.Clone(() => new _a(name, this.getScene()), this);
             }
-            // Clip plane
-            if (!this.disableClipPlane) {
-                clipPlane = scene.clipPlane;
-                const positiony = this._mesh ? this._mesh.absolutePosition.y : 0.0;
-                scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony - 0.05, 0), new Vector3(0, -1, 0));
-                Matrix.ReflectionToRef(scene.clipPlane, mirrorMatrix);
-                this._offsetMirror.copyFrom(mirrorMatrix);
-                if (scene.floatingOriginMode) {
-                    OffsetClipPlaneToRef(scene.floatingOriginOffset, scene.clipPlane, this._tempPlane);
-                    Matrix.ReflectionToRef(this._tempPlane, this._offsetMirror);
+            serialize() {
+                const serializationObject = super.serialize();
+                serializationObject.customType = "BABYLON.WaterMaterial";
+                serializationObject.renderList = [];
+                if (this._refractionRTT && this._refractionRTT.renderList) {
+                    for (let i = 0; i < this._refractionRTT.renderList.length; i++) {
+                        serializationObject.renderList.push(this._refractionRTT.renderList[i].id);
+                    }
                 }
+                return serializationObject;
             }
-            // Transform
-            savedViewMatrix = scene.getViewMatrix();
-            mirrorMatrix.multiplyToRef(savedViewMatrix, this._reflectionTransform);
-            scene.setTransformMatrix(this._reflectionTransform, scene.getProjectionMatrix());
-            const cameraPos = Vector3.TransformCoordinates(scene.activeCamera.position, mirrorMatrix);
-            scene._mirroredCameraPosition = cameraPos;
-            scene._forcedViewPosition = cameraPos; // More performant to set 2 properties here than to check both mirroredCameraPos and forcedViewPos within eye binding (which happens on critical rendering path)
-        };
-        this._reflectionRTT.onAfterRender = () => {
-            if (this._mesh) {
-                this._mesh.isVisible = isVisible;
+            getClassName() {
+                return "WaterMaterial";
             }
-            // Clip plane
-            scene.clipPlane = clipPlane;
-            // Transform
-            scene.setTransformMatrix(savedViewMatrix, scene.getProjectionMatrix());
-            scene._mirroredCameraPosition = null;
-            scene._forcedViewPosition = null;
-        };
-    }
-    getAnimatables() {
-        const results = [];
-        if (this.bumpTexture && this.bumpTexture.animations && this.bumpTexture.animations.length > 0) {
-            results.push(this.bumpTexture);
-        }
-        if (this._reflectionRTT && this._reflectionRTT.animations && this._reflectionRTT.animations.length > 0) {
-            results.push(this._reflectionRTT);
-        }
-        if (this._refractionRTT && this._refractionRTT.animations && this._refractionRTT.animations.length > 0) {
-            results.push(this._refractionRTT);
-        }
-        return results;
-    }
-    getActiveTextures() {
-        const activeTextures = super.getActiveTextures();
-        if (this._bumpTexture) {
-            activeTextures.push(this._bumpTexture);
-        }
-        return activeTextures;
-    }
-    hasTexture(texture) {
-        if (super.hasTexture(texture)) {
-            return true;
-        }
-        if (this._bumpTexture === texture) {
-            return true;
-        }
-        return false;
-    }
-    dispose(forceDisposeEffect) {
-        if (this.bumpTexture) {
-            this.bumpTexture.dispose();
-        }
-        let index = this.getScene().customRenderTargets.indexOf(this._refractionRTT);
-        if (index != -1) {
-            this.getScene().customRenderTargets.splice(index, 1);
-        }
-        index = this.getScene().customRenderTargets.indexOf(this._reflectionRTT);
-        if (index != -1) {
-            this.getScene().customRenderTargets.splice(index, 1);
-        }
-        if (this._reflectionRTT) {
-            this._reflectionRTT.dispose();
-        }
-        if (this._refractionRTT) {
-            this._refractionRTT.dispose();
-        }
-        // Remove image-processing observer
-        if (this._imageProcessingConfiguration && this._imageProcessingObserver) {
-            this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver);
-        }
-        super.dispose(forceDisposeEffect);
-    }
-    clone(name) {
-        return SerializationHelper.Clone(() => new WaterMaterial(name, this.getScene()), this);
-    }
-    serialize() {
-        const serializationObject = super.serialize();
-        serializationObject.customType = "BABYLON.WaterMaterial";
-        serializationObject.renderList = [];
-        if (this._refractionRTT && this._refractionRTT.renderList) {
-            for (let i = 0; i < this._refractionRTT.renderList.length; i++) {
-                serializationObject.renderList.push(this._refractionRTT.renderList[i].id);
+            // Statics
+            static Parse(source, scene, rootUrl) {
+                const mat = SerializationHelper.Parse(() => new _a(source.name, scene), source, scene, rootUrl);
+                mat._waitingRenderList = source.renderList;
+                return mat;
             }
-        }
-        return serializationObject;
-    }
-    getClassName() {
-        return "WaterMaterial";
-    }
-    // Statics
-    static Parse(source, scene, rootUrl) {
-        const mat = SerializationHelper.Parse(() => new WaterMaterial(source.name, scene), source, scene, rootUrl);
-        mat._waitingRenderList = source.renderList;
-        return mat;
-    }
-    static CreateDefaultMesh(name, scene) {
-        const mesh = CreateGround(name, { width: 512, height: 512, subdivisions: 32, updatable: false }, scene);
-        return mesh;
-    }
-}
-__decorate([
-    serializeAsTexture("bumpTexture")
-], WaterMaterial.prototype, "_bumpTexture", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], WaterMaterial.prototype, "bumpTexture", void 0);
-__decorate([
-    serializeAsColor3()
-], WaterMaterial.prototype, "diffuseColor", void 0);
-__decorate([
-    serializeAsColor3()
-], WaterMaterial.prototype, "specularColor", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "specularPower", void 0);
-__decorate([
-    serialize("disableLighting")
-], WaterMaterial.prototype, "_disableLighting", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsLightsDirty")
-], WaterMaterial.prototype, "disableLighting", void 0);
-__decorate([
-    serialize("maxSimultaneousLights")
-], WaterMaterial.prototype, "_maxSimultaneousLights", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsLightsDirty")
-], WaterMaterial.prototype, "maxSimultaneousLights", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "windForce", void 0);
-__decorate([
-    serializeAsVector2()
-], WaterMaterial.prototype, "windDirection", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "waveHeight", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "bumpHeight", void 0);
-__decorate([
-    serialize("bumpSuperimpose")
-], WaterMaterial.prototype, "_bumpSuperimpose", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsMiscDirty")
-], WaterMaterial.prototype, "bumpSuperimpose", void 0);
-__decorate([
-    serialize("fresnelSeparate")
-], WaterMaterial.prototype, "_fresnelSeparate", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsMiscDirty")
-], WaterMaterial.prototype, "fresnelSeparate", void 0);
-__decorate([
-    serialize("bumpAffectsReflection")
-], WaterMaterial.prototype, "_bumpAffectsReflection", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsMiscDirty")
-], WaterMaterial.prototype, "bumpAffectsReflection", void 0);
-__decorate([
-    serializeAsColor3()
-], WaterMaterial.prototype, "waterColor", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "colorBlendFactor", void 0);
-__decorate([
-    serializeAsColor3()
-], WaterMaterial.prototype, "waterColor2", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "colorBlendFactor2", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "waveLength", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "waveSpeed", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "waveCount", void 0);
-__decorate([
-    serialize()
-], WaterMaterial.prototype, "disableClipPlane", void 0);
-__decorate([
-    serialize("useWorldCoordinatesForWaveDeformation")
-], WaterMaterial.prototype, "_useWorldCoordinatesForWaveDeformation", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsMiscDirty")
-], WaterMaterial.prototype, "useWorldCoordinatesForWaveDeformation", void 0);
+            static CreateDefaultMesh(name, scene) {
+                const mesh = CreateGround(name, { width: 512, height: 512, subdivisions: 32, updatable: false }, scene);
+                return mesh;
+            }
+        },
+        _WaterMaterial_bumpTexture_accessor_storage = new WeakMap(),
+        _WaterMaterial_disableLighting_accessor_storage = new WeakMap(),
+        _WaterMaterial_maxSimultaneousLights_accessor_storage = new WeakMap(),
+        _WaterMaterial_bumpSuperimpose_accessor_storage = new WeakMap(),
+        _WaterMaterial_fresnelSeparate_accessor_storage = new WeakMap(),
+        _WaterMaterial_bumpAffectsReflection_accessor_storage = new WeakMap(),
+        _WaterMaterial_useWorldCoordinatesForWaveDeformation_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __bumpTexture_decorators = [serializeAsTexture("bumpTexture")];
+            _bumpTexture_decorators = [expandToProperty("_markAllSubMeshesAsTexturesDirty")];
+            _diffuseColor_decorators = [serializeAsColor3()];
+            _specularColor_decorators = [serializeAsColor3()];
+            _specularPower_decorators = [serialize()];
+            __disableLighting_decorators = [serialize("disableLighting")];
+            _disableLighting_decorators = [expandToProperty("_markAllSubMeshesAsLightsDirty")];
+            __maxSimultaneousLights_decorators = [serialize("maxSimultaneousLights")];
+            _maxSimultaneousLights_decorators = [expandToProperty("_markAllSubMeshesAsLightsDirty")];
+            _windForce_decorators = [serialize()];
+            _windDirection_decorators = [serializeAsVector2()];
+            _waveHeight_decorators = [serialize()];
+            _bumpHeight_decorators = [serialize()];
+            __bumpSuperimpose_decorators = [serialize("bumpSuperimpose")];
+            _bumpSuperimpose_decorators = [expandToProperty("_markAllSubMeshesAsMiscDirty")];
+            __fresnelSeparate_decorators = [serialize("fresnelSeparate")];
+            _fresnelSeparate_decorators = [expandToProperty("_markAllSubMeshesAsMiscDirty")];
+            __bumpAffectsReflection_decorators = [serialize("bumpAffectsReflection")];
+            _bumpAffectsReflection_decorators = [expandToProperty("_markAllSubMeshesAsMiscDirty")];
+            _waterColor_decorators = [serializeAsColor3()];
+            _colorBlendFactor_decorators = [serialize()];
+            _waterColor2_decorators = [serializeAsColor3()];
+            _colorBlendFactor2_decorators = [serialize()];
+            _waveLength_decorators = [serialize()];
+            _waveSpeed_decorators = [serialize()];
+            _waveCount_decorators = [serialize()];
+            _disableClipPlane_decorators = [serialize()];
+            __useWorldCoordinatesForWaveDeformation_decorators = [serialize("useWorldCoordinatesForWaveDeformation")];
+            _useWorldCoordinatesForWaveDeformation_decorators = [expandToProperty("_markAllSubMeshesAsMiscDirty")];
+            __esDecorate(_a, null, _bumpTexture_decorators, { kind: "accessor", name: "bumpTexture", static: false, private: false, access: { has: obj => "bumpTexture" in obj, get: obj => obj.bumpTexture, set: (obj, value) => { obj.bumpTexture = value; } }, metadata: _metadata }, _bumpTexture_initializers, _bumpTexture_extraInitializers);
+            __esDecorate(_a, null, _disableLighting_decorators, { kind: "accessor", name: "disableLighting", static: false, private: false, access: { has: obj => "disableLighting" in obj, get: obj => obj.disableLighting, set: (obj, value) => { obj.disableLighting = value; } }, metadata: _metadata }, _disableLighting_initializers, _disableLighting_extraInitializers);
+            __esDecorate(_a, null, _maxSimultaneousLights_decorators, { kind: "accessor", name: "maxSimultaneousLights", static: false, private: false, access: { has: obj => "maxSimultaneousLights" in obj, get: obj => obj.maxSimultaneousLights, set: (obj, value) => { obj.maxSimultaneousLights = value; } }, metadata: _metadata }, _maxSimultaneousLights_initializers, _maxSimultaneousLights_extraInitializers);
+            __esDecorate(_a, null, _bumpSuperimpose_decorators, { kind: "accessor", name: "bumpSuperimpose", static: false, private: false, access: { has: obj => "bumpSuperimpose" in obj, get: obj => obj.bumpSuperimpose, set: (obj, value) => { obj.bumpSuperimpose = value; } }, metadata: _metadata }, _bumpSuperimpose_initializers, _bumpSuperimpose_extraInitializers);
+            __esDecorate(_a, null, _fresnelSeparate_decorators, { kind: "accessor", name: "fresnelSeparate", static: false, private: false, access: { has: obj => "fresnelSeparate" in obj, get: obj => obj.fresnelSeparate, set: (obj, value) => { obj.fresnelSeparate = value; } }, metadata: _metadata }, _fresnelSeparate_initializers, _fresnelSeparate_extraInitializers);
+            __esDecorate(_a, null, _bumpAffectsReflection_decorators, { kind: "accessor", name: "bumpAffectsReflection", static: false, private: false, access: { has: obj => "bumpAffectsReflection" in obj, get: obj => obj.bumpAffectsReflection, set: (obj, value) => { obj.bumpAffectsReflection = value; } }, metadata: _metadata }, _bumpAffectsReflection_initializers, _bumpAffectsReflection_extraInitializers);
+            __esDecorate(_a, null, _useWorldCoordinatesForWaveDeformation_decorators, { kind: "accessor", name: "useWorldCoordinatesForWaveDeformation", static: false, private: false, access: { has: obj => "useWorldCoordinatesForWaveDeformation" in obj, get: obj => obj.useWorldCoordinatesForWaveDeformation, set: (obj, value) => { obj.useWorldCoordinatesForWaveDeformation = value; } }, metadata: _metadata }, _useWorldCoordinatesForWaveDeformation_initializers, _useWorldCoordinatesForWaveDeformation_extraInitializers);
+            __esDecorate(null, null, __bumpTexture_decorators, { kind: "field", name: "_bumpTexture", static: false, private: false, access: { has: obj => "_bumpTexture" in obj, get: obj => obj._bumpTexture, set: (obj, value) => { obj._bumpTexture = value; } }, metadata: _metadata }, __bumpTexture_initializers, __bumpTexture_extraInitializers);
+            __esDecorate(null, null, _diffuseColor_decorators, { kind: "field", name: "diffuseColor", static: false, private: false, access: { has: obj => "diffuseColor" in obj, get: obj => obj.diffuseColor, set: (obj, value) => { obj.diffuseColor = value; } }, metadata: _metadata }, _diffuseColor_initializers, _diffuseColor_extraInitializers);
+            __esDecorate(null, null, _specularColor_decorators, { kind: "field", name: "specularColor", static: false, private: false, access: { has: obj => "specularColor" in obj, get: obj => obj.specularColor, set: (obj, value) => { obj.specularColor = value; } }, metadata: _metadata }, _specularColor_initializers, _specularColor_extraInitializers);
+            __esDecorate(null, null, _specularPower_decorators, { kind: "field", name: "specularPower", static: false, private: false, access: { has: obj => "specularPower" in obj, get: obj => obj.specularPower, set: (obj, value) => { obj.specularPower = value; } }, metadata: _metadata }, _specularPower_initializers, _specularPower_extraInitializers);
+            __esDecorate(null, null, __disableLighting_decorators, { kind: "field", name: "_disableLighting", static: false, private: false, access: { has: obj => "_disableLighting" in obj, get: obj => obj._disableLighting, set: (obj, value) => { obj._disableLighting = value; } }, metadata: _metadata }, __disableLighting_initializers, __disableLighting_extraInitializers);
+            __esDecorate(null, null, __maxSimultaneousLights_decorators, { kind: "field", name: "_maxSimultaneousLights", static: false, private: false, access: { has: obj => "_maxSimultaneousLights" in obj, get: obj => obj._maxSimultaneousLights, set: (obj, value) => { obj._maxSimultaneousLights = value; } }, metadata: _metadata }, __maxSimultaneousLights_initializers, __maxSimultaneousLights_extraInitializers);
+            __esDecorate(null, null, _windForce_decorators, { kind: "field", name: "windForce", static: false, private: false, access: { has: obj => "windForce" in obj, get: obj => obj.windForce, set: (obj, value) => { obj.windForce = value; } }, metadata: _metadata }, _windForce_initializers, _windForce_extraInitializers);
+            __esDecorate(null, null, _windDirection_decorators, { kind: "field", name: "windDirection", static: false, private: false, access: { has: obj => "windDirection" in obj, get: obj => obj.windDirection, set: (obj, value) => { obj.windDirection = value; } }, metadata: _metadata }, _windDirection_initializers, _windDirection_extraInitializers);
+            __esDecorate(null, null, _waveHeight_decorators, { kind: "field", name: "waveHeight", static: false, private: false, access: { has: obj => "waveHeight" in obj, get: obj => obj.waveHeight, set: (obj, value) => { obj.waveHeight = value; } }, metadata: _metadata }, _waveHeight_initializers, _waveHeight_extraInitializers);
+            __esDecorate(null, null, _bumpHeight_decorators, { kind: "field", name: "bumpHeight", static: false, private: false, access: { has: obj => "bumpHeight" in obj, get: obj => obj.bumpHeight, set: (obj, value) => { obj.bumpHeight = value; } }, metadata: _metadata }, _bumpHeight_initializers, _bumpHeight_extraInitializers);
+            __esDecorate(null, null, __bumpSuperimpose_decorators, { kind: "field", name: "_bumpSuperimpose", static: false, private: false, access: { has: obj => "_bumpSuperimpose" in obj, get: obj => obj._bumpSuperimpose, set: (obj, value) => { obj._bumpSuperimpose = value; } }, metadata: _metadata }, __bumpSuperimpose_initializers, __bumpSuperimpose_extraInitializers);
+            __esDecorate(null, null, __fresnelSeparate_decorators, { kind: "field", name: "_fresnelSeparate", static: false, private: false, access: { has: obj => "_fresnelSeparate" in obj, get: obj => obj._fresnelSeparate, set: (obj, value) => { obj._fresnelSeparate = value; } }, metadata: _metadata }, __fresnelSeparate_initializers, __fresnelSeparate_extraInitializers);
+            __esDecorate(null, null, __bumpAffectsReflection_decorators, { kind: "field", name: "_bumpAffectsReflection", static: false, private: false, access: { has: obj => "_bumpAffectsReflection" in obj, get: obj => obj._bumpAffectsReflection, set: (obj, value) => { obj._bumpAffectsReflection = value; } }, metadata: _metadata }, __bumpAffectsReflection_initializers, __bumpAffectsReflection_extraInitializers);
+            __esDecorate(null, null, _waterColor_decorators, { kind: "field", name: "waterColor", static: false, private: false, access: { has: obj => "waterColor" in obj, get: obj => obj.waterColor, set: (obj, value) => { obj.waterColor = value; } }, metadata: _metadata }, _waterColor_initializers, _waterColor_extraInitializers);
+            __esDecorate(null, null, _colorBlendFactor_decorators, { kind: "field", name: "colorBlendFactor", static: false, private: false, access: { has: obj => "colorBlendFactor" in obj, get: obj => obj.colorBlendFactor, set: (obj, value) => { obj.colorBlendFactor = value; } }, metadata: _metadata }, _colorBlendFactor_initializers, _colorBlendFactor_extraInitializers);
+            __esDecorate(null, null, _waterColor2_decorators, { kind: "field", name: "waterColor2", static: false, private: false, access: { has: obj => "waterColor2" in obj, get: obj => obj.waterColor2, set: (obj, value) => { obj.waterColor2 = value; } }, metadata: _metadata }, _waterColor2_initializers, _waterColor2_extraInitializers);
+            __esDecorate(null, null, _colorBlendFactor2_decorators, { kind: "field", name: "colorBlendFactor2", static: false, private: false, access: { has: obj => "colorBlendFactor2" in obj, get: obj => obj.colorBlendFactor2, set: (obj, value) => { obj.colorBlendFactor2 = value; } }, metadata: _metadata }, _colorBlendFactor2_initializers, _colorBlendFactor2_extraInitializers);
+            __esDecorate(null, null, _waveLength_decorators, { kind: "field", name: "waveLength", static: false, private: false, access: { has: obj => "waveLength" in obj, get: obj => obj.waveLength, set: (obj, value) => { obj.waveLength = value; } }, metadata: _metadata }, _waveLength_initializers, _waveLength_extraInitializers);
+            __esDecorate(null, null, _waveSpeed_decorators, { kind: "field", name: "waveSpeed", static: false, private: false, access: { has: obj => "waveSpeed" in obj, get: obj => obj.waveSpeed, set: (obj, value) => { obj.waveSpeed = value; } }, metadata: _metadata }, _waveSpeed_initializers, _waveSpeed_extraInitializers);
+            __esDecorate(null, null, _waveCount_decorators, { kind: "field", name: "waveCount", static: false, private: false, access: { has: obj => "waveCount" in obj, get: obj => obj.waveCount, set: (obj, value) => { obj.waveCount = value; } }, metadata: _metadata }, _waveCount_initializers, _waveCount_extraInitializers);
+            __esDecorate(null, null, _disableClipPlane_decorators, { kind: "field", name: "disableClipPlane", static: false, private: false, access: { has: obj => "disableClipPlane" in obj, get: obj => obj.disableClipPlane, set: (obj, value) => { obj.disableClipPlane = value; } }, metadata: _metadata }, _disableClipPlane_initializers, _disableClipPlane_extraInitializers);
+            __esDecorate(null, null, __useWorldCoordinatesForWaveDeformation_decorators, { kind: "field", name: "_useWorldCoordinatesForWaveDeformation", static: false, private: false, access: { has: obj => "_useWorldCoordinatesForWaveDeformation" in obj, get: obj => obj._useWorldCoordinatesForWaveDeformation, set: (obj, value) => { obj._useWorldCoordinatesForWaveDeformation = value; } }, metadata: _metadata }, __useWorldCoordinatesForWaveDeformation_initializers, __useWorldCoordinatesForWaveDeformation_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { WaterMaterial };
 RegisterClass("BABYLON.WaterMaterial", WaterMaterial);
 //# sourceMappingURL=waterMaterial.js.map