Add first work for mat libs

Tools/Gulp/config.json

@@ -1480,6 +1480,16 @@
                 "webpack": "../../materialsLibrary/webpack.config.js",
                 "bundle": "true",
                 "babylonIncluded": false,
+                "useOutputForDebugging": true,
+                "preventLoadLibrary": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.cellMaterial.min.js",
+                "webpack": "../../materialsLibrary/legacy/webpack.cell.config.js",
+                "bundle": "true",
+                "babylonIncluded": false,
                 "useOutputForDebugging": true
             }
         ],
@@ -1488,15 +1498,15 @@
             "distOutputDirectory": "/materialsLibrary/",
             "dtsBundle": {
                 "name": "babylonjs-materials",
-                "main": "../../dist/preview release/materials/build/index.d.ts",
+                "main": "../../dist/preview release/materialsLibrary/build/src/index.d.ts",
                 "out": "../babylon.materials.module.d.ts",
-                "baseDir": "../../dist/preview release/materials/build/",
+                "baseDir": "../../dist/preview release/materialsLibrary/build/",
                 "headerText": "BabylonJS Materials"
             },
             "processDeclaration": {
                 "filename": "babylon.materials.module.d.ts",
                 "packageName": "babylonjs-materials",
-                "moduleName": "BABYLON.MATERIALS",
+                "moduleName": "BABYLON",
                 "importsToRemove": [],
                 "classMap": {
                     "babylonjs": "BABYLON",
@@ -1542,7 +1552,7 @@
             "distOutputDirectory": "/postProcessesLibrary/",
             "dtsBundle": {
                 "name": "babylonjs-postProcessLibrary",
-                "main": "../../dist/preview release/postProcessesLibrary/build/index.d.ts",
+                "main": "../../dist/preview release/postProcessesLibrary/build/src/index.d.ts",
                 "out": "../babylon.postProcesses.module.d.ts",
                 "baseDir": "../../dist/preview release/postProcessesLibrary/build/",
                 "headerText": "BabylonJS Postprocess library"

Tools/Gulp/gulpfile.js

@@ -695,7 +695,9 @@ var buildExternalLibrary = function(library, settings, watch) {
                     buildEvent.on("end", function() {
                         if (settings.build.dtsBundle) {
                             dtsBundle.bundle(settings.build.dtsBundle);
-                        } if (settings.build.processDeclaration) {
+                        }
+
+                        if (settings.build.processDeclaration) {
                             let fileLocation = path.join(outputDirectory, settings.build.processDeclaration.filename);
                             fs.readFile(fileLocation, function(err, data) {
                                 if (err) throw err;

dist/preview release/materials/babylon.materials.module.d.ts

@@ -0,0 +1,564 @@
+/*BabylonJS Materials*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/cell";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/custom";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/fire";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/fur";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/gradient";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/grid";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/lava";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/mix";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/normal";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/shadowOnly";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/simple";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/sky";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/terrain";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/triPlanar";
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/water";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/cell/cellMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/custom/customMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/fire/fireMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/fur/furMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/gradient/gradientMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/grid/gridMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/lava/lavaMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/mix/mixMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/normal/normalMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/shadowOnly/shadowOnlyMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/simple/simpleMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/sky/skyMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/terrain/terrainMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/triPlanar/triPlanarMaterial";
+
+export * from "babylonjs-materials/--/--/materialsLibrary/build/src/water/waterMaterial";
+
+import { PushMaterial, BaseTexture, Scene, Color3, AbstractMesh, Nullable, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class CellMaterial extends PushMaterial {
+    diffuseTexture: BaseTexture;
+    diffuseColor: Color3;
+    _computeHighLevel: boolean;
+    computeHighLevel: boolean;
+    disableLighting: boolean;
+    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;
+    getClassName(): string;
+    clone(name: string): CellMaterial;
+    serialize(): any;
+    static Parse(source: any, scene: Scene, rootUrl: string): CellMaterial;
+}
+
+import { StandardMaterial, Texture, Mesh, Effect, StandardMaterialDefines, Scene } from "babylonjs";
+export declare class CustomShaderStructure {
+    FragmentStore: string;
+    VertexStore: string;
+    constructor();
+}
+export declare class ShaderSpecialParts {
+    constructor();
+    Fragment_Begin: string;
+    Fragment_Definitions: string;
+    Fragment_MainBegin: string;
+    Fragment_Custom_Diffuse: string;
+    Fragment_Custom_Alpha: string;
+    Fragment_Before_FragColor: string;
+    Vertex_Begin: string;
+    Vertex_Definitions: string;
+    Vertex_MainBegin: string;
+    Vertex_Before_PositionUpdated: string;
+    Vertex_Before_NormalUpdated: string;
+}
+export declare class CustomMaterial extends StandardMaterial {
+    static ShaderIndexer: number;
+    CustomParts: ShaderSpecialParts;
+    _isCreatedShader: boolean;
+    _createdShaderName: string;
+    _customUniform: string[];
+    _newUniforms: string[];
+    _newUniformInstances: any[];
+    _newSamplerInstances: Texture[];
+    FragmentShader: string;
+    VertexShader: string;
+    AttachAfterBind(mesh: Mesh, effect: Effect): void;
+    ReviewUniform(name: string, arr: string[]): string[];
+    Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: StandardMaterialDefines): string;
+    constructor(name: string, scene: Scene);
+    AddUniform(name: string, kind: string, param: any): CustomMaterial;
+    Fragment_Begin(shaderPart: string): CustomMaterial;
+    Fragment_Definitions(shaderPart: string): CustomMaterial;
+    Fragment_MainBegin(shaderPart: string): CustomMaterial;
+    Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
+    Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
+    Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
+    Vertex_Begin(shaderPart: string): CustomMaterial;
+    Vertex_Definitions(shaderPart: string): CustomMaterial;
+    Vertex_MainBegin(shaderPart: string): CustomMaterial;
+    Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
+    Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
+}
+
+import { PushMaterial, Nullable, BaseTexture, Color3, Scene, AbstractMesh, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class FireMaterial extends PushMaterial {
+    diffuseTexture: Nullable<BaseTexture>;
+    distortionTexture: Nullable<BaseTexture>;
+    opacityTexture: Nullable<BaseTexture>;
+    diffuseColor: Color3;
+    speed: 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;
+    getClassName(): string;
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): FireMaterial;
+    serialize(): any;
+    static Parse(source: any, scene: Scene, rootUrl: string): FireMaterial;
+}
+
+import { PushMaterial, BaseTexture, Color3, Vector3, DynamicTexture, AbstractMesh, Scene, Nullable, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class FurMaterial extends PushMaterial {
+    diffuseTexture: BaseTexture;
+    heightTexture: BaseTexture;
+    diffuseColor: Color3;
+    furLength: number;
+    furAngle: number;
+    furColor: Color3;
+    furOffset: number;
+    furSpacing: number;
+    furGravity: Vector3;
+    furSpeed: number;
+    furDensity: number;
+    furOcclusion: number;
+    furTexture: DynamicTexture;
+    disableLighting: boolean;
+    maxSimultaneousLights: number;
+    highLevelFur: boolean;
+    _meshes: AbstractMesh[];
+    constructor(name: string, scene: Scene);
+    furTime: number;
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): Nullable<BaseTexture>;
+    updateFur(): void;
+    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): FurMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: Scene, rootUrl: string): FurMaterial;
+    static GenerateTexture(name: string, scene: Scene): DynamicTexture;
+    static FurifyMesh(sourceMesh: Mesh, quality: number): Mesh[];
+}
+
+import { PushMaterial, Color3, Scene, Nullable, BaseTexture, AbstractMesh, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class GradientMaterial extends PushMaterial {
+    maxSimultaneousLights: number;
+    topColor: Color3;
+    topColorAlpha: number;
+    bottomColor: Color3;
+    bottomColorAlpha: number;
+    offset: number;
+    scale: number;
+    smoothness: number;
+    disableLighting: boolean;
+    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[];
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): GradientMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: Scene, rootUrl: string): GradientMaterial;
+}
+
+import { Color3, Vector3, Scene, AbstractMesh, SubMesh, Matrix, Mesh } from "babylonjs";
+/**
+    * The grid materials allows you to wrap any shape with a grid.
+    * Colors are customizable.
+    */
+export declare class GridMaterial extends BABYLON.PushMaterial {
+        /**
+            * Main color of the grid (e.g. between lines)
+            */
+        mainColor: Color3;
+        /**
+            * Color of the grid lines.
+            */
+        lineColor: Color3;
+        /**
+            * The scale of the grid compared to unit.
+            */
+        gridRatio: number;
+        /**
+            * Allows setting an offset for the grid lines.
+            */
+        gridOffset: Vector3;
+        /**
+            * The frequency of thicker lines.
+            */
+        majorUnitFrequency: number;
+        /**
+            * The visibility of minor units in the grid.
+            */
+        minorUnitVisibility: number;
+        /**
+            * The grid opacity outside of the lines.
+            */
+        opacity: number;
+        /**
+            * Determine RBG output is premultiplied by alpha value.
+            */
+        preMultiplyAlpha: boolean;
+        /**
+            * constructor
+            * @param name The name given to the material in order to identify it afterwards.
+            * @param scene The scene the material is used in.
+            */
+        constructor(name: string, scene: Scene);
+        /**
+            * Returns wehter or not the grid requires alpha blending.
+            */
+        needAlphaBlending(): boolean;
+        needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): GridMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: Scene, rootUrl: string): GridMaterial;
+}
+
+import { PushMaterial, BaseTexture, Color3, Scene, Nullable, AbstractMesh, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class LavaMaterial extends PushMaterial {
+    diffuseTexture: BaseTexture;
+    noiseTexture: BaseTexture;
+    fogColor: Color3;
+    speed: number;
+    movingSpeed: number;
+    lowFrequencySpeed: number;
+    fogDensity: number;
+    diffuseColor: Color3;
+    disableLighting: boolean;
+    unlit: boolean;
+    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): LavaMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial;
+}
+
+import { PushMaterial, BaseTexture, Texture, Color3, Scene, Nullable, AbstractMesh, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class MixMaterial extends PushMaterial {
+        mixTexture1: BaseTexture;
+        mixTexture2: BaseTexture;
+        diffuseTexture1: Texture;
+        diffuseTexture2: Texture;
+        diffuseTexture3: Texture;
+        diffuseTexture4: Texture;
+        diffuseTexture5: Texture;
+        diffuseTexture6: Texture;
+        diffuseTexture7: Texture;
+        diffuseTexture8: Texture;
+        /**
+            * Uniforms
+            */
+        diffuseColor: Color3;
+        specularColor: Color3;
+        specularPower: number;
+        disableLighting: boolean;
+        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): MixMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: Scene, rootUrl: string): MixMaterial;
+}
+
+import { PushMaterial, BaseTexture, Color3, Scene, Nullable, AbstractMesh, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class NormalMaterial extends PushMaterial {
+    diffuseTexture: BaseTexture;
+    diffuseColor: Color3;
+    disableLighting: boolean;
+    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): NormalMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: Scene, rootUrl: string): NormalMaterial;
+}
+
+import { PushMaterial, IShadowLight, Scene, Nullable, BaseTexture, AbstractMesh, SubMesh, Matrix, Mesh } from "babylonjs";
+export declare class ShadowOnlyMaterial extends PushMaterial {
+    constructor(name: string, scene: Scene);
+    shadowColor: BABYLON.Color3;
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): Nullable<BaseTexture>;
+    activeLight: IShadowLight;
+    isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+    clone(name: string): ShadowOnlyMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: Scene, rootUrl: string): ShadowOnlyMaterial;
+}
+
+import { PushMaterial, BaseTexture, Color3, Scene, Nullable, AbstractMesh, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class SimpleMaterial extends PushMaterial {
+    diffuseTexture: BaseTexture;
+    diffuseColor: Color3;
+    disableLighting: boolean;
+    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): SimpleMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: Scene, rootUrl: string): SimpleMaterial;
+}
+
+import { PushMaterial, Vector3, Scene, Nullable, BaseTexture, AbstractMesh, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class SkyMaterial extends PushMaterial {
+    luminance: number;
+    turbidity: number;
+    rayleigh: number;
+    mieCoefficient: number;
+    mieDirectionalG: number;
+    distance: number;
+    inclination: number;
+    azimuth: number;
+    sunPosition: Vector3;
+    useSunPosition: boolean;
+    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[];
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): SkyMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial;
+}
+
+import { PushMaterial, BaseTexture, Texture, Color3, Scene, Nullable, AbstractMesh, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class TerrainMaterial extends PushMaterial {
+    mixTexture: BaseTexture;
+    diffuseTexture1: Texture;
+    diffuseTexture2: Texture;
+    diffuseTexture3: Texture;
+    bumpTexture1: Texture;
+    bumpTexture2: Texture;
+    bumpTexture3: Texture;
+    diffuseColor: Color3;
+    specularColor: Color3;
+    specularPower: number;
+    disableLighting: boolean;
+    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;
+}
+
+import { PushMaterial, BaseTexture, Color3, Scene, Nullable, AbstractMesh, SubMesh, Matrix, Mesh, IAnimatable } from "babylonjs";
+export declare class TriPlanarMaterial extends PushMaterial {
+    mixTexture: BaseTexture;
+    diffuseTextureX: BaseTexture;
+    diffuseTextureY: BaseTexture;
+    diffuseTextureZ: BaseTexture;
+    normalTextureX: BaseTexture;
+    normalTextureY: BaseTexture;
+    normalTextureZ: BaseTexture;
+    tileSize: number;
+    diffuseColor: Color3;
+    specularColor: Color3;
+    specularPower: number;
+    disableLighting: boolean;
+    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): TriPlanarMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: Scene, rootUrl: string): TriPlanarMaterial;
+}
+
+import { PushMaterial, BaseTexture, Color3, Vector2, SmartArray, RenderTargetTexture, Nullable, AbstractMesh, Matrix, Scene, SubMesh, Mesh, IAnimatable } from "babylonjs";
+export declare class WaterMaterial extends PushMaterial {
+        renderTargetSize: Vector2;
+        bumpTexture: BaseTexture;
+        diffuseColor: Color3;
+        specularColor: Color3;
+        specularPower: number;
+        disableLighting: boolean;
+        maxSimultaneousLights: number;
+        /**
+         * @param {number}: Represents the wind force
+         */
+        windForce: number;
+        /**
+         * @param {Vector2}: The direction of the wind in the plane (X, Z)
+         */
+        windDirection: Vector2;
+        /**
+         * @param {number}: Wave height, represents the height of the waves
+         */
+        waveHeight: number;
+        /**
+         * @param {number}: Bump height, represents the bump height related to the bump map
+         */
+        bumpHeight: number;
+        bumpSuperimpose: boolean;
+        fresnelSeparate: boolean;
+        bumpAffectsReflection: boolean;
+        /**
+         * @param {number}: The water color blended with the refraction (near)
+         */
+        waterColor: Color3;
+        /**
+         * @param {number}: The blend factor related to the water color
+         */
+        colorBlendFactor: number;
+        /**
+            * @param {number}: The water color blended with the reflection (far)
+            */
+        waterColor2: Color3;
+        /**
+            * @param {number}: The blend factor related to the water color (reflection, far)
+            */
+        colorBlendFactor2: number;
+        /**
+         * @param {number}: Represents the maximum length of a wave
+         */
+        waveLength: number;
+        /**
+         * @param {number}: Defines the waves speed
+         */
+        waveSpeed: number;
+        protected _renderTargets: SmartArray<RenderTargetTexture>;
+        /**
+            * Gets a boolean indicating that current material needs to register RTT
+            */
+        readonly hasRenderTargetTextures: boolean;
+        /**
+         * Constructor
+         */
+        constructor(name: string, scene: Scene, renderTargetSize?: Vector2);
+        useLogarithmicDepth: boolean;
+        readonly refractionTexture: Nullable<RenderTargetTexture>;
+        readonly reflectionTexture: Nullable<RenderTargetTexture>;
+        addToRenderList(node: any): void;
+        enableRenderTargets(enable: boolean): void;
+        getRenderList(): Nullable<AbstractMesh[]>;
+        readonly renderTargetsEnabled: boolean;
+        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): WaterMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial;
+        static CreateDefaultMesh(name: string, scene: Scene): Mesh;
+}
+

dist/preview release/materialsLibrary/babylon.backgroundMaterial.d.ts

@@ -1,280 +0,0 @@
-
-declare namespace BABYLON {
-    /**
-     * Background material
-     */
-    class BackgroundMaterial extends BABYLON.PushMaterial {
-        /**
-         * Key light Color (multiply against the R channel of the environement texture)
-         */
-        protected _primaryColor: Color3;
-        primaryColor: Color3;
-        /**
-         * Key light Level (allowing HDR output of the background)
-         */
-        protected _primaryLevel: float;
-        primaryLevel: float;
-        /**
-         * Secondary light Color (multiply against the G channel of the environement texture)
-         */
-        protected _secondaryColor: Color3;
-        secondaryColor: Color3;
-        /**
-         * Secondary light Level (allowing HDR output of the background)
-         */
-        protected _secondaryLevel: float;
-        secondaryLevel: float;
-        /**
-         * Tertiary light Color (multiply against the B channel of the environement texture)
-         */
-        protected _tertiaryColor: Color3;
-        tertiaryColor: Color3;
-        /**
-         * Tertiary light Level (allowing HDR output of the background)
-         */
-        protected _tertiaryLevel: float;
-        tertiaryLevel: float;
-        /**
-         * Reflection Texture used in the material.
-         * Should be author in a specific way for the best result (refer to the documentation).
-         */
-        protected _reflectionTexture: Nullable<BaseTexture>;
-        reflectionTexture: Nullable<BaseTexture>;
-        /**
-         * Reflection Texture level of blur.
-         *
-         * Can be use to reuse an existing HDR Texture and target a specific LOD to prevent authoring the
-         * texture twice.
-         */
-        protected _reflectionBlur: float;
-        reflectionBlur: float;
-        /**
-         * Diffuse Texture used in the material.
-         * Should be author in a specific way for the best result (refer to the documentation).
-         */
-        protected _diffuseTexture: Nullable<BaseTexture>;
-        diffuseTexture: Nullable<BaseTexture>;
-        /**
-         * Specify the list of lights casting shadow on the material.
-         * All scene shadow lights will be included if null.
-         */
-        protected _shadowLights: Nullable<IShadowLight[]>;
-        shadowLights: Nullable<IShadowLight[]>;
-        /**
-         * For the lights having a blurred shadow generator, this can add a second blur pass in order to reach
-         * soft lighting on the background.
-         */
-        protected _shadowBlurScale: int;
-        shadowBlurScale: int;
-        /**
-         * Helps adjusting the shadow to a softer level if required.
-         * 0 means black shadows and 1 means no shadows.
-         */
-        protected _shadowLevel: float;
-        shadowLevel: float;
-        /**
-         * In case of opacity Fresnel or reflection falloff, this is use as a scene center.
-         * It is usually zero but might be interesting to modify according to your setup.
-         */
-        protected _sceneCenter: Vector3;
-        sceneCenter: Vector3;
-        /**
-         * This helps specifying that the material is falling off to the sky box at grazing angle.
-         * This helps ensuring a nice transition when the camera goes under the ground.
-         */
-        protected _opacityFresnel: boolean;
-        opacityFresnel: boolean;
-        /**
-         * This helps specifying that the material is falling off from diffuse to the reflection texture at grazing angle.
-         * This helps adding a mirror texture on the ground.
-         */
-        protected _reflectionFresnel: boolean;
-        reflectionFresnel: boolean;
-        /**
-         * This helps specifying the falloff radius off the reflection texture from the sceneCenter.
-         * This helps adding a nice falloff effect to the reflection if used as a mirror for instance.
-         */
-        protected _reflectionFalloffDistance: number;
-        reflectionFalloffDistance: number;
-        /**
-         * This specifies the weight of the reflection against the background in case of reflection Fresnel.
-         */
-        protected _reflectionAmount: number;
-        reflectionAmount: number;
-        /**
-         * This specifies the weight of the reflection at grazing angle.
-         */
-        protected _reflectionReflectance0: number;
-        reflectionReflectance0: number;
-        /**
-         * This specifies the weight of the reflection at a perpendicular point of view.
-         */
-        protected _reflectionReflectance90: number;
-        reflectionReflectance90: number;
-        /**
-         * Helps to directly use the maps channels instead of their level.
-         */
-        protected _useRGBColor: boolean;
-        useRGBColor: boolean;
-        /**
-         * Number of Simultaneous lights allowed on the material.
-         */
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: int;
-        /**
-         * Default configuration related to image processing available in the Background Material.
-         */
-        protected _imageProcessingConfiguration: ImageProcessingConfiguration;
-        /**
-         * Keep track of the image processing observer to allow dispose and replace.
-         */
-        private _imageProcessingObserver;
-        /**
-         * Attaches a new image processing configuration to the PBR Material.
-         * @param configuration (if null the scene configuration will be use)
-         */
-        protected _attachImageProcessingConfiguration(configuration: Nullable<ImageProcessingConfiguration>): void;
-        /**
-         * Gets the image processing configuration used either in this material.
-         */
-        /**
-         * Sets the Default image processing configuration used either in the this material.
-         *
-         * If sets to null, the scene one is in use.
-         */
-        imageProcessingConfiguration: Nullable<ImageProcessingConfiguration>;
-        /**
-         * Gets wether the color curves effect is enabled.
-         */
-        /**
-         * Sets wether the color curves effect is enabled.
-         */
-        cameraColorCurvesEnabled: boolean;
-        /**
-         * Gets wether the color grading effect is enabled.
-         */
-        /**
-         * Gets wether the color grading effect is enabled.
-         */
-        cameraColorGradingEnabled: boolean;
-        /**
-         * Gets wether tonemapping is enabled or not.
-         */
-        /**
-         * Sets wether tonemapping is enabled or not
-         */
-        cameraToneMappingEnabled: boolean;
-        /**
-         * The camera exposure used on this material.
-         * This property is here and not in the camera to allow controlling exposure without full screen post process.
-         * This corresponds to a photographic exposure.
-         */
-        /**
-         * The camera exposure used on this material.
-         * This property is here and not in the camera to allow controlling exposure without full screen post process.
-         * This corresponds to a photographic exposure.
-         */
-        cameraExposure: float;
-        /**
-         * Gets The camera contrast used on this material.
-         */
-        /**
-         * Sets The camera contrast used on this material.
-         */
-        cameraContrast: float;
-        /**
-         * Gets the Color Grading 2D Lookup Texture.
-         */
-        /**
-         * Sets the Color Grading 2D Lookup Texture.
-         */
-        cameraColorGradingTexture: Nullable<BaseTexture>;
-        /**
-         * The color grading curves provide additional color adjustmnent that is applied after any color grading transform (3D LUT).
-         * They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects.
-         * These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image;
-         * corresponding to low luminance, medium luminance, and high luminance areas respectively.
-         */
-        /**
-         * The color grading curves provide additional color adjustmnent that is applied after any color grading transform (3D LUT).
-         * They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects.
-         * These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image;
-         * corresponding to low luminance, medium luminance, and high luminance areas respectively.
-         */
-        cameraColorCurves: Nullable<ColorCurves>;
-        private _renderTargets;
-        private _reflectionControls;
-        /**
-         * constructor
-         * @param name The name of the material
-         * @param scene The scene to add the material to
-         */
-        constructor(name: string, scene: BABYLON.Scene);
-        /**
-         * The entire material has been created in order to prevent overdraw.
-         * @returns false
-         */
-        needAlphaTesting(): boolean;
-        /**
-         * The entire material has been created in order to prevent overdraw.
-         * @returns true if blending is enable
-         */
-        needAlphaBlending(): boolean;
-        /**
-         * Checks wether the material is ready to be rendered for a given mesh.
-         * @param mesh The mesh to render
-         * @param subMesh The submesh to check against
-         * @param useInstances Specify wether or not the material is used with instances
-         */
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        /**
-         * Build the uniform buffer used in the material.
-         */
-        buildUniformLayout(): void;
-        /**
-         * Unbind the material.
-         */
-        unbind(): void;
-        /**
-         * Bind only the world matrix to the material.
-         * @param world The world matrix to bind.
-         */
-        bindOnlyWorldMatrix(world: Matrix): void;
-        /**
-         * Bind the material for a dedicated submeh (every used meshes will be considered opaque).
-         * @param world The world matrix to bind.
-         * @param subMesh The submesh to bind for.
-         */
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        /**
-         * Dispose the material.
-         * @forceDisposeEffect Force disposal of the associated effect.
-         * @forceDisposeTextures Force disposal of the associated textures.
-         */
-        dispose(forceDisposeEffect?: boolean, forceDisposeTextures?: boolean): void;
-        /**
-         * Clones the material.
-         * @name The cloned name.
-         * @returns The cloned material.
-         */
-        clone(name: string): BackgroundMaterial;
-        /**
-         * Serializes the current material to its JSON representation.
-         * @returns The JSON representation.
-         */
-        serialize(): any;
-        /**
-         * Gets the class name of the material
-         * @returns "BackgroundMaterial"
-         */
-        getClassName(): string;
-        /**
-         * Parse a JSON input to create back a background material.
-         * @param source
-         * @param scene
-         * @param rootUrl
-         * @returns the instantiated BackgroundMaterial.
-         */
-        static Parse(source: any, scene: Scene, rootUrl: string): BackgroundMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.cellMaterial.d.ts

@@ -1,29 +0,0 @@
-
-declare module BABYLON {
-    class CellMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        _computeHighLevel: boolean;
-        computeHighLevel: boolean;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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;
-        getClassName(): string;
-        clone(name: string): CellMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): CellMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.customMaterial.d.ts

@@ -1,50 +0,0 @@
-
-declare module BABYLON {
-    class CustomShaderStructure {
-        FragmentStore: string;
-        VertexStore: string;
-        constructor();
-    }
-    class ShaderSpecialParts {
-        constructor();
-        Fragment_Begin: string;
-        Fragment_Definitions: string;
-        Fragment_MainBegin: string;
-        Fragment_Custom_Diffuse: string;
-        Fragment_Custom_Alpha: string;
-        Fragment_Before_FragColor: string;
-        Vertex_Begin: string;
-        Vertex_Definitions: string;
-        Vertex_MainBegin: string;
-        Vertex_Before_PositionUpdated: string;
-        Vertex_Before_NormalUpdated: string;
-    }
-    class CustomMaterial extends StandardMaterial {
-        static ShaderIndexer: number;
-        CustomParts: ShaderSpecialParts;
-        _isCreatedShader: boolean;
-        _createdShaderName: string;
-        _customUniform: string[];
-        _newUniforms: string[];
-        _newUniformInstances: any[];
-        _newSamplerInstances: Texture[];
-        FragmentShader: string;
-        VertexShader: string;
-        AttachAfterBind(mesh: Mesh, effect: Effect): void;
-        ReviewUniform(name: string, arr: string[]): string[];
-        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: StandardMaterialDefines): string;
-        constructor(name: string, scene: Scene);
-        AddUniform(name: string, kind: string, param: any): CustomMaterial;
-        Fragment_Begin(shaderPart: string): CustomMaterial;
-        Fragment_Definitions(shaderPart: string): CustomMaterial;
-        Fragment_MainBegin(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
-        Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
-        Vertex_Begin(shaderPart: string): CustomMaterial;
-        Vertex_Definitions(shaderPart: string): CustomMaterial;
-        Vertex_MainBegin(shaderPart: string): CustomMaterial;
-        Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
-        Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.customMaterial.js

@@ -1,192 +0,0 @@
-/// <reference path="../../../dist/preview release/babylon.d.ts"/>
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    }
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var BABYLON;
-(function (BABYLON) {
-    var CustomShaderStructure = /** @class */ (function () {
-        function CustomShaderStructure() {
-        }
-        return CustomShaderStructure;
-    }());
-    BABYLON.CustomShaderStructure = CustomShaderStructure;
-    var ShaderSpecialParts = /** @class */ (function () {
-        function ShaderSpecialParts() {
-        }
-        return ShaderSpecialParts;
-    }());
-    BABYLON.ShaderSpecialParts = ShaderSpecialParts;
-    var CustomMaterial = /** @class */ (function (_super) {
-        __extends(CustomMaterial, _super);
-        function CustomMaterial(name, scene) {
-            var _this = _super.call(this, name, scene) || this;
-            _this.CustomParts = new ShaderSpecialParts();
-            _this.customShaderNameResolve = _this.Builder;
-            _this.FragmentShader = BABYLON.Effect.ShadersStore["defaultPixelShader"];
-            _this.VertexShader = BABYLON.Effect.ShadersStore["defaultVertexShader"];
-            return _this;
-        }
-        CustomMaterial.prototype.AttachAfterBind = function (mesh, effect) {
-            for (var el in this._newUniformInstances) {
-                var ea = el.toString().split('-');
-                if (ea[0] == 'vec2') {
-                    effect.setVector2(ea[1], this._newUniformInstances[el]);
-                }
-                else if (ea[0] == 'vec3') {
-                    effect.setVector3(ea[1], this._newUniformInstances[el]);
-                }
-                else if (ea[0] == 'vec4') {
-                    effect.setVector4(ea[1], this._newUniformInstances[el]);
-                }
-                else if (ea[0] == 'mat4') {
-                    effect.setMatrix(ea[1], this._newUniformInstances[el]);
-                }
-                else if (ea[0] == 'float') {
-                    effect.setFloat(ea[1], this._newUniformInstances[el]);
-                }
-            }
-            for (var el in this._newSamplerInstances) {
-                var ea = el.toString().split('-');
-                if (ea[0] == 'sampler2D' && this._newSamplerInstances[el].isReady && this._newSamplerInstances[el].isReady()) {
-                    effect.setTexture(ea[1], this._newSamplerInstances[el]);
-                }
-            }
-        };
-        CustomMaterial.prototype.ReviewUniform = function (name, arr) {
-            if (name == "uniform") {
-                for (var ind in this._newUniforms) {
-                    if (this._customUniform[ind].indexOf('sampler') == -1) {
-                        arr.push(this._newUniforms[ind]);
-                    }
-                }
-            }
-            if (name == "sampler") {
-                for (var ind in this._newUniforms) {
-                    if (this._customUniform[ind].indexOf('sampler') != -1) {
-                        arr.push(this._newUniforms[ind]);
-                    }
-                }
-            }
-            return arr;
-        };
-        CustomMaterial.prototype.Builder = function (shaderName, uniforms, uniformBuffers, samplers, defines) {
-            var _this = this;
-            if (this._isCreatedShader) {
-                return this._createdShaderName;
-            }
-            this._isCreatedShader = false;
-            CustomMaterial.ShaderIndexer++;
-            var name = "custom_" + CustomMaterial.ShaderIndexer;
-            this.ReviewUniform("uniform", uniforms);
-            this.ReviewUniform("sampler", samplers);
-            var fn_afterBind = this._afterBind.bind(this);
-            this._afterBind = function (m, e) {
-                if (!e) {
-                    return;
-                }
-                _this.AttachAfterBind(m, e);
-                try {
-                    fn_afterBind(m, e);
-                }
-                catch (e) { }
-            };
-            BABYLON.Effect.ShadersStore[name + "VertexShader"] = this.VertexShader
-                .replace('#define CUSTOM_VERTEX_BEGIN', (this.CustomParts.Vertex_Begin ? this.CustomParts.Vertex_Begin : ""))
-                .replace('#define CUSTOM_VERTEX_DEFINITIONS', (this._customUniform ? this._customUniform.join("\n") : "") + (this.CustomParts.Vertex_Definitions ? this.CustomParts.Vertex_Definitions : ""))
-                .replace('#define CUSTOM_VERTEX_MAIN_BEGIN', (this.CustomParts.Vertex_MainBegin ? this.CustomParts.Vertex_MainBegin : ""))
-                .replace('#define CUSTOM_VERTEX_UPDATE_POSITION', (this.CustomParts.Vertex_Before_PositionUpdated ? this.CustomParts.Vertex_Before_PositionUpdated : ""))
-                .replace('#define CUSTOM_VERTEX_UPDATE_NORMAL', (this.CustomParts.Vertex_Before_NormalUpdated ? this.CustomParts.Vertex_Before_NormalUpdated : ""));
-            // #define CUSTOM_VERTEX_MAIN_END
-            BABYLON.Effect.ShadersStore[name + "PixelShader"] = this.FragmentShader
-                .replace('#define CUSTOM_FRAGMENT_BEGIN', (this.CustomParts.Fragment_Begin ? this.CustomParts.Fragment_Begin : ""))
-                .replace('#define CUSTOM_FRAGMENT_MAIN_BEGIN', (this.CustomParts.Fragment_MainBegin ? this.CustomParts.Fragment_MainBegin : ""))
-                .replace('#define CUSTOM_FRAGMENT_DEFINITIONS', (this._customUniform ? this._customUniform.join("\n") : "") + (this.CustomParts.Fragment_Definitions ? this.CustomParts.Fragment_Definitions : ""))
-                .replace('#define CUSTOM_FRAGMENT_UPDATE_DIFFUSE', (this.CustomParts.Fragment_Custom_Diffuse ? this.CustomParts.Fragment_Custom_Diffuse : ""))
-                .replace('#define CUSTOM_FRAGMENT_UPDATE_ALPHA', (this.CustomParts.Fragment_Custom_Alpha ? this.CustomParts.Fragment_Custom_Alpha : ""))
-                .replace('#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR', (this.CustomParts.Fragment_Before_FragColor ? this.CustomParts.Fragment_Before_FragColor : ""));
-            // #define CUSTOM_FRAGMENT_BEFORE_LIGHTS
-            // #define CUSTOM_FRAGMENT_BEFORE_FOG
-            this._isCreatedShader = true;
-            this._createdShaderName = name;
-            return name;
-        };
-        CustomMaterial.prototype.AddUniform = function (name, kind, param) {
-            if (!this._customUniform) {
-                this._customUniform = new Array();
-                this._newUniforms = new Array();
-                this._newSamplerInstances = new Array();
-                this._newUniformInstances = new Array();
-            }
-            if (param) {
-                if (kind.indexOf("sampler") == -1) {
-                    this._newUniformInstances[kind + "-" + name] = param;
-                }
-                else {
-                    this._newUniformInstances[kind + "-" + name] = param;
-                }
-            }
-            this._customUniform.push("uniform " + kind + " " + name + ";");
-            this._newUniforms.push(name);
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Begin = function (shaderPart) {
-            this.CustomParts.Fragment_Begin = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Definitions = function (shaderPart) {
-            this.CustomParts.Fragment_Definitions = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_MainBegin = function (shaderPart) {
-            this.CustomParts.Fragment_MainBegin = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Custom_Diffuse = function (shaderPart) {
-            this.CustomParts.Fragment_Custom_Diffuse = shaderPart.replace("result", "diffuseColor");
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Custom_Alpha = function (shaderPart) {
-            this.CustomParts.Fragment_Custom_Alpha = shaderPart.replace("result", "alpha");
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Before_FragColor = function (shaderPart) {
-            this.CustomParts.Fragment_Before_FragColor = shaderPart.replace("result", "color");
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_Begin = function (shaderPart) {
-            this.CustomParts.Vertex_Begin = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_Definitions = function (shaderPart) {
-            this.CustomParts.Vertex_Definitions = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_MainBegin = function (shaderPart) {
-            this.CustomParts.Vertex_MainBegin = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_Before_PositionUpdated = function (shaderPart) {
-            this.CustomParts.Vertex_Before_PositionUpdated = shaderPart.replace("result", "positionUpdated");
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_Before_NormalUpdated = function (shaderPart) {
-            this.CustomParts.Vertex_Before_NormalUpdated = shaderPart.replace("result", "normalUpdated");
-            return this;
-        };
-        CustomMaterial.ShaderIndexer = 1;
-        return CustomMaterial;
-    }(BABYLON.StandardMaterial));
-    BABYLON.CustomMaterial = CustomMaterial;
-})(BABYLON || (BABYLON = {}));
-
-//# sourceMappingURL=babylon.customMaterial.js.map

dist/preview release/materialsLibrary/babylon.fireMaterial.d.ts

@@ -1,30 +0,0 @@
-
-declare module BABYLON {
-    class FireMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: Nullable<BaseTexture>;
-        private _distortionTexture;
-        distortionTexture: Nullable<BaseTexture>;
-        private _opacityTexture;
-        opacityTexture: Nullable<BaseTexture>;
-        diffuseColor: Color3;
-        speed: number;
-        private _scaledDiffuse;
-        private _renderId;
-        private _lastTime;
-        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;
-        getClassName(): string;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): FireMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): FireMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.furMaterial.d.ts

@@ -1,46 +0,0 @@
-
-declare module BABYLON {
-    class FurMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        private _heightTexture;
-        heightTexture: BaseTexture;
-        diffuseColor: Color3;
-        furLength: number;
-        furAngle: number;
-        furColor: Color3;
-        furOffset: number;
-        furSpacing: number;
-        furGravity: Vector3;
-        furSpeed: number;
-        furDensity: number;
-        furOcclusion: number;
-        furTexture: DynamicTexture;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        highLevelFur: boolean;
-        _meshes: AbstractMesh[];
-        private _renderId;
-        private _furTime;
-        constructor(name: string, scene: Scene);
-        furTime: number;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        updateFur(): void;
-        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): FurMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): FurMaterial;
-        static GenerateTexture(name: string, scene: Scene): DynamicTexture;
-        static FurifyMesh(sourceMesh: Mesh, quality: number): Mesh[];
-    }
-}

dist/preview release/materialsLibrary/babylon.gradientMaterial.d.ts

@@ -1,29 +0,0 @@
-
-declare module BABYLON {
-    class GradientMaterial extends PushMaterial {
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        topColor: Color3;
-        topColorAlpha: number;
-        bottomColor: Color3;
-        bottomColorAlpha: number;
-        offset: number;
-        scale: number;
-        smoothness: number;
-        disableLighting: boolean;
-        private _scaledDiffuse;
-        private _renderId;
-        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[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): GradientMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): GradientMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.gridMaterial.d.ts

@@ -1,61 +0,0 @@
-
-declare module BABYLON {
-    /**
-     * The grid materials allows you to wrap any shape with a grid.
-     * Colors are customizable.
-     */
-    class GridMaterial extends BABYLON.PushMaterial {
-        /**
-         * Main color of the grid (e.g. between lines)
-         */
-        mainColor: Color3;
-        /**
-         * Color of the grid lines.
-         */
-        lineColor: Color3;
-        /**
-         * The scale of the grid compared to unit.
-         */
-        gridRatio: number;
-        /**
-         * Allows setting an offset for the grid lines.
-         */
-        gridOffset: Vector3;
-        /**
-         * The frequency of thicker lines.
-         */
-        majorUnitFrequency: number;
-        /**
-         * The visibility of minor units in the grid.
-         */
-        minorUnitVisibility: number;
-        /**
-         * The grid opacity outside of the lines.
-         */
-        opacity: number;
-        /**
-         * Determine RBG output is premultiplied by alpha value.
-         */
-        preMultiplyAlpha: boolean;
-        private _gridControl;
-        private _renderId;
-        /**
-         * constructor
-         * @param name The name given to the material in order to identify it afterwards.
-         * @param scene The scene the material is used in.
-         */
-        constructor(name: string, scene: Scene);
-        /**
-         * Returns wehter or not the grid requires alpha blending.
-         */
-        needAlphaBlending(): boolean;
-        needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): GridMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): GridMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.lavaMaterial.d.ts

@@ -1,37 +0,0 @@
-
-declare module BABYLON {
-    class LavaMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        noiseTexture: BaseTexture;
-        fogColor: Color3;
-        speed: number;
-        movingSpeed: number;
-        lowFrequencySpeed: number;
-        fogDensity: number;
-        private _lastTime;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _unlit;
-        unlit: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _scaledDiffuse;
-        private _renderId;
-        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): LavaMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.materials.d.ts

@@ -0,0 +1,549 @@
+/*BabylonJS Materials*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+}
+declare module BABYLON {
+    export class CellMaterial extends BABYLON.PushMaterial {
+        diffuseTexture: BABYLON.BaseTexture;
+        diffuseColor: BABYLON.Color3;
+        _computeHighLevel: boolean;
+        computeHighLevel: boolean;
+        disableLighting: boolean;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        getClassName(): string;
+        clone(name: string): CellMaterial;
+        serialize(): any;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): CellMaterial;
+    }
+}
+declare module BABYLON {
+    export class CustomShaderStructure {
+        FragmentStore: string;
+        VertexStore: string;
+        constructor();
+    }
+    export class ShaderSpecialParts {
+        constructor();
+        Fragment_Begin: string;
+        Fragment_Definitions: string;
+        Fragment_MainBegin: string;
+        Fragment_Custom_Diffuse: string;
+        Fragment_Custom_Alpha: string;
+        Fragment_Before_FragColor: string;
+        Vertex_Begin: string;
+        Vertex_Definitions: string;
+        Vertex_MainBegin: string;
+        Vertex_Before_PositionUpdated: string;
+        Vertex_Before_NormalUpdated: string;
+    }
+    export class CustomMaterial extends BABYLON.StandardMaterial {
+        static ShaderIndexer: number;
+        CustomParts: ShaderSpecialParts;
+        _isCreatedShader: boolean;
+        _createdShaderName: string;
+        _customUniform: string[];
+        _newUniforms: string[];
+        _newUniformInstances: any[];
+        _newSamplerInstances: BABYLON.Texture[];
+        FragmentShader: string;
+        VertexShader: string;
+        AttachAfterBind(mesh: BABYLON.Mesh, effect: BABYLON.Effect): void;
+        ReviewUniform(name: string, arr: string[]): string[];
+        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: BABYLON.StandardMaterialDefines): string;
+        constructor(name: string, scene: BABYLON.Scene);
+        AddUniform(name: string, kind: string, param: any): CustomMaterial;
+        Fragment_Begin(shaderPart: string): CustomMaterial;
+        Fragment_Definitions(shaderPart: string): CustomMaterial;
+        Fragment_MainBegin(shaderPart: string): CustomMaterial;
+        Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
+        Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
+        Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
+        Vertex_Begin(shaderPart: string): CustomMaterial;
+        Vertex_Definitions(shaderPart: string): CustomMaterial;
+        Vertex_MainBegin(shaderPart: string): CustomMaterial;
+        Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
+        Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
+    }
+}
+declare module BABYLON {
+    export class FireMaterial extends BABYLON.PushMaterial {
+        diffuseTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
+        distortionTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
+        opacityTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
+        diffuseColor: BABYLON.Color3;
+        speed: number;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        getClassName(): string;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): FireMaterial;
+        serialize(): any;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FireMaterial;
+    }
+}
+declare module BABYLON {
+    export class FurMaterial extends BABYLON.PushMaterial {
+        diffuseTexture: BABYLON.BaseTexture;
+        heightTexture: BABYLON.BaseTexture;
+        diffuseColor: BABYLON.Color3;
+        furLength: number;
+        furAngle: number;
+        furColor: BABYLON.Color3;
+        furOffset: number;
+        furSpacing: number;
+        furGravity: BABYLON.Vector3;
+        furSpeed: number;
+        furDensity: number;
+        furOcclusion: number;
+        furTexture: BABYLON.DynamicTexture;
+        disableLighting: boolean;
+        maxSimultaneousLights: number;
+        highLevelFur: boolean;
+        _meshes: BABYLON.AbstractMesh[];
+        constructor(name: string, scene: BABYLON.Scene);
+        furTime: number;
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        updateFur(): void;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): FurMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FurMaterial;
+        static GenerateTexture(name: string, scene: BABYLON.Scene): BABYLON.DynamicTexture;
+        static FurifyMesh(sourceMesh: BABYLON.Mesh, quality: number): BABYLON.Mesh[];
+    }
+}
+declare module BABYLON {
+    export class GradientMaterial extends BABYLON.PushMaterial {
+        maxSimultaneousLights: number;
+        topColor: BABYLON.Color3;
+        topColorAlpha: number;
+        bottomColor: BABYLON.Color3;
+        bottomColorAlpha: number;
+        offset: number;
+        scale: number;
+        smoothness: number;
+        disableLighting: boolean;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): GradientMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): GradientMaterial;
+    }
+}
+declare module BABYLON {
+    /**
+        * The grid materials allows you to wrap any shape with a grid.
+        * Colors are customizable.
+        */
+    export class GridMaterial extends BABYLON.PushMaterial {
+            /**
+                * Main color of the grid (e.g. between lines)
+                */
+            mainColor: BABYLON.Color3;
+            /**
+                * Color of the grid lines.
+                */
+            lineColor: BABYLON.Color3;
+            /**
+                * The scale of the grid compared to unit.
+                */
+            gridRatio: number;
+            /**
+                * Allows setting an offset for the grid lines.
+                */
+            gridOffset: BABYLON.Vector3;
+            /**
+                * The frequency of thicker lines.
+                */
+            majorUnitFrequency: number;
+            /**
+                * The visibility of minor units in the grid.
+                */
+            minorUnitVisibility: number;
+            /**
+                * The grid opacity outside of the lines.
+                */
+            opacity: number;
+            /**
+                * Determine RBG output is premultiplied by alpha value.
+                */
+            preMultiplyAlpha: boolean;
+            /**
+                * constructor
+                * @param name The name given to the material in order to identify it afterwards.
+                * @param scene The scene the material is used in.
+                */
+            constructor(name: string, scene: BABYLON.Scene);
+            /**
+                * Returns wehter or not the grid requires alpha blending.
+                */
+            needAlphaBlending(): boolean;
+            needAlphaBlendingForMesh(mesh: BABYLON.AbstractMesh): boolean;
+            isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+            bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+            dispose(forceDisposeEffect?: boolean): void;
+            clone(name: string): GridMaterial;
+            serialize(): any;
+            getClassName(): string;
+            static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): GridMaterial;
+    }
+}
+declare module BABYLON {
+    export class LavaMaterial extends BABYLON.PushMaterial {
+        diffuseTexture: BABYLON.BaseTexture;
+        noiseTexture: BABYLON.BaseTexture;
+        fogColor: BABYLON.Color3;
+        speed: number;
+        movingSpeed: number;
+        lowFrequencySpeed: number;
+        fogDensity: number;
+        diffuseColor: BABYLON.Color3;
+        disableLighting: boolean;
+        unlit: boolean;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): LavaMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): LavaMaterial;
+    }
+}
+declare module BABYLON {
+    export class MixMaterial extends BABYLON.PushMaterial {
+            mixTexture1: BABYLON.BaseTexture;
+            mixTexture2: BABYLON.BaseTexture;
+            diffuseTexture1: BABYLON.Texture;
+            diffuseTexture2: BABYLON.Texture;
+            diffuseTexture3: BABYLON.Texture;
+            diffuseTexture4: BABYLON.Texture;
+            diffuseTexture5: BABYLON.Texture;
+            diffuseTexture6: BABYLON.Texture;
+            diffuseTexture7: BABYLON.Texture;
+            diffuseTexture8: BABYLON.Texture;
+            /**
+                * Uniforms
+                */
+            diffuseColor: BABYLON.Color3;
+            specularColor: BABYLON.Color3;
+            specularPower: number;
+            disableLighting: boolean;
+            maxSimultaneousLights: number;
+            constructor(name: string, scene: BABYLON.Scene);
+            needAlphaBlending(): boolean;
+            needAlphaTesting(): boolean;
+            getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+            isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+            bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+            getAnimatables(): BABYLON.IAnimatable[];
+            getActiveTextures(): BABYLON.BaseTexture[];
+            hasTexture(texture: BABYLON.BaseTexture): boolean;
+            dispose(forceDisposeEffect?: boolean): void;
+            clone(name: string): MixMaterial;
+            serialize(): any;
+            getClassName(): string;
+            static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): MixMaterial;
+    }
+}
+declare module BABYLON {
+    export class NormalMaterial extends BABYLON.PushMaterial {
+        diffuseTexture: BABYLON.BaseTexture;
+        diffuseColor: BABYLON.Color3;
+        disableLighting: boolean;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): NormalMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): NormalMaterial;
+    }
+}
+declare module BABYLON {
+    export class ShadowOnlyMaterial extends BABYLON.PushMaterial {
+        constructor(name: string, scene: BABYLON.Scene);
+        shadowColor: BABYLON.Color3;
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        activeLight: BABYLON.IShadowLight;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        clone(name: string): ShadowOnlyMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): ShadowOnlyMaterial;
+    }
+}
+declare module BABYLON {
+    export class SimpleMaterial extends BABYLON.PushMaterial {
+        diffuseTexture: BABYLON.BaseTexture;
+        diffuseColor: BABYLON.Color3;
+        disableLighting: boolean;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): SimpleMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): SimpleMaterial;
+    }
+}
+declare module BABYLON {
+    export class SkyMaterial extends BABYLON.PushMaterial {
+        luminance: number;
+        turbidity: number;
+        rayleigh: number;
+        mieCoefficient: number;
+        mieDirectionalG: number;
+        distance: number;
+        inclination: number;
+        azimuth: number;
+        sunPosition: BABYLON.Vector3;
+        useSunPosition: boolean;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): SkyMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): SkyMaterial;
+    }
+}
+declare module BABYLON {
+    export class TerrainMaterial extends BABYLON.PushMaterial {
+        mixTexture: BABYLON.BaseTexture;
+        diffuseTexture1: BABYLON.Texture;
+        diffuseTexture2: BABYLON.Texture;
+        diffuseTexture3: BABYLON.Texture;
+        bumpTexture1: BABYLON.Texture;
+        bumpTexture2: BABYLON.Texture;
+        bumpTexture3: BABYLON.Texture;
+        diffuseColor: BABYLON.Color3;
+        specularColor: BABYLON.Color3;
+        specularPower: number;
+        disableLighting: boolean;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): TerrainMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): TerrainMaterial;
+    }
+}
+declare module BABYLON {
+    export class TriPlanarMaterial extends BABYLON.PushMaterial {
+        mixTexture: BABYLON.BaseTexture;
+        diffuseTextureX: BABYLON.BaseTexture;
+        diffuseTextureY: BABYLON.BaseTexture;
+        diffuseTextureZ: BABYLON.BaseTexture;
+        normalTextureX: BABYLON.BaseTexture;
+        normalTextureY: BABYLON.BaseTexture;
+        normalTextureZ: BABYLON.BaseTexture;
+        tileSize: number;
+        diffuseColor: BABYLON.Color3;
+        specularColor: BABYLON.Color3;
+        specularPower: number;
+        disableLighting: boolean;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): TriPlanarMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): TriPlanarMaterial;
+    }
+}
+declare module BABYLON {
+    export class WaterMaterial extends BABYLON.PushMaterial {
+            renderTargetSize: BABYLON.Vector2;
+            bumpTexture: BABYLON.BaseTexture;
+            diffuseColor: BABYLON.Color3;
+            specularColor: BABYLON.Color3;
+            specularPower: number;
+            disableLighting: boolean;
+            maxSimultaneousLights: number;
+            /**
+             * @param {number}: Represents the wind force
+             */
+            windForce: number;
+            /**
+             * @param {Vector2}: The direction of the wind in the plane (X, Z)
+             */
+            windDirection: BABYLON.Vector2;
+            /**
+             * @param {number}: Wave height, represents the height of the waves
+             */
+            waveHeight: number;
+            /**
+             * @param {number}: Bump height, represents the bump height related to the bump map
+             */
+            bumpHeight: number;
+            bumpSuperimpose: boolean;
+            fresnelSeparate: boolean;
+            bumpAffectsReflection: boolean;
+            /**
+             * @param {number}: The water color blended with the refraction (near)
+             */
+            waterColor: BABYLON.Color3;
+            /**
+             * @param {number}: The blend factor related to the water color
+             */
+            colorBlendFactor: number;
+            /**
+                * @param {number}: The water color blended with the reflection (far)
+                */
+            waterColor2: BABYLON.Color3;
+            /**
+                * @param {number}: The blend factor related to the water color (reflection, far)
+                */
+            colorBlendFactor2: number;
+            /**
+             * @param {number}: Represents the maximum length of a wave
+             */
+            waveLength: number;
+            /**
+             * @param {number}: Defines the waves speed
+             */
+            waveSpeed: number;
+            protected _renderTargets: BABYLON.SmartArray<BABYLON.RenderTargetTexture>;
+            /**
+                * Gets a boolean indicating that current material needs to register RTT
+                */
+            readonly hasRenderTargetTextures: boolean;
+            /**
+             * Constructor
+             */
+            constructor(name: string, scene: BABYLON.Scene, renderTargetSize?: BABYLON.Vector2);
+            useLogarithmicDepth: boolean;
+            readonly refractionTexture: BABYLON.Nullable<BABYLON.RenderTargetTexture>;
+            readonly reflectionTexture: BABYLON.Nullable<BABYLON.RenderTargetTexture>;
+            addToRenderList(node: any): void;
+            enableRenderTargets(enable: boolean): void;
+            getRenderList(): BABYLON.Nullable<BABYLON.AbstractMesh[]>;
+            readonly renderTargetsEnabled: boolean;
+            needAlphaBlending(): boolean;
+            needAlphaTesting(): boolean;
+            getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+            isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+            bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+            getAnimatables(): BABYLON.IAnimatable[];
+            getActiveTextures(): BABYLON.BaseTexture[];
+            hasTexture(texture: BABYLON.BaseTexture): boolean;
+            dispose(forceDisposeEffect?: boolean): void;
+            clone(name: string): WaterMaterial;
+            serialize(): any;
+            getClassName(): string;
+            static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): WaterMaterial;
+            static CreateDefaultMesh(name: string, scene: BABYLON.Scene): BABYLON.Mesh;
+    }
+}

dist/preview release/materialsLibrary/babylon.mixMaterial.d.ts

@@ -1,56 +0,0 @@
-
-declare module BABYLON {
-    class MixMaterial extends PushMaterial {
-        /**
-         * Mix textures
-         */
-        private _mixTexture1;
-        mixTexture1: BaseTexture;
-        private _mixTexture2;
-        mixTexture2: BaseTexture;
-        /**
-         * Diffuse textures
-         */
-        private _diffuseTexture1;
-        diffuseTexture1: Texture;
-        private _diffuseTexture2;
-        diffuseTexture2: Texture;
-        private _diffuseTexture3;
-        diffuseTexture3: Texture;
-        private _diffuseTexture4;
-        diffuseTexture4: Texture;
-        private _diffuseTexture5;
-        diffuseTexture5: Texture;
-        private _diffuseTexture6;
-        diffuseTexture6: Texture;
-        private _diffuseTexture7;
-        diffuseTexture7: Texture;
-        private _diffuseTexture8;
-        diffuseTexture8: Texture;
-        /**
-         * Uniforms
-         */
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): MixMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): MixMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.normalMaterial.d.ts

@@ -1,27 +0,0 @@
-
-declare module BABYLON {
-    class NormalMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): NormalMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): NormalMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.shadowOnlyMaterial.d.ts

@@ -1,19 +0,0 @@
-
-declare module BABYLON {
-    class ShadowOnlyMaterial extends PushMaterial {
-        private _renderId;
-        private _activeLight;
-        constructor(name: string, scene: Scene);
-        shadowColor: Color3;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        activeLight: IShadowLight;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        clone(name: string): ShadowOnlyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): ShadowOnlyMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.simpleMaterial.d.ts

@@ -1,27 +0,0 @@
-
-declare module BABYLON {
-    class SimpleMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): SimpleMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): SimpleMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.skyMaterial.d.ts

@@ -1,29 +0,0 @@
-
-declare module BABYLON {
-    class SkyMaterial extends PushMaterial {
-        luminance: number;
-        turbidity: number;
-        rayleigh: number;
-        mieCoefficient: number;
-        mieDirectionalG: number;
-        distance: number;
-        inclination: number;
-        azimuth: number;
-        sunPosition: Vector3;
-        useSunPosition: boolean;
-        private _cameraPosition;
-        private _renderId;
-        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[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): SkyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.terrainMaterial.d.ts

@@ -1,41 +0,0 @@
-
-declare module BABYLON {
-    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;
-        private _renderId;
-        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;
-    }
-}

dist/preview release/materialsLibrary/babylon.triPlanarMaterial.d.ts

@@ -1,41 +0,0 @@
-
-declare module BABYLON {
-    class TriPlanarMaterial extends PushMaterial {
-        mixTexture: BaseTexture;
-        private _diffuseTextureX;
-        diffuseTextureX: BaseTexture;
-        private _diffuseTextureY;
-        diffuseTextureY: BaseTexture;
-        private _diffuseTextureZ;
-        diffuseTextureZ: BaseTexture;
-        private _normalTextureX;
-        normalTextureX: BaseTexture;
-        private _normalTextureY;
-        normalTextureY: BaseTexture;
-        private _normalTextureZ;
-        normalTextureZ: BaseTexture;
-        tileSize: number;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): TriPlanarMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): TriPlanarMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylon.waterMaterial.d.ts

@@ -1,110 +0,0 @@
-
-declare module BABYLON {
-    class WaterMaterial extends PushMaterial {
-        renderTargetSize: Vector2;
-        private _bumpTexture;
-        bumpTexture: BaseTexture;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        /**
-        * @param {number}: Represents the wind force
-        */
-        windForce: number;
-        /**
-        * @param {Vector2}: The direction of the wind in the plane (X, Z)
-        */
-        windDirection: Vector2;
-        /**
-        * @param {number}: Wave height, represents the height of the waves
-        */
-        waveHeight: number;
-        /**
-        * @param {number}: Bump height, represents the bump height related to the bump map
-        */
-        bumpHeight: number;
-        /**
-         * @param {boolean}: Add a smaller moving bump to less steady waves.
-         */
-        private _bumpSuperimpose;
-        bumpSuperimpose: boolean;
-        /**
-         * @param {boolean}: Color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
-         */
-        private _fresnelSeparate;
-        fresnelSeparate: boolean;
-        /**
-         * @param {boolean}: bump Waves modify the reflection.
-         */
-        private _bumpAffectsReflection;
-        bumpAffectsReflection: boolean;
-        /**
-        * @param {number}: The water color blended with the refraction (near)
-        */
-        waterColor: Color3;
-        /**
-        * @param {number}: The blend factor related to the water color
-        */
-        colorBlendFactor: number;
-        /**
-         * @param {number}: The water color blended with the reflection (far)
-         */
-        waterColor2: Color3;
-        /**
-         * @param {number}: The blend factor related to the water color (reflection, far)
-         */
-        colorBlendFactor2: number;
-        /**
-        * @param {number}: Represents the maximum length of a wave
-        */
-        waveLength: number;
-        /**
-        * @param {number}: Defines the waves speed
-        */
-        waveSpeed: number;
-        protected _renderTargets: SmartArray<RenderTargetTexture>;
-        private _mesh;
-        private _refractionRTT;
-        private _reflectionRTT;
-        private _reflectionTransform;
-        private _lastTime;
-        private _lastDeltaTime;
-        private _renderId;
-        private _useLogarithmicDepth;
-        private _waitingRenderList;
-        /**
-         * Gets a boolean indicating that current material needs to register RTT
-         */
-        readonly hasRenderTargetTextures: boolean;
-        /**
-        * Constructor
-        */
-        constructor(name: string, scene: Scene, renderTargetSize?: Vector2);
-        useLogarithmicDepth: boolean;
-        readonly refractionTexture: Nullable<RenderTargetTexture>;
-        readonly reflectionTexture: Nullable<RenderTargetTexture>;
-        addToRenderList(node: any): void;
-        enableRenderTargets(enable: boolean): void;
-        getRenderList(): Nullable<AbstractMesh[]>;
-        readonly renderTargetsEnabled: boolean;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        private _createRenderTargets;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): WaterMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial;
-        static CreateDefaultMesh(name: string, scene: Scene): Mesh;
-    }
-}

dist/preview release/materialsLibrary/babylonjs.materials.d.ts

@@ -1,646 +0,0 @@
-
-declare module BABYLON {
-    class ShadowOnlyMaterial extends PushMaterial {
-        private _renderId;
-        private _activeLight;
-        constructor(name: string, scene: Scene);
-        shadowColor: Color3;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        activeLight: IShadowLight;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        clone(name: string): ShadowOnlyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): ShadowOnlyMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class GradientMaterial extends PushMaterial {
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        topColor: Color3;
-        topColorAlpha: number;
-        bottomColor: Color3;
-        bottomColorAlpha: number;
-        offset: number;
-        scale: number;
-        smoothness: number;
-        disableLighting: boolean;
-        private _scaledDiffuse;
-        private _renderId;
-        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[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): GradientMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): GradientMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class NormalMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): NormalMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): NormalMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class LavaMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        noiseTexture: BaseTexture;
-        fogColor: Color3;
-        speed: number;
-        movingSpeed: number;
-        lowFrequencySpeed: number;
-        fogDensity: number;
-        private _lastTime;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _unlit;
-        unlit: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _scaledDiffuse;
-        private _renderId;
-        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): LavaMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class SimpleMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): SimpleMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): SimpleMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class WaterMaterial extends PushMaterial {
-        renderTargetSize: Vector2;
-        private _bumpTexture;
-        bumpTexture: BaseTexture;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        /**
-        * @param {number}: Represents the wind force
-        */
-        windForce: number;
-        /**
-        * @param {Vector2}: The direction of the wind in the plane (X, Z)
-        */
-        windDirection: Vector2;
-        /**
-        * @param {number}: Wave height, represents the height of the waves
-        */
-        waveHeight: number;
-        /**
-        * @param {number}: Bump height, represents the bump height related to the bump map
-        */
-        bumpHeight: number;
-        /**
-         * @param {boolean}: Add a smaller moving bump to less steady waves.
-         */
-        private _bumpSuperimpose;
-        bumpSuperimpose: boolean;
-        /**
-         * @param {boolean}: Color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
-         */
-        private _fresnelSeparate;
-        fresnelSeparate: boolean;
-        /**
-         * @param {boolean}: bump Waves modify the reflection.
-         */
-        private _bumpAffectsReflection;
-        bumpAffectsReflection: boolean;
-        /**
-        * @param {number}: The water color blended with the refraction (near)
-        */
-        waterColor: Color3;
-        /**
-        * @param {number}: The blend factor related to the water color
-        */
-        colorBlendFactor: number;
-        /**
-         * @param {number}: The water color blended with the reflection (far)
-         */
-        waterColor2: Color3;
-        /**
-         * @param {number}: The blend factor related to the water color (reflection, far)
-         */
-        colorBlendFactor2: number;
-        /**
-        * @param {number}: Represents the maximum length of a wave
-        */
-        waveLength: number;
-        /**
-        * @param {number}: Defines the waves speed
-        */
-        waveSpeed: number;
-        protected _renderTargets: SmartArray<RenderTargetTexture>;
-        private _mesh;
-        private _refractionRTT;
-        private _reflectionRTT;
-        private _reflectionTransform;
-        private _lastTime;
-        private _lastDeltaTime;
-        private _renderId;
-        private _useLogarithmicDepth;
-        private _waitingRenderList;
-        /**
-         * Gets a boolean indicating that current material needs to register RTT
-         */
-        readonly hasRenderTargetTextures: boolean;
-        /**
-        * Constructor
-        */
-        constructor(name: string, scene: Scene, renderTargetSize?: Vector2);
-        useLogarithmicDepth: boolean;
-        readonly refractionTexture: Nullable<RenderTargetTexture>;
-        readonly reflectionTexture: Nullable<RenderTargetTexture>;
-        addToRenderList(node: any): void;
-        enableRenderTargets(enable: boolean): void;
-        getRenderList(): Nullable<AbstractMesh[]>;
-        readonly renderTargetsEnabled: boolean;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        private _createRenderTargets;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): WaterMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial;
-        static CreateDefaultMesh(name: string, scene: Scene): Mesh;
-    }
-}
-
-
-declare module BABYLON {
-    class FireMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: Nullable<BaseTexture>;
-        private _distortionTexture;
-        distortionTexture: Nullable<BaseTexture>;
-        private _opacityTexture;
-        opacityTexture: Nullable<BaseTexture>;
-        diffuseColor: Color3;
-        speed: number;
-        private _scaledDiffuse;
-        private _renderId;
-        private _lastTime;
-        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;
-        getClassName(): string;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): FireMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): FireMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class FurMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        private _heightTexture;
-        heightTexture: BaseTexture;
-        diffuseColor: Color3;
-        furLength: number;
-        furAngle: number;
-        furColor: Color3;
-        furOffset: number;
-        furSpacing: number;
-        furGravity: Vector3;
-        furSpeed: number;
-        furDensity: number;
-        furOcclusion: number;
-        furTexture: DynamicTexture;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        highLevelFur: boolean;
-        _meshes: AbstractMesh[];
-        private _renderId;
-        private _furTime;
-        constructor(name: string, scene: Scene);
-        furTime: number;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        updateFur(): void;
-        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): FurMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): FurMaterial;
-        static GenerateTexture(name: string, scene: Scene): DynamicTexture;
-        static FurifyMesh(sourceMesh: Mesh, quality: number): Mesh[];
-    }
-}
-
-
-declare module BABYLON {
-    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;
-        private _renderId;
-        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;
-    }
-}
-
-
-declare module BABYLON {
-    class MixMaterial extends PushMaterial {
-        /**
-         * Mix textures
-         */
-        private _mixTexture1;
-        mixTexture1: BaseTexture;
-        private _mixTexture2;
-        mixTexture2: BaseTexture;
-        /**
-         * Diffuse textures
-         */
-        private _diffuseTexture1;
-        diffuseTexture1: Texture;
-        private _diffuseTexture2;
-        diffuseTexture2: Texture;
-        private _diffuseTexture3;
-        diffuseTexture3: Texture;
-        private _diffuseTexture4;
-        diffuseTexture4: Texture;
-        private _diffuseTexture5;
-        diffuseTexture5: Texture;
-        private _diffuseTexture6;
-        diffuseTexture6: Texture;
-        private _diffuseTexture7;
-        diffuseTexture7: Texture;
-        private _diffuseTexture8;
-        diffuseTexture8: Texture;
-        /**
-         * Uniforms
-         */
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): MixMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): MixMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class TriPlanarMaterial extends PushMaterial {
-        mixTexture: BaseTexture;
-        private _diffuseTextureX;
-        diffuseTextureX: BaseTexture;
-        private _diffuseTextureY;
-        diffuseTextureY: BaseTexture;
-        private _diffuseTextureZ;
-        diffuseTextureZ: BaseTexture;
-        private _normalTextureX;
-        normalTextureX: BaseTexture;
-        private _normalTextureY;
-        normalTextureY: BaseTexture;
-        private _normalTextureZ;
-        normalTextureZ: BaseTexture;
-        tileSize: number;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): TriPlanarMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): TriPlanarMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class SkyMaterial extends PushMaterial {
-        luminance: number;
-        turbidity: number;
-        rayleigh: number;
-        mieCoefficient: number;
-        mieDirectionalG: number;
-        distance: number;
-        inclination: number;
-        azimuth: number;
-        sunPosition: Vector3;
-        useSunPosition: boolean;
-        private _cameraPosition;
-        private _renderId;
-        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[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): SkyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    /**
-     * The grid materials allows you to wrap any shape with a grid.
-     * Colors are customizable.
-     */
-    class GridMaterial extends BABYLON.PushMaterial {
-        /**
-         * Main color of the grid (e.g. between lines)
-         */
-        mainColor: Color3;
-        /**
-         * Color of the grid lines.
-         */
-        lineColor: Color3;
-        /**
-         * The scale of the grid compared to unit.
-         */
-        gridRatio: number;
-        /**
-         * Allows setting an offset for the grid lines.
-         */
-        gridOffset: Vector3;
-        /**
-         * The frequency of thicker lines.
-         */
-        majorUnitFrequency: number;
-        /**
-         * The visibility of minor units in the grid.
-         */
-        minorUnitVisibility: number;
-        /**
-         * The grid opacity outside of the lines.
-         */
-        opacity: number;
-        /**
-         * Determine RBG output is premultiplied by alpha value.
-         */
-        preMultiplyAlpha: boolean;
-        private _gridControl;
-        private _renderId;
-        /**
-         * constructor
-         * @param name The name given to the material in order to identify it afterwards.
-         * @param scene The scene the material is used in.
-         */
-        constructor(name: string, scene: Scene);
-        /**
-         * Returns wehter or not the grid requires alpha blending.
-         */
-        needAlphaBlending(): boolean;
-        needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): GridMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): GridMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class CustomShaderStructure {
-        FragmentStore: string;
-        VertexStore: string;
-        constructor();
-    }
-    class ShaderSpecialParts {
-        constructor();
-        Fragment_Begin: string;
-        Fragment_Definitions: string;
-        Fragment_MainBegin: string;
-        Fragment_Custom_Diffuse: string;
-        Fragment_Custom_Alpha: string;
-        Fragment_Before_FragColor: string;
-        Vertex_Begin: string;
-        Vertex_Definitions: string;
-        Vertex_MainBegin: string;
-        Vertex_Before_PositionUpdated: string;
-        Vertex_Before_NormalUpdated: string;
-    }
-    class CustomMaterial extends StandardMaterial {
-        static ShaderIndexer: number;
-        CustomParts: ShaderSpecialParts;
-        _isCreatedShader: boolean;
-        _createdShaderName: string;
-        _customUniform: string[];
-        _newUniforms: string[];
-        _newUniformInstances: any[];
-        _newSamplerInstances: Texture[];
-        FragmentShader: string;
-        VertexShader: string;
-        AttachAfterBind(mesh: Mesh, effect: Effect): void;
-        ReviewUniform(name: string, arr: string[]): string[];
-        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: StandardMaterialDefines): string;
-        constructor(name: string, scene: Scene);
-        AddUniform(name: string, kind: string, param: any): CustomMaterial;
-        Fragment_Begin(shaderPart: string): CustomMaterial;
-        Fragment_Definitions(shaderPart: string): CustomMaterial;
-        Fragment_MainBegin(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
-        Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
-        Vertex_Begin(shaderPart: string): CustomMaterial;
-        Vertex_Definitions(shaderPart: string): CustomMaterial;
-        Vertex_MainBegin(shaderPart: string): CustomMaterial;
-        Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
-        Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class CellMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        _computeHighLevel: boolean;
-        computeHighLevel: boolean;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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;
-        getClassName(): string;
-        clone(name: string): CellMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): CellMaterial;
-    }
-}

dist/preview release/materialsLibrary/babylonjs.materials.module.d.ts

@@ -1,651 +0,0 @@
-
-
-declare module 'babylonjs-materials' { 
-    export = BABYLON; 
-}
-
-declare module BABYLON {
-    class ShadowOnlyMaterial extends PushMaterial {
-        private _renderId;
-        private _activeLight;
-        constructor(name: string, scene: Scene);
-        shadowColor: Color3;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        activeLight: IShadowLight;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        clone(name: string): ShadowOnlyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): ShadowOnlyMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class GradientMaterial extends PushMaterial {
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        topColor: Color3;
-        topColorAlpha: number;
-        bottomColor: Color3;
-        bottomColorAlpha: number;
-        offset: number;
-        scale: number;
-        smoothness: number;
-        disableLighting: boolean;
-        private _scaledDiffuse;
-        private _renderId;
-        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[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): GradientMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): GradientMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class NormalMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): NormalMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): NormalMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class LavaMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        noiseTexture: BaseTexture;
-        fogColor: Color3;
-        speed: number;
-        movingSpeed: number;
-        lowFrequencySpeed: number;
-        fogDensity: number;
-        private _lastTime;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _unlit;
-        unlit: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _scaledDiffuse;
-        private _renderId;
-        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): LavaMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class SimpleMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): SimpleMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): SimpleMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class WaterMaterial extends PushMaterial {
-        renderTargetSize: Vector2;
-        private _bumpTexture;
-        bumpTexture: BaseTexture;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        /**
-        * @param {number}: Represents the wind force
-        */
-        windForce: number;
-        /**
-        * @param {Vector2}: The direction of the wind in the plane (X, Z)
-        */
-        windDirection: Vector2;
-        /**
-        * @param {number}: Wave height, represents the height of the waves
-        */
-        waveHeight: number;
-        /**
-        * @param {number}: Bump height, represents the bump height related to the bump map
-        */
-        bumpHeight: number;
-        /**
-         * @param {boolean}: Add a smaller moving bump to less steady waves.
-         */
-        private _bumpSuperimpose;
-        bumpSuperimpose: boolean;
-        /**
-         * @param {boolean}: Color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
-         */
-        private _fresnelSeparate;
-        fresnelSeparate: boolean;
-        /**
-         * @param {boolean}: bump Waves modify the reflection.
-         */
-        private _bumpAffectsReflection;
-        bumpAffectsReflection: boolean;
-        /**
-        * @param {number}: The water color blended with the refraction (near)
-        */
-        waterColor: Color3;
-        /**
-        * @param {number}: The blend factor related to the water color
-        */
-        colorBlendFactor: number;
-        /**
-         * @param {number}: The water color blended with the reflection (far)
-         */
-        waterColor2: Color3;
-        /**
-         * @param {number}: The blend factor related to the water color (reflection, far)
-         */
-        colorBlendFactor2: number;
-        /**
-        * @param {number}: Represents the maximum length of a wave
-        */
-        waveLength: number;
-        /**
-        * @param {number}: Defines the waves speed
-        */
-        waveSpeed: number;
-        protected _renderTargets: SmartArray<RenderTargetTexture>;
-        private _mesh;
-        private _refractionRTT;
-        private _reflectionRTT;
-        private _reflectionTransform;
-        private _lastTime;
-        private _lastDeltaTime;
-        private _renderId;
-        private _useLogarithmicDepth;
-        private _waitingRenderList;
-        /**
-         * Gets a boolean indicating that current material needs to register RTT
-         */
-        readonly hasRenderTargetTextures: boolean;
-        /**
-        * Constructor
-        */
-        constructor(name: string, scene: Scene, renderTargetSize?: Vector2);
-        useLogarithmicDepth: boolean;
-        readonly refractionTexture: Nullable<RenderTargetTexture>;
-        readonly reflectionTexture: Nullable<RenderTargetTexture>;
-        addToRenderList(node: any): void;
-        enableRenderTargets(enable: boolean): void;
-        getRenderList(): Nullable<AbstractMesh[]>;
-        readonly renderTargetsEnabled: boolean;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        private _createRenderTargets;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): WaterMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial;
-        static CreateDefaultMesh(name: string, scene: Scene): Mesh;
-    }
-}
-
-
-declare module BABYLON {
-    class FireMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: Nullable<BaseTexture>;
-        private _distortionTexture;
-        distortionTexture: Nullable<BaseTexture>;
-        private _opacityTexture;
-        opacityTexture: Nullable<BaseTexture>;
-        diffuseColor: Color3;
-        speed: number;
-        private _scaledDiffuse;
-        private _renderId;
-        private _lastTime;
-        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;
-        getClassName(): string;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): FireMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): FireMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class FurMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        private _heightTexture;
-        heightTexture: BaseTexture;
-        diffuseColor: Color3;
-        furLength: number;
-        furAngle: number;
-        furColor: Color3;
-        furOffset: number;
-        furSpacing: number;
-        furGravity: Vector3;
-        furSpeed: number;
-        furDensity: number;
-        furOcclusion: number;
-        furTexture: DynamicTexture;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        highLevelFur: boolean;
-        _meshes: AbstractMesh[];
-        private _renderId;
-        private _furTime;
-        constructor(name: string, scene: Scene);
-        furTime: number;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        updateFur(): void;
-        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): FurMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): FurMaterial;
-        static GenerateTexture(name: string, scene: Scene): DynamicTexture;
-        static FurifyMesh(sourceMesh: Mesh, quality: number): Mesh[];
-    }
-}
-
-
-declare module BABYLON {
-    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;
-        private _renderId;
-        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;
-    }
-}
-
-
-declare module BABYLON {
-    class MixMaterial extends PushMaterial {
-        /**
-         * Mix textures
-         */
-        private _mixTexture1;
-        mixTexture1: BaseTexture;
-        private _mixTexture2;
-        mixTexture2: BaseTexture;
-        /**
-         * Diffuse textures
-         */
-        private _diffuseTexture1;
-        diffuseTexture1: Texture;
-        private _diffuseTexture2;
-        diffuseTexture2: Texture;
-        private _diffuseTexture3;
-        diffuseTexture3: Texture;
-        private _diffuseTexture4;
-        diffuseTexture4: Texture;
-        private _diffuseTexture5;
-        diffuseTexture5: Texture;
-        private _diffuseTexture6;
-        diffuseTexture6: Texture;
-        private _diffuseTexture7;
-        diffuseTexture7: Texture;
-        private _diffuseTexture8;
-        diffuseTexture8: Texture;
-        /**
-         * Uniforms
-         */
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): MixMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): MixMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class TriPlanarMaterial extends PushMaterial {
-        mixTexture: BaseTexture;
-        private _diffuseTextureX;
-        diffuseTextureX: BaseTexture;
-        private _diffuseTextureY;
-        diffuseTextureY: BaseTexture;
-        private _diffuseTextureZ;
-        diffuseTextureZ: BaseTexture;
-        private _normalTextureX;
-        normalTextureX: BaseTexture;
-        private _normalTextureY;
-        normalTextureY: BaseTexture;
-        private _normalTextureZ;
-        normalTextureZ: BaseTexture;
-        tileSize: number;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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): TriPlanarMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): TriPlanarMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class SkyMaterial extends PushMaterial {
-        luminance: number;
-        turbidity: number;
-        rayleigh: number;
-        mieCoefficient: number;
-        mieDirectionalG: number;
-        distance: number;
-        inclination: number;
-        azimuth: number;
-        sunPosition: Vector3;
-        useSunPosition: boolean;
-        private _cameraPosition;
-        private _renderId;
-        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[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): SkyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    /**
-     * The grid materials allows you to wrap any shape with a grid.
-     * Colors are customizable.
-     */
-    class GridMaterial extends BABYLON.PushMaterial {
-        /**
-         * Main color of the grid (e.g. between lines)
-         */
-        mainColor: Color3;
-        /**
-         * Color of the grid lines.
-         */
-        lineColor: Color3;
-        /**
-         * The scale of the grid compared to unit.
-         */
-        gridRatio: number;
-        /**
-         * Allows setting an offset for the grid lines.
-         */
-        gridOffset: Vector3;
-        /**
-         * The frequency of thicker lines.
-         */
-        majorUnitFrequency: number;
-        /**
-         * The visibility of minor units in the grid.
-         */
-        minorUnitVisibility: number;
-        /**
-         * The grid opacity outside of the lines.
-         */
-        opacity: number;
-        /**
-         * Determine RBG output is premultiplied by alpha value.
-         */
-        preMultiplyAlpha: boolean;
-        private _gridControl;
-        private _renderId;
-        /**
-         * constructor
-         * @param name The name given to the material in order to identify it afterwards.
-         * @param scene The scene the material is used in.
-         */
-        constructor(name: string, scene: Scene);
-        /**
-         * Returns wehter or not the grid requires alpha blending.
-         */
-        needAlphaBlending(): boolean;
-        needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): GridMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): GridMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class CustomShaderStructure {
-        FragmentStore: string;
-        VertexStore: string;
-        constructor();
-    }
-    class ShaderSpecialParts {
-        constructor();
-        Fragment_Begin: string;
-        Fragment_Definitions: string;
-        Fragment_MainBegin: string;
-        Fragment_Custom_Diffuse: string;
-        Fragment_Custom_Alpha: string;
-        Fragment_Before_FragColor: string;
-        Vertex_Begin: string;
-        Vertex_Definitions: string;
-        Vertex_MainBegin: string;
-        Vertex_Before_PositionUpdated: string;
-        Vertex_Before_NormalUpdated: string;
-    }
-    class CustomMaterial extends StandardMaterial {
-        static ShaderIndexer: number;
-        CustomParts: ShaderSpecialParts;
-        _isCreatedShader: boolean;
-        _createdShaderName: string;
-        _customUniform: string[];
-        _newUniforms: string[];
-        _newUniformInstances: any[];
-        _newSamplerInstances: Texture[];
-        FragmentShader: string;
-        VertexShader: string;
-        AttachAfterBind(mesh: Mesh, effect: Effect): void;
-        ReviewUniform(name: string, arr: string[]): string[];
-        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: StandardMaterialDefines): string;
-        constructor(name: string, scene: Scene);
-        AddUniform(name: string, kind: string, param: any): CustomMaterial;
-        Fragment_Begin(shaderPart: string): CustomMaterial;
-        Fragment_Definitions(shaderPart: string): CustomMaterial;
-        Fragment_MainBegin(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
-        Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
-        Vertex_Begin(shaderPart: string): CustomMaterial;
-        Vertex_Definitions(shaderPart: string): CustomMaterial;
-        Vertex_MainBegin(shaderPart: string): CustomMaterial;
-        Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
-        Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
-    }
-}
-
-
-declare module BABYLON {
-    class CellMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        _computeHighLevel: boolean;
-        computeHighLevel: boolean;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        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;
-        getClassName(): string;
-        clone(name: string): CellMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): CellMaterial;
-    }
-}

dist/preview release/postProcessesLibrary/babylon.postProcesses.module.d.ts

@@ -3,19 +3,19 @@
 //   ../../../../Tools/Gulp/babylonjs
 
 declare module 'babylonjs-postProcessLibrary' {
-    export * from "babylonjs-postProcessLibrary/asciiArt";
-    export * from "babylonjs-postProcessLibrary/digitalRain";
+    export * from "babylonjs-postProcessLibrary/src/asciiArt";
+    export * from "babylonjs-postProcessLibrary/src/digitalRain";
 }
 
-declare module 'babylonjs-postProcessLibrary/asciiArt' {
-    export * from "babylonjs-postProcessLibrary/asciiArt/asciiArtPostProcess";
+declare module 'babylonjs-postProcessLibrary/src/asciiArt' {
+    export * from "babylonjs-postProcessLibrary/src/asciiArt/asciiArtPostProcess";
 }
 
-declare module 'babylonjs-postProcessLibrary/digitalRain' {
-    export * from "babylonjs-postProcessLibrary/digitalRain/digitalRainPostProcess";
+declare module 'babylonjs-postProcessLibrary/src/digitalRain' {
+    export * from "babylonjs-postProcessLibrary/src/digitalRain/digitalRainPostProcess";
 }
 
-declare module 'babylonjs-postProcessLibrary/asciiArt/asciiArtPostProcess' {
+declare module 'babylonjs-postProcessLibrary/src/asciiArt/asciiArtPostProcess' {
     import { BaseTexture, Nullable, Scene, PostProcess, Camera } from "babylonjs";
     /**
         * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
@@ -99,7 +99,7 @@ declare module 'babylonjs-postProcessLibrary/asciiArt/asciiArtPostProcess' {
     }
 }
 
-declare module 'babylonjs-postProcessLibrary/digitalRain/digitalRainPostProcess' {
+declare module 'babylonjs-postProcessLibrary/src/digitalRain/digitalRainPostProcess' {
     import { BaseTexture, Nullable, Scene, PostProcess, Camera } from "babylonjs";
     /**
         * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.

materialsLibrary/legacy/legacy-cell.ts

@@ -0,0 +1,15 @@
+import * as postProcessLibrary from "../src/cell/index";
+
+/**
+ *
+ * This is the entry point for the UMD module.
+ * The entry point for a future ESM package should be index.ts
+ */
+var globalObject = (typeof global !== 'undefined') ? global : ((typeof window !== 'undefined') ? window : undefined);
+if (typeof globalObject !== "undefined") {
+    for (var key in postProcessLibrary) {
+        (<any>globalObject).BABYLON[key] = (<any>postProcessLibrary)[key];
+    }
+}
+
+export * from "../src/cell/index";

materialsLibrary/legacy/webpack.cell.config.js

@@ -0,0 +1,67 @@
+const path = require('path');
+const webpack = require('webpack');
+const DtsBundleWebpack = require('dts-bundle-webpack');
+const CleanWebpackPlugin = require('clean-webpack-plugin');
+
+module.exports = {
+    context: __dirname,
+    entry: {
+        'babylonjs-materials': path.resolve(__dirname, './legacy-cell.ts'),
+    },
+    output: {
+        path: path.resolve(__dirname, '../dist/preview release/materialsLibrary'),
+        filename: 'babylon.cellMaterial.min.js',
+        libraryTarget: 'umd',
+        library: {
+            root: ["MATLIB"],
+            amd: "babylonjs-materials",
+            commonjs: "babylonjs-materials"
+        },
+        umdNamedDefine: true
+    },
+    resolve: {
+        extensions: [".js", '.ts']
+    },
+    externals: {
+        babylonjs: {
+            root: "BABYLON",
+            commonjs: "babylonjs",
+            commonjs2: "babylonjs",
+            amd: "babylonjs"
+        }
+    },
+    devtool: "source-map",
+    module: {
+        rules: [{
+            test: /\.tsx?$/,
+            loader: "ts-loader",
+            exclude: /node_modules/
+        },
+        {
+            test: /\.fx$/,
+            use: [{
+                loader: path.resolve(__dirname, '../../Tools/WebpackShaderLoader/index.js')
+            }]
+        }]
+    },
+    mode: "production",
+    devServer: {
+        contentBase: path.join(__dirname, "dist"),
+        compress: false,
+        //open: true,
+        port: 9000
+    },
+    plugins: [
+        new CleanWebpackPlugin([
+            path.resolve(__dirname, './src/**/*.js'),
+            path.resolve(__dirname, './src/**/*.map')
+        ]),
+        new webpack.WatchIgnorePlugin([
+            /\.js$/,
+            /\.d\.ts$/
+        ])
+    ],
+    watchOptions: {
+        ignored: [path.resolve(__dirname, './dist/**/*.*'), 'node_modules']
+    }
+}

materialsLibrary/tsconfig.json

@@ -1,31 +1,31 @@
 {
-  "compilerOptions": {
-      "experimentalDecorators": true,
-      "module": "commonjs",
-      "target": "es5",
-      "noImplicitAny": true,
-      "noImplicitReturns": true,
-      "noImplicitThis": true,
-      "noUnusedLocals": true,
-      "strictNullChecks": true,
-      "declaration": true,
-      "sourceMap": true,
-      "lib": [
-          "es5",
-          "dom",
-          "es2015.promise",
-          "es2015.collection",
-          "es2015.iterable"
-      ],
-      "skipDefaultLibCheck": true,
-      "skipLibCheck": true,
-      "baseUrl": "./src/",
-      "rootDir": "./src/",
-      "paths": {
-          "babylonjs": [
-              "../../dist/preview release/babylon.d.ts"
-          ]
-      },
-      "outDir": "./build"
-  }
+    "compilerOptions": {
+        "experimentalDecorators": true,
+        "module": "commonjs",
+        "target": "es5",
+        "noImplicitAny": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "noUnusedLocals": true,
+        "strictNullChecks": true,
+        "declaration": true,
+        "sourceMap": true,
+        "lib": [
+            "es5",
+            "dom",
+            "es2015.promise",
+            "es2015.collection",
+            "es2015.iterable"
+        ],
+        "skipDefaultLibCheck": true,
+        "skipLibCheck": true,
+        "baseUrl": "./src/",
+        "rootDir": "./",
+        "paths": {
+            "babylonjs": [
+                "../../dist/preview release/babylon.d.ts"
+            ]
+        },
+        "outDir": "./build"
+    }
 }

materialsLibrary/webpack.config.js

@@ -9,7 +9,7 @@ module.exports = {
         'babylonjs-materials': path.resolve(__dirname, './src/legacy.ts'),
     },
     output: {
-        path: path.resolve(__dirname, '../dist/preview release/gui'),
+        path: path.resolve(__dirname, '../dist/preview release/materialsLibrary'),
         filename: 'babylon.materials.min.js',
         libraryTarget: 'umd',
         library: {
@@ -17,8 +17,7 @@ module.exports = {
             amd: "babylonjs-materials",
             commonjs: "babylonjs-materials"
         },
-        umdNamedDefine: true,
-        //devtoolModuleFilenameTemplate: "[absolute-resource-path]"
+        umdNamedDefine: true
     },
     resolve: {
         extensions: [".js", '.ts']
@@ -57,14 +56,6 @@ module.exports = {
             path.resolve(__dirname, './src/**/*.js'),
             path.resolve(__dirname, './src/**/*.map')
         ]),
-        // moved out of here due to the way gulp works...
-        /*new DtsBundleWebpack({
-            name: "babylonjs-gui",
-            main: path.resolve(__dirname, '../dist/preview release/gui/build/index.d.ts'),
-            out: path.resolve(__dirname, '../dist/preview release/gui/babylon.gui.module.d.ts'),
-            baseDir: path.resolve(__dirname, '../dist/preview release/gui/build/'),
-            headerText: "BabylonJS GUI"
-        }),*/
         new webpack.WatchIgnorePlugin([
             /\.js$/,
             /\.d\.ts$/