@onerjs/materials 8.23.1

package/terrain/terrain.vertex.js

@@ -0,0 +1,96 @@
+// Do not edit.
+import { ShaderStore } from "@babylonjs/core/Engines/shaderStore.js";
+import "@babylonjs/core/Shaders/ShadersInclude/bonesDeclaration.js";
+import "@babylonjs/core/Shaders/ShadersInclude/bakedVertexAnimationDeclaration.js";
+import "@babylonjs/core/Shaders/ShadersInclude/instancesDeclaration.js";
+import "@babylonjs/core/Shaders/ShadersInclude/logDepthDeclaration.js";
+import "@babylonjs/core/Shaders/ShadersInclude/clipPlaneVertexDeclaration.js";
+import "@babylonjs/core/Shaders/ShadersInclude/fogVertexDeclaration.js";
+import "@babylonjs/core/Shaders/ShadersInclude/lightFragmentDeclaration.js";
+import "@babylonjs/core/Shaders/ShadersInclude/lightUboDeclaration.js";
+import "@babylonjs/core/Shaders/ShadersInclude/instancesVertex.js";
+import "@babylonjs/core/Shaders/ShadersInclude/bonesVertex.js";
+import "@babylonjs/core/Shaders/ShadersInclude/bakedVertexAnimation.js";
+import "@babylonjs/core/Shaders/ShadersInclude/clipPlaneVertex.js";
+import "@babylonjs/core/Shaders/ShadersInclude/logDepthVertex.js";
+import "@babylonjs/core/Shaders/ShadersInclude/fogVertex.js";
+import "@babylonjs/core/Shaders/ShadersInclude/shadowsVertex.js";
+import "@babylonjs/core/Shaders/ShadersInclude/vertexColorMixing.js";
+const name = "terrainVertexShader";
+const shader = `precision highp float;attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<instancesDeclaration>
+uniform mat4 view;uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vTextureUV;uniform mat4 textureMatrix;uniform vec2 vTextureInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+varying vec4 vColor;
+#endif
+#include<logDepthDeclaration>
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void) {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+#ifdef VERTEXCOLOR
+vec4 colorUpdated=color;
+#endif
+#include<instancesVertex>
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+vec4 worldPos=finalWorld*vec4(position,1.0);gl_Position=viewProjection*worldPos;vPositionW=vec3(worldPos);
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef DIFFUSE
+if (vTextureInfos.x==0.)
+{vTextureUV=vec2(textureMatrix*vec4(uv,1.0,0.0));}
+else
+{vTextureUV=vec2(textureMatrix*vec4(uv2,1.0,0.0));}
+#endif
+#include<clipPlaneVertex>
+#include<logDepthVertex>
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+#include<vertexColorMixing>
+#if defined(POINTSIZE) && !defined(WEBGPU)
+gl_PointSize=pointSize;
+#endif
+#define CUSTOM_VERTEX_MAIN_END
+}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStore[name]) {
+    ShaderStore.ShadersStore[name] = shader;
+}
+/** @internal */
+export const terrainVertexShader = { name, shader };
+//# sourceMappingURL=terrain.vertex.js.map

package/terrain/terrain.vertex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain.vertex.js","sourceRoot":"","sources":["../../../../dev/materials/src/terrain/terrain.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,+CAAiC;AACvD,oEAAsD;AACtD,mFAAqE;AACrE,wEAA0D;AAC1D,uEAAyD;AACzD,8EAAgE;AAChE,wEAA0D;AAC1D,4EAA8D;AAC9D,uEAAyD;AACzD,mEAAqD;AACrD,+DAAiD;AACjD,wEAA0D;AAC1D,mEAAqD;AACrD,kEAAoD;AACpD,6DAA+C;AAC/C,iEAAmD;AACnD,qEAAuD;AAEvD,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqEd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;IAClC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAC5C,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"core/Engines/shaderStore\";\nimport \"core/Shaders/ShadersInclude/bonesDeclaration\";\nimport \"core/Shaders/ShadersInclude/bakedVertexAnimationDeclaration\";\nimport \"core/Shaders/ShadersInclude/instancesDeclaration\";\nimport \"core/Shaders/ShadersInclude/logDepthDeclaration\";\nimport \"core/Shaders/ShadersInclude/clipPlaneVertexDeclaration\";\nimport \"core/Shaders/ShadersInclude/fogVertexDeclaration\";\nimport \"core/Shaders/ShadersInclude/lightFragmentDeclaration\";\nimport \"core/Shaders/ShadersInclude/lightUboDeclaration\";\nimport \"core/Shaders/ShadersInclude/instancesVertex\";\nimport \"core/Shaders/ShadersInclude/bonesVertex\";\nimport \"core/Shaders/ShadersInclude/bakedVertexAnimation\";\nimport \"core/Shaders/ShadersInclude/clipPlaneVertex\";\nimport \"core/Shaders/ShadersInclude/logDepthVertex\";\nimport \"core/Shaders/ShadersInclude/fogVertex\";\nimport \"core/Shaders/ShadersInclude/shadowsVertex\";\nimport \"core/Shaders/ShadersInclude/vertexColorMixing\";\n\nconst name = \"terrainVertexShader\";\nconst shader = `precision highp float;attribute vec3 position;\n#ifdef NORMAL\nattribute vec3 normal;\n#endif\n#ifdef UV1\nattribute vec2 uv;\n#endif\n#ifdef UV2\nattribute vec2 uv2;\n#endif\n#ifdef VERTEXCOLOR\nattribute vec4 color;\n#endif\n#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<instancesDeclaration>\nuniform mat4 view;uniform mat4 viewProjection;\n#ifdef DIFFUSE\nvarying vec2 vTextureUV;uniform mat4 textureMatrix;uniform vec2 vTextureInfos;\n#endif\n#ifdef POINTSIZE\nuniform float pointSize;\n#endif\nvarying vec3 vPositionW;\n#ifdef NORMAL\nvarying vec3 vNormalW;\n#endif\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nvarying vec4 vColor;\n#endif\n#include<logDepthDeclaration>\n#include<clipPlaneVertexDeclaration>\n#include<fogVertexDeclaration>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_VERTEX_MAIN_BEGIN\n#ifdef VERTEXCOLOR\nvec4 colorUpdated=color;\n#endif\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 worldPos=finalWorld*vec4(position,1.0);gl_Position=viewProjection*worldPos;vPositionW=vec3(worldPos);\n#ifdef NORMAL\nvNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));\n#endif\n#ifndef UV1\nvec2 uv=vec2(0.,0.);\n#endif\n#ifndef UV2\nvec2 uv2=vec2(0.,0.);\n#endif\n#ifdef DIFFUSE\nif (vTextureInfos.x==0.)\n{vTextureUV=vec2(textureMatrix*vec4(uv,1.0,0.0));}\nelse\n{vTextureUV=vec2(textureMatrix*vec4(uv2,1.0,0.0));}\n#endif\n#include<clipPlaneVertex>\n#include<logDepthVertex>\n#include<fogVertex>\n#include<shadowsVertex>[0..maxSimultaneousLights]\n#include<vertexColorMixing>\n#if defined(POINTSIZE) && !defined(WEBGPU)\ngl_PointSize=pointSize;\n#endif\n#define CUSTOM_VERTEX_MAIN_END\n}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStore[name]) {\n    ShaderStore.ShadersStore[name] = shader;\n}\n/** @internal */\nexport const terrainVertexShader = { name, shader };\n"]}

package/terrain/terrainMaterial.d.ts

@@ -0,0 +1,50 @@
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import type { IAnimatable } from "@babylonjs/core/Animations/animatable.interface.js";
+import type { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture.js";
+import type { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+import { PushMaterial } from "@babylonjs/core/Materials/pushMaterial.js";
+import type { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
+import type { SubMesh } from "@babylonjs/core/Meshes/subMesh.js";
+import type { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import { Scene } from "@babylonjs/core/scene.js";
+import "./terrain.fragment.js";
+import "./terrain.vertex.js";
+export declare class TerrainMaterial extends PushMaterial {
+    private _mixTexture;
+    mixTexture: BaseTexture;
+    private _diffuseTexture1;
+    diffuseTexture1: Texture;
+    private _diffuseTexture2;
+    diffuseTexture2: Texture;
+    private _diffuseTexture3;
+    diffuseTexture3: Texture;
+    private _bumpTexture1;
+    bumpTexture1: Texture;
+    private _bumpTexture2;
+    bumpTexture2: Texture;
+    private _bumpTexture3;
+    bumpTexture3: Texture;
+    diffuseColor: Color3;
+    specularColor: Color3;
+    specularPower: number;
+    private _disableLighting;
+    disableLighting: boolean;
+    private _maxSimultaneousLights;
+    maxSimultaneousLights: number;
+    constructor(name: string, scene?: Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): Nullable<BaseTexture>;
+    isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+    getAnimatables(): IAnimatable[];
+    getActiveTextures(): BaseTexture[];
+    hasTexture(texture: BaseTexture): boolean;
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): TerrainMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: Scene, rootUrl: string): TerrainMaterial;
+}

package/terrain/terrainMaterial.js

@@ -0,0 +1,445 @@
+import { __decorate } from "@babylonjs/core/tslib.es6.js";
+import { serializeAsTexture, serialize, expandToProperty, serializeAsColor3 } from "@babylonjs/core/Misc/decorators.js";
+import { SerializationHelper } from "@babylonjs/core/Misc/decorators.serialization.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { MaterialDefines } from "@babylonjs/core/Materials/materialDefines.js";
+import { PushMaterial } from "@babylonjs/core/Materials/pushMaterial.js";
+import { MaterialFlags } from "@babylonjs/core/Materials/materialFlags.js";
+import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
+import { Scene } from "@babylonjs/core/scene.js";
+import { RegisterClass } from "@babylonjs/core/Misc/typeStore.js";
+import "./terrain.fragment.js";
+import "./terrain.vertex.js";
+import { EffectFallbacks } from "@babylonjs/core/Materials/effectFallbacks.js";
+import { AddClipPlaneUniforms, BindClipPlane } from "@babylonjs/core/Materials/clipPlaneMaterialHelper.js";
+import { BindBonesParameters, BindFogParameters, BindLights, BindLogDepth, HandleFallbacksForShadows, PrepareAttributesForBones, PrepareAttributesForInstances, PrepareDefinesForAttributes, PrepareDefinesForFrameBoundValues, PrepareDefinesForLights, PrepareDefinesForMisc, PrepareUniformsAndSamplersList, } from "@babylonjs/core/Materials/materialHelper.functions.js";
+class TerrainMaterialDefines extends MaterialDefines {
+    constructor() {
+        super();
+        this.DIFFUSE = false;
+        this.BUMP = 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.SPECULARTERM = 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.IMAGEPROCESSINGPOSTPROCESS = false;
+        this.SKIPFINALCOLORCLAMP = false;
+        this.LOGARITHMICDEPTH = false;
+        this.AREALIGHTSUPPORTED = true;
+        this.AREALIGHTNOROUGHTNESS = true;
+        this.rebuild();
+    }
+}
+export class TerrainMaterial extends PushMaterial {
+    constructor(name, scene) {
+        super(name, scene);
+        this.diffuseColor = new Color3(1, 1, 1);
+        this.specularColor = new Color3(0, 0, 0);
+        this.specularPower = 64;
+        this._disableLighting = false;
+        this._maxSimultaneousLights = 4;
+    }
+    needAlphaBlending() {
+        return this.alpha < 1.0;
+    }
+    needAlphaTesting() {
+        return false;
+    }
+    getAlphaTestTexture() {
+        return null;
+    }
+    // Methods
+    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 TerrainMaterialDefines();
+        }
+        const defines = subMesh.materialDefines;
+        const scene = this.getScene();
+        if (this._isReadyForSubMesh(subMesh)) {
+            return true;
+        }
+        const engine = scene.getEngine();
+        // Textures
+        if (scene.texturesEnabled) {
+            if (!this.mixTexture || !this.mixTexture.isReady()) {
+                return false;
+            }
+            defines._needUVs = true;
+            if (MaterialFlags.DiffuseTextureEnabled) {
+                if (!this.diffuseTexture1 || !this.diffuseTexture1.isReady()) {
+                    return false;
+                }
+                if (!this.diffuseTexture2 || !this.diffuseTexture2.isReady()) {
+                    return false;
+                }
+                if (!this.diffuseTexture3 || !this.diffuseTexture3.isReady()) {
+                    return false;
+                }
+                defines.DIFFUSE = true;
+            }
+            if (this.bumpTexture1 && this.bumpTexture2 && this.bumpTexture3 && MaterialFlags.BumpTextureEnabled) {
+                if (!this.bumpTexture1.isReady()) {
+                    return false;
+                }
+                if (!this.bumpTexture2.isReady()) {
+                    return false;
+                }
+                if (!this.bumpTexture3.isReady()) {
+                    return false;
+                }
+                defines._needNormals = true;
+                defines.BUMP = true;
+            }
+        }
+        // Misc.
+        PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, this.needAlphaTestingForMesh(mesh), defines);
+        // Lights
+        defines._needNormals = PrepareDefinesForLights(scene, mesh, defines, false, this._maxSimultaneousLights, this._disableLighting);
+        // Values that need to be evaluated on every frame
+        PrepareDefinesForFrameBoundValues(scene, engine, this, defines, useInstances ? true : false);
+        // Attribs
+        PrepareDefinesForAttributes(mesh, defines, true, true);
+        // Get correct effect
+        if (defines.isDirty) {
+            defines.markAsProcessed();
+            scene.resetCachedMaterial();
+            // Fallbacks
+            const fallbacks = new EffectFallbacks();
+            if (defines.FOG) {
+                fallbacks.addFallback(1, "FOG");
+            }
+            HandleFallbacksForShadows(defines, fallbacks, this.maxSimultaneousLights);
+            if (defines.NUM_BONE_INFLUENCERS > 0) {
+                fallbacks.addCPUSkinningFallback(0, mesh);
+            }
+            defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
+            //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 = "terrain";
+            const join = defines.toString();
+            const uniforms = [
+                "world",
+                "view",
+                "viewProjection",
+                "vEyePosition",
+                "vLightsType",
+                "vDiffuseColor",
+                "vSpecularColor",
+                "vFogInfos",
+                "vFogColor",
+                "pointSize",
+                "vTextureInfos",
+                "mBones",
+                "textureMatrix",
+                "diffuse1Infos",
+                "diffuse2Infos",
+                "diffuse3Infos",
+            ];
+            const samplers = [
+                "textureSampler",
+                "diffuse1Sampler",
+                "diffuse2Sampler",
+                "diffuse3Sampler",
+                "bump1Sampler",
+                "bump2Sampler",
+                "bump3Sampler",
+                "logarithmicDepthConstant",
+                "areaLightsLTC1Sampler",
+                "areaLightsLTC2Sampler",
+            ];
+            const uniformBuffers = [];
+            AddClipPlaneUniforms(uniforms);
+            PrepareUniformsAndSamplersList({
+                uniformsNames: uniforms,
+                uniformBuffersNames: uniformBuffers,
+                samplers: samplers,
+                defines: defines,
+                maxSimultaneousLights: this.maxSimultaneousLights,
+            });
+            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 },
+            }, engine), defines, this._materialContext);
+        }
+        // Check if Area Lights have LTC texture.
+        if (defines["AREALIGHTUSED"]) {
+            for (let index = 0; index < mesh.lightSources.length; index++) {
+                if (!mesh.lightSources[index]._isReady()) {
+                    return false;
+                }
+            }
+        }
+        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) {
+            return;
+        }
+        this._activeEffect = effect;
+        // Matrices
+        this.bindOnlyWorldMatrix(world);
+        this._activeEffect.setMatrix("view", scene.getViewMatrix());
+        this._activeEffect.setMatrix("viewProjection", scene.getTransformMatrix());
+        // Bones
+        BindBonesParameters(mesh, this._activeEffect);
+        if (this._mustRebind(scene, effect, subMesh)) {
+            // Textures
+            if (this.mixTexture) {
+                this._activeEffect.setTexture("textureSampler", this._mixTexture);
+                this._activeEffect.setFloat2("vTextureInfos", this._mixTexture.coordinatesIndex, this._mixTexture.level);
+                this._activeEffect.setMatrix("textureMatrix", this._mixTexture.getTextureMatrix());
+                if (MaterialFlags.DiffuseTextureEnabled) {
+                    if (this._diffuseTexture1) {
+                        this._activeEffect.setTexture("diffuse1Sampler", this._diffuseTexture1);
+                        this._activeEffect.setFloat2("diffuse1Infos", this._diffuseTexture1.uScale, this._diffuseTexture1.vScale);
+                    }
+                    if (this._diffuseTexture2) {
+                        this._activeEffect.setTexture("diffuse2Sampler", this._diffuseTexture2);
+                        this._activeEffect.setFloat2("diffuse2Infos", this._diffuseTexture2.uScale, this._diffuseTexture2.vScale);
+                    }
+                    if (this._diffuseTexture3) {
+                        this._activeEffect.setTexture("diffuse3Sampler", this._diffuseTexture3);
+                        this._activeEffect.setFloat2("diffuse3Infos", this._diffuseTexture3.uScale, this._diffuseTexture3.vScale);
+                    }
+                }
+                if (MaterialFlags.BumpTextureEnabled && scene.getEngine().getCaps().standardDerivatives) {
+                    if (this._bumpTexture1) {
+                        this._activeEffect.setTexture("bump1Sampler", this._bumpTexture1);
+                    }
+                    if (this._bumpTexture2) {
+                        this._activeEffect.setTexture("bump2Sampler", this._bumpTexture2);
+                    }
+                    if (this._bumpTexture3) {
+                        this._activeEffect.setTexture("bump3Sampler", this._bumpTexture3);
+                    }
+                }
+            }
+            // 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);
+        this._afterBind(mesh, this._activeEffect, subMesh);
+    }
+    getAnimatables() {
+        const results = [];
+        if (this.mixTexture && this.mixTexture.animations && this.mixTexture.animations.length > 0) {
+            results.push(this.mixTexture);
+        }
+        return results;
+    }
+    getActiveTextures() {
+        const activeTextures = super.getActiveTextures();
+        if (this._mixTexture) {
+            activeTextures.push(this._mixTexture);
+        }
+        if (this._diffuseTexture1) {
+            activeTextures.push(this._diffuseTexture1);
+        }
+        if (this._diffuseTexture2) {
+            activeTextures.push(this._diffuseTexture2);
+        }
+        if (this._diffuseTexture3) {
+            activeTextures.push(this._diffuseTexture3);
+        }
+        if (this._bumpTexture1) {
+            activeTextures.push(this._bumpTexture1);
+        }
+        if (this._bumpTexture2) {
+            activeTextures.push(this._bumpTexture2);
+        }
+        if (this._bumpTexture3) {
+            activeTextures.push(this._bumpTexture3);
+        }
+        return activeTextures;
+    }
+    hasTexture(texture) {
+        if (super.hasTexture(texture)) {
+            return true;
+        }
+        if (this._mixTexture === texture) {
+            return true;
+        }
+        if (this._diffuseTexture1 === texture) {
+            return true;
+        }
+        if (this._diffuseTexture2 === texture) {
+            return true;
+        }
+        if (this._diffuseTexture3 === texture) {
+            return true;
+        }
+        if (this._bumpTexture1 === texture) {
+            return true;
+        }
+        if (this._bumpTexture2 === texture) {
+            return true;
+        }
+        if (this._bumpTexture3 === texture) {
+            return true;
+        }
+        return false;
+    }
+    dispose(forceDisposeEffect) {
+        if (this.mixTexture) {
+            this.mixTexture.dispose();
+        }
+        super.dispose(forceDisposeEffect);
+    }
+    clone(name) {
+        return SerializationHelper.Clone(() => new TerrainMaterial(name, this.getScene()), this);
+    }
+    serialize() {
+        const serializationObject = super.serialize();
+        serializationObject.customType = "BABYLON.TerrainMaterial";
+        return serializationObject;
+    }
+    getClassName() {
+        return "TerrainMaterial";
+    }
+    // Statics
+    static Parse(source, scene, rootUrl) {
+        return SerializationHelper.Parse(() => new TerrainMaterial(source.name, scene), source, scene, rootUrl);
+    }
+}
+__decorate([
+    serializeAsTexture("mixTexture")
+], TerrainMaterial.prototype, "_mixTexture", void 0);
+__decorate([
+    expandToProperty("_markAllSubMeshesAsTexturesDirty")
+], TerrainMaterial.prototype, "mixTexture", void 0);
+__decorate([
+    serializeAsTexture("diffuseTexture1")
+], TerrainMaterial.prototype, "_diffuseTexture1", void 0);
+__decorate([
+    expandToProperty("_markAllSubMeshesAsTexturesDirty")
+], TerrainMaterial.prototype, "diffuseTexture1", void 0);
+__decorate([
+    serializeAsTexture("diffuseTexture2")
+], TerrainMaterial.prototype, "_diffuseTexture2", void 0);
+__decorate([
+    expandToProperty("_markAllSubMeshesAsTexturesDirty")
+], TerrainMaterial.prototype, "diffuseTexture2", void 0);
+__decorate([
+    serializeAsTexture("diffuseTexture3")
+], TerrainMaterial.prototype, "_diffuseTexture3", void 0);
+__decorate([
+    expandToProperty("_markAllSubMeshesAsTexturesDirty")
+], TerrainMaterial.prototype, "diffuseTexture3", void 0);
+__decorate([
+    serializeAsTexture("bumpTexture1")
+], TerrainMaterial.prototype, "_bumpTexture1", void 0);
+__decorate([
+    expandToProperty("_markAllSubMeshesAsTexturesDirty")
+], TerrainMaterial.prototype, "bumpTexture1", void 0);
+__decorate([
+    serializeAsTexture("bumpTexture2")
+], TerrainMaterial.prototype, "_bumpTexture2", void 0);
+__decorate([
+    expandToProperty("_markAllSubMeshesAsTexturesDirty")
+], TerrainMaterial.prototype, "bumpTexture2", void 0);
+__decorate([
+    serializeAsTexture("bumpTexture3")
+], TerrainMaterial.prototype, "_bumpTexture3", void 0);
+__decorate([
+    expandToProperty("_markAllSubMeshesAsTexturesDirty")
+], TerrainMaterial.prototype, "bumpTexture3", void 0);
+__decorate([
+    serializeAsColor3()
+], TerrainMaterial.prototype, "diffuseColor", void 0);
+__decorate([
+    serializeAsColor3()
+], TerrainMaterial.prototype, "specularColor", void 0);
+__decorate([
+    serialize()
+], TerrainMaterial.prototype, "specularPower", void 0);
+__decorate([
+    serialize("disableLighting")
+], TerrainMaterial.prototype, "_disableLighting", void 0);
+__decorate([
+    expandToProperty("_markAllSubMeshesAsLightsDirty")
+], TerrainMaterial.prototype, "disableLighting", void 0);
+__decorate([
+    serialize("maxSimultaneousLights")
+], TerrainMaterial.prototype, "_maxSimultaneousLights", void 0);
+__decorate([
+    expandToProperty("_markAllSubMeshesAsLightsDirty")
+], TerrainMaterial.prototype, "maxSimultaneousLights", void 0);
+RegisterClass("BABYLON.TerrainMaterial", TerrainMaterial);
+//# sourceMappingURL=terrainMaterial.js.map