@babylonjs/materials 5.20.0 → 5.22.1

package/water/waterMaterial.js

@@ -1,4 +1,4 @@
-import { __decorate, __extends } from "tslib";
+import { __decorate } from "@babylonjs/core/tslib.es6.js";
 import { serializeAsVector2, serializeAsTexture, serialize, expandToProperty, serializeAsColor3, SerializationHelper } from "@babylonjs/core/Misc/decorators.js";
 import { Matrix, Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
 import { Color3 } from "@babylonjs/core/Maths/math.color.js";
@@ -18,233 +18,208 @@ import "./water.fragment.js";
 import "./water.vertex.js";
 import { EffectFallbacks } from "@babylonjs/core/Materials/effectFallbacks.js";
 import { CreateGround } from "@babylonjs/core/Meshes/Builders/groundBuilder.js";
-var WaterMaterialDefines = /** @class */ (function (_super) {
-    __extends(WaterMaterialDefines, _super);
-    function WaterMaterialDefines() {
-        var _this = _super.call(this) || this;
-        _this.BUMP = false;
-        _this.REFLECTION = false;
-        _this.CLIPPLANE = false;
-        _this.CLIPPLANE2 = false;
-        _this.CLIPPLANE3 = false;
-        _this.CLIPPLANE4 = false;
-        _this.CLIPPLANE5 = false;
-        _this.CLIPPLANE6 = false;
-        _this.ALPHATEST = false;
-        _this.DEPTHPREPASS = false;
-        _this.POINTSIZE = false;
-        _this.FOG = false;
-        _this.NORMAL = false;
-        _this.UV1 = false;
-        _this.UV2 = false;
-        _this.VERTEXCOLOR = false;
-        _this.VERTEXALPHA = false;
-        _this.NUM_BONE_INFLUENCERS = 0;
-        _this.BonesPerMesh = 0;
-        _this.INSTANCES = false;
-        _this.INSTANCESCOLOR = false;
-        _this.SPECULARTERM = false;
-        _this.LOGARITHMICDEPTH = false;
-        _this.USE_REVERSE_DEPTHBUFFER = false;
-        _this.FRESNELSEPARATE = false;
-        _this.BUMPSUPERIMPOSE = false;
-        _this.BUMPAFFECTSREFLECTION = false;
-        _this.IMAGEPROCESSING = false;
-        _this.VIGNETTE = false;
-        _this.VIGNETTEBLENDMODEMULTIPLY = false;
-        _this.VIGNETTEBLENDMODEOPAQUE = false;
-        _this.TONEMAPPING = false;
-        _this.TONEMAPPING_ACES = false;
-        _this.CONTRAST = false;
-        _this.EXPOSURE = false;
-        _this.COLORCURVES = false;
-        _this.COLORGRADING = false;
-        _this.COLORGRADING3D = false;
-        _this.SAMPLER3DGREENDEPTH = false;
-        _this.SAMPLER3DBGRMAP = false;
-        _this.IMAGEPROCESSINGPOSTPROCESS = false;
-        _this.SKIPFINALCOLORCLAMP = false;
-        _this.rebuild();
-        return _this;
+class WaterMaterialDefines extends MaterialDefines {
+    constructor() {
+        super();
+        this.BUMP = false;
+        this.REFLECTION = false;
+        this.CLIPPLANE = false;
+        this.CLIPPLANE2 = false;
+        this.CLIPPLANE3 = false;
+        this.CLIPPLANE4 = false;
+        this.CLIPPLANE5 = false;
+        this.CLIPPLANE6 = false;
+        this.ALPHATEST = false;
+        this.DEPTHPREPASS = false;
+        this.POINTSIZE = false;
+        this.FOG = false;
+        this.NORMAL = false;
+        this.UV1 = false;
+        this.UV2 = false;
+        this.VERTEXCOLOR = false;
+        this.VERTEXALPHA = false;
+        this.NUM_BONE_INFLUENCERS = 0;
+        this.BonesPerMesh = 0;
+        this.INSTANCES = false;
+        this.INSTANCESCOLOR = false;
+        this.SPECULARTERM = false;
+        this.LOGARITHMICDEPTH = false;
+        this.USE_REVERSE_DEPTHBUFFER = false;
+        this.FRESNELSEPARATE = false;
+        this.BUMPSUPERIMPOSE = false;
+        this.BUMPAFFECTSREFLECTION = false;
+        this.IMAGEPROCESSING = false;
+        this.VIGNETTE = false;
+        this.VIGNETTEBLENDMODEMULTIPLY = false;
+        this.VIGNETTEBLENDMODEOPAQUE = false;
+        this.TONEMAPPING = false;
+        this.TONEMAPPING_ACES = false;
+        this.CONTRAST = false;
+        this.EXPOSURE = false;
+        this.COLORCURVES = false;
+        this.COLORGRADING = false;
+        this.COLORGRADING3D = false;
+        this.SAMPLER3DGREENDEPTH = false;
+        this.SAMPLER3DBGRMAP = false;
+        this.DITHER = false;
+        this.IMAGEPROCESSINGPOSTPROCESS = false;
+        this.SKIPFINALCOLORCLAMP = false;
+        this.rebuild();
     }
-    return WaterMaterialDefines;
-}(MaterialDefines));
-var WaterMaterial = /** @class */ (function (_super) {
-    __extends(WaterMaterial, _super);
+}
+export class WaterMaterial extends PushMaterial {
     /**
      * Constructor
      * @param name
      * @param scene
      * @param renderTargetSize
      */
-    function WaterMaterial(name, scene, renderTargetSize) {
-        if (renderTargetSize === void 0) { renderTargetSize = new Vector2(512, 512); }
-        var _this = _super.call(this, name, scene) || this;
-        _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;
+    constructor(name, scene, renderTargetSize = new Vector2(512, 512)) {
+        super(name, scene);
+        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;
+        this.windForce = 6;
         /**
          * Defines the direction of the wind in the plane (X, Z).
          */
-        _this.windDirection = new Vector2(0, 1);
+        this.windDirection = new Vector2(0, 1);
         /**
          * Defines the height of the waves.
          */
-        _this.waveHeight = 0.4;
+        this.waveHeight = 0.4;
         /**
          * Defines the bump height related to the bump map.
          */
-        _this.bumpHeight = 0.4;
+        this.bumpHeight = 0.4;
         /**
          * Defines wether or not: to add a smaller moving bump to less steady waves.
          */
-        _this._bumpSuperimpose = false;
+        this._bumpSuperimpose = false;
         /**
          * Defines wether or not color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
          */
-        _this._fresnelSeparate = false;
+        this._fresnelSeparate = false;
         /**
          * Defines wether or not bump Wwves modify the reflection.
          */
-        _this._bumpAffectsReflection = false;
+        this._bumpAffectsReflection = false;
         /**
          * Defines the water color blended with the refraction (near).
          */
-        _this.waterColor = new Color3(0.1, 0.1, 0.6);
+        this.waterColor = new Color3(0.1, 0.1, 0.6);
         /**
          * Defines the blend factor related to the water color.
          */
-        _this.colorBlendFactor = 0.2;
+        this.colorBlendFactor = 0.2;
         /**
          * Defines the water color blended with the reflection (far).
          */
-        _this.waterColor2 = new Color3(0.1, 0.1, 0.6);
+        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;
+        this.colorBlendFactor2 = 0.2;
         /**
          * Defines the maximum length of a wave.
          */
-        _this.waveLength = 0.1;
+        this.waveLength = 0.1;
         /**
          * Defines the waves speed.
          */
-        _this.waveSpeed = 1.0;
+        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;
+        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;
-        _this._renderTargets = new SmartArray(16);
+        this.disableClipPlane = false;
+        this._renderTargets = new SmartArray(16);
         /*
          * Private members
          */
-        _this._mesh = null;
-        _this._reflectionTransform = Matrix.Zero();
-        _this._lastTime = 0;
-        _this._lastDeltaTime = 0;
-        _this._createRenderTargets(_this.getScene(), renderTargetSize);
+        this._mesh = null;
+        this._reflectionTransform = Matrix.Zero();
+        this._lastTime = 0;
+        this._lastDeltaTime = 0;
+        this._createRenderTargets(this.getScene(), renderTargetSize);
         // Create render targets
-        _this.getRenderTargetTextures = function () {
-            _this._renderTargets.reset();
-            _this._renderTargets.push(_this._reflectionRTT);
-            _this._renderTargets.push(_this._refractionRTT);
-            return _this._renderTargets;
+        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(function () {
-                _this._markAllSubMeshesAsImageProcessingDirty();
+        this._imageProcessingConfiguration = this.getScene().imageProcessingConfiguration;
+        if (this._imageProcessingConfiguration) {
+            this._imageProcessingObserver = this._imageProcessingConfiguration.onUpdateParameters.add(() => {
+                this._markAllSubMeshesAsImageProcessingDirty();
             });
         }
-        return _this;
     }
-    Object.defineProperty(WaterMaterial.prototype, "hasRenderTargetTextures", {
-        /**
-         * Gets a boolean indicating that current material needs to register RTT
-         */
-        get: function () {
-            return true;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(WaterMaterial.prototype, "useLogarithmicDepth", {
-        get: function () {
-            return this._useLogarithmicDepth;
-        },
-        set: function (value) {
-            this._useLogarithmicDepth = value && this.getScene().getEngine().getCaps().fragmentDepthSupported;
-            this._markAllSubMeshesAsMiscDirty();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(WaterMaterial.prototype, "refractionTexture", {
-        // Get / Set
-        get: function () {
-            return this._refractionRTT;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(WaterMaterial.prototype, "reflectionTexture", {
-        get: function () {
-            return this._reflectionRTT;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    /**
+     * Gets a boolean indicating that current material needs to register RTT
+     */
+    get hasRenderTargetTextures() {
+        return true;
+    }
+    get useLogarithmicDepth() {
+        return this._useLogarithmicDepth;
+    }
+    set useLogarithmicDepth(value) {
+        this._useLogarithmicDepth = value && this.getScene().getEngine().getCaps().fragmentDepthSupported;
+        this._markAllSubMeshesAsMiscDirty();
+    }
+    // Get / Set
+    get refractionTexture() {
+        return this._refractionRTT;
+    }
+    get reflectionTexture() {
+        return this._reflectionRTT;
+    }
     // Methods
-    WaterMaterial.prototype.addToRenderList = function (node) {
+    addToRenderList(node) {
         if (this._refractionRTT && this._refractionRTT.renderList) {
             this._refractionRTT.renderList.push(node);
         }
         if (this._reflectionRTT && this._reflectionRTT.renderList) {
             this._reflectionRTT.renderList.push(node);
         }
-    };
-    WaterMaterial.prototype.enableRenderTargets = function (enable) {
-        var refreshRate = enable ? 1 : 0;
+    }
+    enableRenderTargets(enable) {
+        const refreshRate = enable ? 1 : 0;
         if (this._refractionRTT) {
             this._refractionRTT.refreshRate = refreshRate;
         }
         if (this._reflectionRTT) {
             this._reflectionRTT.refreshRate = refreshRate;
         }
-    };
-    WaterMaterial.prototype.getRenderList = function () {
+    }
+    getRenderList() {
         return this._refractionRTT ? this._refractionRTT.renderList : [];
-    };
-    Object.defineProperty(WaterMaterial.prototype, "renderTargetsEnabled", {
-        get: function () {
-            return !(this._refractionRTT && this._refractionRTT.refreshRate === 0);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    WaterMaterial.prototype.needAlphaBlending = function () {
+    }
+    get renderTargetsEnabled() {
+        return !(this._refractionRTT && this._refractionRTT.refreshRate === 0);
+    }
+    needAlphaBlending() {
         return this.alpha < 1.0;
-    };
-    WaterMaterial.prototype.needAlphaTesting = function () {
+    }
+    needAlphaTesting() {
         return false;
-    };
-    WaterMaterial.prototype.getAlphaTestTexture = function () {
+    }
+    getAlphaTestTexture() {
         return null;
-    };
-    WaterMaterial.prototype.isReadyForSubMesh = function (mesh, subMesh, useInstances) {
+    }
+    isReadyForSubMesh(mesh, subMesh, useInstances) {
         if (this.isFrozen) {
             if (subMesh.effect && subMesh.effect._wasPreviouslyReady && subMesh.effect._wasPreviouslyUsingInstances === useInstances) {
                 return true;
@@ -253,12 +228,12 @@ var WaterMaterial = /** @class */ (function (_super) {
         if (!subMesh.materialDefines) {
             subMesh.materialDefines = new WaterMaterialDefines();
         }
-        var defines = subMesh.materialDefines;
-        var scene = this.getScene();
+        const defines = subMesh.materialDefines;
+        const scene = this.getScene();
         if (this._isReadyForSubMesh(subMesh)) {
             return true;
         }
-        var engine = scene.getEngine();
+        const engine = scene.getEngine();
         // Textures
         if (defines._areTexturesDirty) {
             defines._needUVs = false;
@@ -306,7 +281,7 @@ var WaterMaterial = /** @class */ (function (_super) {
         // Configure this
         this._mesh = mesh;
         if (this._waitingRenderList) {
-            for (var i = 0; i < this._waitingRenderList.length; i++) {
+            for (let i = 0; i < this._waitingRenderList.length; i++) {
                 this.addToRenderList(scene.getNodeById(this._waitingRenderList[i]));
             }
             this._waitingRenderList = null;
@@ -316,7 +291,7 @@ var WaterMaterial = /** @class */ (function (_super) {
             defines.markAsProcessed();
             scene.resetCachedMaterial();
             // Fallbacks
-            var fallbacks = new EffectFallbacks();
+            const fallbacks = new EffectFallbacks();
             if (defines.FOG) {
                 fallbacks.addFallback(1, "FOG");
             }
@@ -328,7 +303,7 @@ var WaterMaterial = /** @class */ (function (_super) {
                 fallbacks.addCPUSkinningFallback(0, mesh);
             }
             //Attributes
-            var attribs = [VertexBuffer.PositionKind];
+            const attribs = [VertexBuffer.PositionKind];
             if (defines.NORMAL) {
                 attribs.push(VertexBuffer.NormalKind);
             }
@@ -344,9 +319,9 @@ var WaterMaterial = /** @class */ (function (_super) {
             MaterialHelper.PrepareAttributesForBones(attribs, mesh, defines, fallbacks);
             MaterialHelper.PrepareAttributesForInstances(attribs, defines);
             // Legacy browser patch
-            var shaderName = "water";
-            var join = defines.toString();
-            var uniforms = [
+            const shaderName = "water";
+            const join = defines.toString();
+            const uniforms = [
                 "world",
                 "view",
                 "viewProjection",
@@ -383,13 +358,13 @@ var WaterMaterial = /** @class */ (function (_super) {
                 "waveSpeed",
                 "waveCount",
             ];
-            var samplers = [
+            const samplers = [
                 "normalSampler",
                 // Water
                 "refractionSampler",
                 "reflectionSampler",
             ];
-            var uniformBuffers = new Array();
+            const uniformBuffers = new Array();
             if (ImageProcessingConfiguration) {
                 ImageProcessingConfiguration.PrepareUniforms(uniforms, defines);
                 ImageProcessingConfiguration.PrepareSamplers(samplers, defines);
@@ -420,14 +395,14 @@ var WaterMaterial = /** @class */ (function (_super) {
         subMesh.effect._wasPreviouslyReady = true;
         subMesh.effect._wasPreviouslyUsingInstances = !!useInstances;
         return true;
-    };
-    WaterMaterial.prototype.bindForSubMesh = function (world, mesh, subMesh) {
-        var scene = this.getScene();
-        var defines = subMesh.materialDefines;
+    }
+    bindForSubMesh(world, mesh, subMesh) {
+        const scene = this.getScene();
+        const defines = subMesh.materialDefines;
         if (!defines) {
             return;
         }
-        var effect = subMesh.effect;
+        const effect = subMesh.effect;
         if (!effect || !this._mesh) {
             return;
         }
@@ -472,9 +447,9 @@ var WaterMaterial = /** @class */ (function (_super) {
             this._activeEffect.setTexture("refractionSampler", this._refractionRTT);
             this._activeEffect.setTexture("reflectionSampler", this._reflectionRTT);
         }
-        var wrvp = this._mesh.getWorldMatrix().multiply(this._reflectionTransform).multiply(scene.getProjectionMatrix());
+        const wrvp = this._mesh.getWorldMatrix().multiply(this._reflectionTransform).multiply(scene.getProjectionMatrix());
         // Add delta time. Prevent adding delta time if it hasn't changed.
-        var deltaTime = scene.getEngine().getDeltaTime();
+        const deltaTime = scene.getEngine().getDeltaTime();
         if (deltaTime !== this._lastDeltaTime) {
             this._lastDeltaTime = deltaTime;
             this._lastTime += this._lastDeltaTime;
@@ -497,9 +472,8 @@ var WaterMaterial = /** @class */ (function (_super) {
             this._imageProcessingConfiguration.bind(this._activeEffect);
         }
         this._afterBind(mesh, this._activeEffect);
-    };
-    WaterMaterial.prototype._createRenderTargets = function (scene, renderTargetSize) {
-        var _this = this;
+    }
+    _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;
@@ -509,53 +483,53 @@ var WaterMaterial = /** @class */ (function (_super) {
         this._reflectionRTT.wrapU = Constants.TEXTURE_MIRROR_ADDRESSMODE;
         this._reflectionRTT.wrapV = Constants.TEXTURE_MIRROR_ADDRESSMODE;
         this._reflectionRTT.ignoreCameraViewport = true;
-        var isVisible;
-        var clipPlane = null;
-        var savedViewMatrix;
-        var mirrorMatrix = Matrix.Zero();
-        this._refractionRTT.onBeforeRender = function () {
-            if (_this._mesh) {
-                isVisible = _this._mesh.isVisible;
-                _this._mesh.isVisible = false;
+        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) {
+            if (!this.disableClipPlane) {
                 clipPlane = scene.clipPlane;
-                var positiony = _this._mesh ? _this._mesh.position.y : 0.0;
+                const positiony = this._mesh ? this._mesh.position.y : 0.0;
                 scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony + 0.05, 0), new Vector3(0, 1, 0));
             }
         };
-        this._refractionRTT.onAfterRender = function () {
-            if (_this._mesh) {
-                _this._mesh.isVisible = isVisible;
+        this._refractionRTT.onAfterRender = () => {
+            if (this._mesh) {
+                this._mesh.isVisible = isVisible;
             }
             // Clip plane
-            if (!_this.disableClipPlane) {
+            if (!this.disableClipPlane) {
                 scene.clipPlane = clipPlane;
             }
         };
-        this._reflectionRTT.onBeforeRender = function () {
-            if (_this._mesh) {
-                isVisible = _this._mesh.isVisible;
-                _this._mesh.isVisible = false;
+        this._reflectionRTT.onBeforeRender = () => {
+            if (this._mesh) {
+                isVisible = this._mesh.isVisible;
+                this._mesh.isVisible = false;
             }
             // Clip plane
-            if (!_this.disableClipPlane) {
+            if (!this.disableClipPlane) {
                 clipPlane = scene.clipPlane;
-                var positiony = _this._mesh ? _this._mesh.position.y : 0.0;
+                const positiony = this._mesh ? this._mesh.position.y : 0.0;
                 scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony - 0.05, 0), new Vector3(0, -1, 0));
                 Matrix.ReflectionToRef(scene.clipPlane, mirrorMatrix);
             }
             // Transform
             savedViewMatrix = scene.getViewMatrix();
-            mirrorMatrix.multiplyToRef(savedViewMatrix, _this._reflectionTransform);
-            scene.setTransformMatrix(_this._reflectionTransform, scene.getProjectionMatrix());
+            mirrorMatrix.multiplyToRef(savedViewMatrix, this._reflectionTransform);
+            scene.setTransformMatrix(this._reflectionTransform, scene.getProjectionMatrix());
             scene.getEngine().cullBackFaces = false;
             scene._mirroredCameraPosition = Vector3.TransformCoordinates(scene.activeCamera.position, mirrorMatrix);
         };
-        this._reflectionRTT.onAfterRender = function () {
-            if (_this._mesh) {
-                _this._mesh.isVisible = isVisible;
+        this._reflectionRTT.onAfterRender = () => {
+            if (this._mesh) {
+                this._mesh.isVisible = isVisible;
             }
             // Clip plane
             scene.clipPlane = clipPlane;
@@ -564,9 +538,9 @@ var WaterMaterial = /** @class */ (function (_super) {
             scene.getEngine().cullBackFaces = null;
             scene._mirroredCameraPosition = null;
         };
-    };
-    WaterMaterial.prototype.getAnimatables = function () {
-        var results = [];
+    }
+    getAnimatables() {
+        const results = [];
         if (this.bumpTexture && this.bumpTexture.animations && this.bumpTexture.animations.length > 0) {
             results.push(this.bumpTexture);
         }
@@ -577,28 +551,28 @@ var WaterMaterial = /** @class */ (function (_super) {
             results.push(this._refractionRTT);
         }
         return results;
-    };
-    WaterMaterial.prototype.getActiveTextures = function () {
-        var activeTextures = _super.prototype.getActiveTextures.call(this);
+    }
+    getActiveTextures() {
+        const activeTextures = super.getActiveTextures();
         if (this._bumpTexture) {
             activeTextures.push(this._bumpTexture);
         }
         return activeTextures;
-    };
-    WaterMaterial.prototype.hasTexture = function (texture) {
-        if (_super.prototype.hasTexture.call(this, texture)) {
+    }
+    hasTexture(texture) {
+        if (super.hasTexture(texture)) {
             return true;
         }
         if (this._bumpTexture === texture) {
             return true;
         }
         return false;
-    };
-    WaterMaterial.prototype.dispose = function (forceDisposeEffect) {
+    }
+    dispose(forceDisposeEffect) {
         if (this.bumpTexture) {
             this.bumpTexture.dispose();
         }
-        var index = this.getScene().customRenderTargets.indexOf(this._refractionRTT);
+        let index = this.getScene().customRenderTargets.indexOf(this._refractionRTT);
         if (index != -1) {
             this.getScene().customRenderTargets.splice(index, 1);
         }
@@ -617,122 +591,119 @@ var WaterMaterial = /** @class */ (function (_super) {
         if (this._imageProcessingConfiguration && this._imageProcessingObserver) {
             this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver);
         }
-        _super.prototype.dispose.call(this, forceDisposeEffect);
-    };
-    WaterMaterial.prototype.clone = function (name) {
-        var _this = this;
-        return SerializationHelper.Clone(function () { return new WaterMaterial(name, _this.getScene()); }, this);
-    };
-    WaterMaterial.prototype.serialize = function () {
-        var serializationObject = _super.prototype.serialize.call(this);
+        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 (var i = 0; i < this._refractionRTT.renderList.length; i++) {
+            for (let i = 0; i < this._refractionRTT.renderList.length; i++) {
                 serializationObject.renderList.push(this._refractionRTT.renderList[i].id);
             }
         }
         return serializationObject;
-    };
-    WaterMaterial.prototype.getClassName = function () {
+    }
+    getClassName() {
         return "WaterMaterial";
-    };
+    }
     // Statics
-    WaterMaterial.Parse = function (source, scene, rootUrl) {
-        var mat = SerializationHelper.Parse(function () { return new WaterMaterial(source.name, scene); }, source, scene, rootUrl);
+    static Parse(source, scene, rootUrl) {
+        const mat = SerializationHelper.Parse(() => new WaterMaterial(source.name, scene), source, scene, rootUrl);
         mat._waitingRenderList = source.renderList;
         return mat;
-    };
-    WaterMaterial.CreateDefaultMesh = function (name, scene) {
-        var mesh = CreateGround(name, { width: 512, height: 512, subdivisions: 32, updatable: false }, scene);
+    }
+    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()
-    ], WaterMaterial.prototype, "useLogarithmicDepth", null);
-    return WaterMaterial;
-}(PushMaterial));
-export { WaterMaterial };
+    }
+}
+__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()
+], WaterMaterial.prototype, "useLogarithmicDepth", null);
 RegisterClass("BABYLON.WaterMaterial", WaterMaterial);
 //# sourceMappingURL=waterMaterial.js.map