babylonjs-materials 7.15.2 → 7.16.1

package/babylonjs.materials.d.ts

@@ -1,637 +1,625 @@
 
 declare module BABYLON {
-    /** @internal */
-    export var cellPixelShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export var cellVertexShader: {
-        name: string;
-        shader: string;
-    };
 
 
-    export class CellMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
+    export class WaterMaterial extends PushMaterial {
+        renderTargetSize: Vector2;
+        private _bumpTexture;
+        bumpTexture: BaseTexture;
         diffuseColor: Color3;
-        _computeHighLevel: boolean;
-        computeHighLevel: boolean;
+        specularColor: Color3;
+        specularPower: number;
         private _disableLighting;
         disableLighting: boolean;
         private _maxSimultaneousLights;
         maxSimultaneousLights: number;
-        constructor(name: string, scene?: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        getClassName(): string;
-        clone(name: string): CellMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): CellMaterial;
-    }
-
-
-
-
-    /**
-     * Structure of a custom shader
-     */
-    export class CustomShaderStructure {
         /**
-         * Fragment store
+         * Defines the wind force.
          */
-        FragmentStore: string;
+        windForce: number;
         /**
-         * Vertex store
+         * Defines the direction of the wind in the plane (X, Z).
          */
-        VertexStore: string;
-        constructor();
-    }
-    /**
-     * Parts of a shader
-     */
-    export class ShaderSpecialParts {
-        constructor();
+        windDirection: Vector2;
         /**
-         * Beginning of the fragment shader
+         * Defines the height of the waves.
          */
-        Fragment_Begin: string;
+        waveHeight: number;
         /**
-         * Variable definitions of the fragment shader
+         * Defines the bump height related to the bump map.
          */
-        Fragment_Definitions: string;
+        bumpHeight: number;
         /**
-         * Beginning of the fragment main function
+         * Defines wether or not: to add a smaller moving bump to less steady waves.
          */
-        Fragment_MainBegin: string;
+        private _bumpSuperimpose;
+        bumpSuperimpose: boolean;
         /**
-         * End of the fragment main function
+         * Defines wether or not color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
          */
-        Fragment_MainEnd: string;
+        private _fresnelSeparate;
+        fresnelSeparate: boolean;
         /**
-         * Diffuse color calculation
+         * Defines wether or not bump Wwves modify the reflection.
          */
-        Fragment_Custom_Diffuse: string;
+        private _bumpAffectsReflection;
+        bumpAffectsReflection: boolean;
         /**
-         * Before lightning computations
+         * Defines the water color blended with the refraction (near).
          */
-        Fragment_Before_Lights: string;
+        waterColor: Color3;
         /**
-         * Before fog computations
+         * Defines the blend factor related to the water color.
          */
-        Fragment_Before_Fog: string;
+        colorBlendFactor: number;
         /**
-         * Alpha calculations
+         * Defines the water color blended with the reflection (far).
          */
-        Fragment_Custom_Alpha: string;
+        waterColor2: Color3;
         /**
-         * Before frag color is assigned
+         * Defines the blend factor related to the water color (reflection, far).
          */
-        Fragment_Before_FragColor: string;
+        colorBlendFactor2: number;
         /**
-         * Beginning of the vertex shader
+         * Defines the maximum length of a wave.
          */
-        Vertex_Begin: string;
+        waveLength: number;
         /**
-         * Variable definitions of the vertex shader
+         * Defines the waves speed.
          */
-        Vertex_Definitions: string;
+        waveSpeed: number;
         /**
-         * Start of the main function of the vertex shader
+         * Defines the number of times waves are repeated. This is typically used to adjust waves count according to the ground's size where the material is applied on.
          */
-        Vertex_MainBegin: string;
+        waveCount: number;
         /**
-         * Before the world position computation
+         * Sets or gets whether or not automatic clipping should be enabled or not. Setting to true will save performances and
+         * will avoid calculating useless pixels in the pixel shader of the water material.
          */
-        Vertex_Before_PositionUpdated: string;
+        disableClipPlane: boolean;
         /**
-         * Before the normal computation
+         * Defines whether or not to use world coordinates for wave deformations.
+         * The default value is false, meaning that the deformation is applied in object (local) space.
+         * You will probably need to set it to true if you are using instances or thin instances for your water objects.
          */
-        Vertex_Before_NormalUpdated: string;
+        private _useWorldCoordinatesForWaveDeformation;
+        useWorldCoordinatesForWaveDeformation: boolean;
+        protected _renderTargets: SmartArray<RenderTargetTexture>;
+        private _mesh;
+        private _refractionRTT;
+        private _reflectionRTT;
+        private _reflectionTransform;
+        private _lastTime;
+        private _lastDeltaTime;
+        private _waitingRenderList;
+        private _imageProcessingConfiguration;
+        private _imageProcessingObserver;
         /**
-         * After the world position has been computed
+         * Gets a boolean indicating that current material needs to register RTT
          */
-        Vertex_After_WorldPosComputed: string;
+        get hasRenderTargetTextures(): boolean;
         /**
-         * Main end of the vertex shader
+         * Constructor
+         * @param name
+         * @param scene
+         * @param renderTargetSize
          */
-        Vertex_MainEnd: string;
+        constructor(name: string, scene?: Scene, renderTargetSize?: Vector2);
+        get refractionTexture(): Nullable<RenderTargetTexture>;
+        get reflectionTexture(): Nullable<RenderTargetTexture>;
+        addToRenderList(node: any): void;
+        removeFromRenderList(node: any): void;
+        enableRenderTargets(enable: boolean): void;
+        getRenderList(): Nullable<AbstractMesh[]>;
+        get 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;
     }
-    /**
-     * Customized material
-     */
-    export class CustomMaterial extends StandardMaterial {
-        /**
-         * Index for each created shader
-         */
-        static ShaderIndexer: number;
-        /**
-         * Custom shader structure
-         */
-        CustomParts: ShaderSpecialParts;
-        /**
-         * Name of the shader
-         */
-        _createdShaderName: string;
-        /**
-         * List of custom uniforms
-         */
-        _customUniform: string[];
-        /**
-         * Names of the new uniforms
-         */
-        _newUniforms: string[];
-        /**
-         * Instances of the new uniform objects
-         */
-        _newUniformInstances: {
-            [name: string]: any;
-        };
-        /**
-         * Instances of the new sampler objects
-         */
-        _newSamplerInstances: {
-            [name: string]: Texture;
-        };
-        /**
-         * List of the custom attributes
-         */
-        _customAttributes: string[];
-        /**
-         * Fragment shader string
-         */
-        FragmentShader: string;
-        /**
-         * Vertex shader string
-         */
-        VertexShader: string;
-        /**
-         * Runs after the material is bound to a mesh
-         * @param mesh mesh bound
-         * @param effect bound effect used to render
-         */
-        AttachAfterBind(mesh: Mesh | undefined, effect: Effect): void;
-        /**
-         * @internal
-         */
-        ReviewUniform(name: string, arr: string[]): string[];
-        /**
-         * Builds the material
-         * @param shaderName name of the shader
-         * @param uniforms list of uniforms
-         * @param uniformBuffers list of uniform buffers
-         * @param samplers list of samplers
-         * @param defines list of defines
-         * @param attributes list of attributes
-         * @returns the shader name
-         */
-        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: MaterialDefines | string[], attributes?: string[]): string;
-        protected _injectCustomCode(code: string, shaderType: string): string;
-        protected _getCustomCode(shaderType: string): {
-            [pointName: string]: string;
-        };
-        constructor(name: string, scene?: Scene);
-        protected _afterBind(mesh?: Mesh, effect?: Nullable<Effect>, subMesh?: SubMesh): void;
-        /**
-         * Adds a new uniform to the shader
-         * @param name the name of the uniform to add
-         * @param kind the type of the uniform to add
-         * @param param the value of the uniform to add
-         * @returns the current material
-         */
-        AddUniform(name: string, kind: string, param: any): CustomMaterial;
-        /**
-         * Adds a custom attribute
-         * @param name the name of the attribute
-         * @returns the current material
-         */
-        AddAttribute(name: string): CustomMaterial;
+
+
+    /** @internal */
+    export var waterVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var waterPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+
+
+    /** @internal */
+    export var triplanarVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var triplanarPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    export 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;
+        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;
+    }
+
+
+
+
+    export class TerrainMaterial extends PushMaterial {
+        private _mixTexture;
+        mixTexture: BaseTexture;
+        private _diffuseTexture1;
+        diffuseTexture1: Texture;
+        private _diffuseTexture2;
+        diffuseTexture2: Texture;
+        private _diffuseTexture3;
+        diffuseTexture3: Texture;
+        private _bumpTexture1;
+        bumpTexture1: Texture;
+        private _bumpTexture2;
+        bumpTexture2: Texture;
+        private _bumpTexture3;
+        bumpTexture3: Texture;
+        diffuseColor: Color3;
+        specularColor: Color3;
+        specularPower: number;
+        private _disableLighting;
+        disableLighting: boolean;
+        private _maxSimultaneousLights;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene?: Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        getAnimatables(): IAnimatable[];
+        getActiveTextures(): BaseTexture[];
+        hasTexture(texture: BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): TerrainMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: Scene, rootUrl: string): TerrainMaterial;
+    }
+
+
+    /** @internal */
+    export var terrainVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var terrainPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+
+
+    /**
+     * This is the sky material which allows to create dynamic and texture free effects for skyboxes.
+     * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
+     */
+    export class SkyMaterial extends PushMaterial {
         /**
-         * Sets the code on Fragment_Begin portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the overall luminance of sky in interval ]0, 1[.
          */
-        Fragment_Begin(shaderPart: string): CustomMaterial;
+        luminance: number;
         /**
-         * Sets the code on Fragment_Definitions portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the amount (scattering) of haze as opposed to molecules in atmosphere.
          */
-        Fragment_Definitions(shaderPart: string): CustomMaterial;
+        turbidity: number;
         /**
-         * Sets the code on Fragment_MainBegin portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the sky appearance (light intensity).
          */
-        Fragment_MainBegin(shaderPart: string): CustomMaterial;
+        rayleigh: number;
         /**
-         * Sets the code on Fragment_MainEnd portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the mieCoefficient in interval [0, 0.1] which affects the property .mieDirectionalG.
          */
-        Fragment_MainEnd(shaderPart: string): CustomMaterial;
+        mieCoefficient: number;
         /**
-         * Sets the code on Fragment_Custom_Diffuse portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the amount of haze particles following the Mie scattering theory.
          */
-        Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
+        mieDirectionalG: number;
         /**
-         * Sets the code on Fragment_Custom_Alpha portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the distance of the sun according to the active scene camera.
          */
-        Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
+        distance: number;
         /**
-         * Sets the code on Fragment_Before_Lights portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the sun inclination, in interval [-0.5, 0.5]. When the inclination is not 0, the sun is said
+         * "inclined".
          */
-        Fragment_Before_Lights(shaderPart: string): CustomMaterial;
+        inclination: number;
         /**
-         * Sets the code on Fragment_Before_Fog portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the solar azimuth in interval [0, 1]. The azimuth is the angle in the horizontal plan between
+         * an object direction and a reference direction.
          */
-        Fragment_Before_Fog(shaderPart: string): CustomMaterial;
+        azimuth: number;
         /**
-         * Sets the code on Fragment_Before_FragColor portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the sun position in the sky on (x,y,z). If the property .useSunPosition is set to false, then
+         * the property is overridden by the inclination and the azimuth and can be read at any moment.
          */
-        Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
+        sunPosition: Vector3;
         /**
-         * Sets the code on Vertex_Begin portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines if the sun position should be computed (inclination and azimuth) according to the given
+         * .sunPosition property.
          */
-        Vertex_Begin(shaderPart: string): CustomMaterial;
+        useSunPosition: boolean;
         /**
-         * Sets the code on Vertex_Definitions portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines an offset vector used to get a horizon offset.
+         * @example skyMaterial.cameraOffset.y = camera.globalPosition.y // Set horizon relative to 0 on the Y axis
          */
-        Vertex_Definitions(shaderPart: string): CustomMaterial;
+        cameraOffset: Vector3;
         /**
-         * Sets the code on Vertex_MainBegin portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines the vector the skyMaterial should consider as up. (default is Vector3(0, 1, 0) as returned by Vector3.Up())
          */
-        Vertex_MainBegin(shaderPart: string): CustomMaterial;
+        up: Vector3;
         /**
-         * Sets the code on Vertex_Before_PositionUpdated portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Defines if sky should be dithered.
          */
-        Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
+        dithering: boolean;
+        private _cameraPosition;
+        private _skyOrientation;
         /**
-         * Sets the code on Vertex_Before_NormalUpdated portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Instantiates a new sky material.
+         * This material allows to create dynamic and texture free
+         * effects for skyboxes by taking care of the atmosphere state.
+         * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
+         * @param name Define the name of the material in the scene
+         * @param scene Define the scene the material belong to
          */
-        Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
+        constructor(name: string, scene?: Scene);
         /**
-         * Sets the code on Vertex_After_WorldPosComputed portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Specifies if the material will require alpha blending
+         * @returns a boolean specifying if alpha blending is needed
          */
-        Vertex_After_WorldPosComputed(shaderPart: string): CustomMaterial;
+        needAlphaBlending(): boolean;
         /**
-         * Sets the code on Vertex_MainEnd portion
-         * @param shaderPart the code string
-         * @returns the current material
+         * Specifies if this material should be rendered in alpha test mode
+         * @returns false as the sky material doesn't need alpha testing.
          */
-        Vertex_MainEnd(shaderPart: string): CustomMaterial;
-    }
-
-
-
-
-    /**
-     * Albedo parts of the shader
-     */
-    export class ShaderAlbedoParts {
-        constructor();
+        needAlphaTesting(): boolean;
         /**
-         * Beginning of the fragment shader
+         * Get the texture used for alpha test purpose.
+         * @returns null as the sky material has no texture.
          */
-        Fragment_Begin: string;
-        /**
-         * Fragment definitions
-         */
-        Fragment_Definitions: string;
-        /**
-         * Beginning of the main function
-         */
-        Fragment_MainBegin: string;
-        /**
-         * End of main function
-         */
-        Fragment_MainEnd: string;
-        /**
-         * Albedo color
-         */
-        Fragment_Custom_Albedo: string;
-        /**
-         * Lights
-         */
-        Fragment_Before_Lights: string;
-        /**
-         * Metallic and roughness
-         */
-        Fragment_Custom_MetallicRoughness: string;
-        /**
-         * Microsurface
-         */
-        Fragment_Custom_MicroSurface: string;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
         /**
-         * Fog computations
+         * Get if the submesh is ready to be used and all its information available.
+         * Child classes can use it to update shaders
+         * @param mesh defines the mesh to check
+         * @param subMesh defines which submesh to check
+         * @returns a boolean indicating that the submesh is ready or not
          */
-        Fragment_Before_Fog: string;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
         /**
-         * Alpha
+         * Binds the submesh to this material by preparing the effect and shader to draw
+         * @param world defines the world transformation matrix
+         * @param mesh defines the mesh containing the submesh
+         * @param subMesh defines the submesh to bind the material to
          */
-        Fragment_Custom_Alpha: string;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
         /**
-         * Color composition
+         * Get the list of animatables in the material.
+         * @returns the list of animatables object used in the material
          */
-        Fragment_Before_FinalColorComposition: string;
+        getAnimatables(): IAnimatable[];
         /**
-         * Fragment color
+         * Disposes the material
+         * @param forceDisposeEffect specifies if effects should be forcefully disposed
          */
-        Fragment_Before_FragColor: string;
+        dispose(forceDisposeEffect?: boolean): void;
         /**
-         * Beginning of vertex shader
+         * Makes a duplicate of the material, and gives it a new name
+         * @param name defines the new name for the duplicated material
+         * @returns the cloned material
          */
-        Vertex_Begin: string;
+        clone(name: string): SkyMaterial;
         /**
-         * Vertex definitions
+         * Serializes this material in a JSON representation
+         * @returns the serialized material object
          */
-        Vertex_Definitions: string;
+        serialize(): any;
         /**
-         * Vertex main begin
+         * Gets the current class name of the material e.g. "SkyMaterial"
+         * Mainly use in serialization.
+         * @returns the class name
          */
-        Vertex_MainBegin: string;
+        getClassName(): string;
         /**
-         * Vertex before position updated
+         * Creates a sky material from parsed material data
+         * @param source defines the JSON representation of the material
+         * @param scene defines the hosting scene
+         * @param rootUrl defines the root URL to use to load textures and relative dependencies
+         * @returns a new sky material
          */
-        Vertex_Before_PositionUpdated: string;
+        static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial;
+    }
+
+
+    /** @internal */
+    export var skyVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var skyPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+
+
+    export class SimpleMaterial extends PushMaterial {
+        private _diffuseTexture;
+        diffuseTexture: BaseTexture;
+        diffuseColor: Color3;
+        private _disableLighting;
+        disableLighting: boolean;
+        private _maxSimultaneousLights;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene?: Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
+        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        getAnimatables(): IAnimatable[];
+        getActiveTextures(): BaseTexture[];
+        hasTexture(texture: BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): SimpleMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: Scene, rootUrl: string): SimpleMaterial;
+    }
+
+
+    /** @internal */
+    export var simpleVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var simplePixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+
+
+    export class ShadowOnlyMaterial extends PushMaterial {
+        private _activeLight;
+        private _needAlphaBlending;
+        constructor(name: string, scene?: Scene);
+        shadowColor: Color3;
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): Nullable<BaseTexture>;
+        get activeLight(): IShadowLight;
+        set activeLight(light: IShadowLight);
+        private _getFirstShadowLightForMesh;
+        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;
+    }
+
+
+    /** @internal */
+    export var shadowOnlyVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var shadowOnlyPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+
+
+    export class NormalMaterial extends PushMaterial {
+        private _diffuseTexture;
+        diffuseTexture: BaseTexture;
+        diffuseColor: Color3;
+        private _disableLighting;
+        disableLighting: boolean;
+        private _maxSimultaneousLights;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene?: Scene);
+        needAlphaBlending(): boolean;
+        needAlphaBlendingForMesh(mesh: AbstractMesh): 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;
+    }
+
+
+    /** @internal */
+    export var normalVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var normalPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+
+
+    export class MixMaterial extends PushMaterial {
         /**
-         * Vertex before normal updated
+         * Mix textures
          */
-        Vertex_Before_NormalUpdated: string;
+        private _mixTexture1;
+        mixTexture1: BaseTexture;
+        private _mixTexture2;
+        mixTexture2: BaseTexture;
         /**
-         * Vertex after world pos computed
+         * Diffuse textures
          */
-        Vertex_After_WorldPosComputed: string;
+        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;
         /**
-         * Vertex main end
+         * Uniforms
          */
-        Vertex_MainEnd: string;
-    }
-    /**
-     * @deprecated use ShaderAlbedoParts instead.
-     */
-    export var ShaderAlebdoParts: typeof ShaderAlbedoParts;
-    export class PBRCustomMaterial extends PBRMaterial {
-        /**
-         * Index for each created shader
-         */
-        static ShaderIndexer: number;
-        /**
-         * Custom shader structure
-         */
-        CustomParts: ShaderAlbedoParts;
-        /**
-         * Name of the shader
-         */
-        _createdShaderName: string;
-        /**
-         * List of custom uniforms
-         */
-        _customUniform: string[];
-        /**
-         * Names of the new uniforms
-         */
-        _newUniforms: string[];
-        /**
-         * Instances of the new uniform objects
-         */
-        _newUniformInstances: {
-            [name: string]: any;
-        };
-        /**
-         * Instances of the new sampler objects
-         */
-        _newSamplerInstances: {
-            [name: string]: Texture;
-        };
-        /**
-         * List of the custom attributes
-         */
-        _customAttributes: string[];
-        /**
-         * Fragment shader string
-         */
-        FragmentShader: string;
-        /**
-         * Vertex shader string
-         */
-        VertexShader: string;
-        /**
-         * Runs after the material is bound to a mesh
-         * @param mesh mesh bound
-         * @param effect bound effect used to render
-         */
-        AttachAfterBind(mesh: Mesh | undefined, effect: Effect): void;
-        /**
-         * @internal
-         */
-        ReviewUniform(name: string, arr: string[]): string[];
-        /**
-         * Builds the material
-         * @param shaderName name of the shader
-         * @param uniforms list of uniforms
-         * @param uniformBuffers list of uniform buffers
-         * @param samplers list of samplers
-         * @param defines list of defines
-         * @param attributes list of attributes
-         * @param options options to compile the shader
-         * @returns the shader name
-         */
-        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: MaterialDefines | string[], attributes?: string[], options?: ICustomShaderNameResolveOptions): string;
-        protected _injectCustomCode(code: string, shaderType: string): string;
-        protected _getCustomCode(shaderType: string): {
-            [pointName: string]: string;
-        };
+        diffuseColor: Color3;
+        specularColor: Color3;
+        specularPower: number;
+        private _disableLighting;
+        disableLighting: boolean;
+        private _maxSimultaneousLights;
+        maxSimultaneousLights: number;
         constructor(name: string, scene?: Scene);
-        protected _afterBind(mesh?: Mesh, effect?: Nullable<Effect>, subMesh?: SubMesh): void;
-        /**
-         * Adds a new uniform to the shader
-         * @param name the name of the uniform to add
-         * @param kind the type of the uniform to add
-         * @param param the value of the uniform to add
-         * @returns the current material
-         */
-        AddUniform(name: string, kind: string, param: any): PBRCustomMaterial;
-        /**
-         * Adds a custom attribute
-         * @param name the name of the attribute
-         * @returns the current material
-         */
-        AddAttribute(name: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Begin portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Begin(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Definitions portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Definitions(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_MainBegin portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_MainBegin(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Custom_Albedo portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Custom_Albedo(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Custom_Alpha portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Custom_Alpha(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Before_Lights portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Before_Lights(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Custom_MetallicRoughness portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Custom_MetallicRoughness(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Custom_MicroSurface portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Custom_MicroSurface(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Before_Fog portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Before_Fog(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Before_FinalColorComposition portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Before_FinalColorComposition(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_Before_FragColor portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_Before_FragColor(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Fragment_MainEnd portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Fragment_MainEnd(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Vertex_Begin portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Vertex_Begin(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Vertex_Definitions portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Vertex_Definitions(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Vertex_MainBegin portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Vertex_MainBegin(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Vertex_Before_PositionUpdated portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Vertex_Before_PositionUpdated(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Vertex_Before_NormalUpdated portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Vertex_Before_NormalUpdated(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Vertex_After_WorldPosComputed portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Vertex_After_WorldPosComputed(shaderPart: string): PBRCustomMaterial;
-        /**
-         * Sets the code on Vertex_MainEnd portion
-         * @param shaderPart the code string
-         * @returns the current material
-         */
-        Vertex_MainEnd(shaderPart: string): PBRCustomMaterial;
+        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;
     }
 
 
     /** @internal */
-    export var firePixelShader: {
+    export var mixVertexShader: {
         name: string;
         shader: string;
     };
 
 
     /** @internal */
-    export var fireVertexShader: {
+    export var mixPixelShader: {
         name: string;
         shader: string;
     };
 
 
-    export class FireMaterial extends PushMaterial {
+
+
+    export class LavaMaterial extends PushMaterial {
         private _diffuseTexture;
-        diffuseTexture: Nullable<BaseTexture>;
-        private _distortionTexture;
-        distortionTexture: Nullable<BaseTexture>;
-        private _opacityTexture;
-        opacityTexture: Nullable<BaseTexture>;
-        diffuseColor: Color3;
+        diffuseTexture: BaseTexture;
+        noiseTexture: BaseTexture;
+        fogColor: Color3;
         speed: number;
-        private _scaledDiffuse;
+        movingSpeed: number;
+        lowFrequencySpeed: number;
+        fogDensity: number;
         private _lastTime;
+        diffuseColor: Color3;
+        private _disableLighting;
+        disableLighting: boolean;
+        private _unlit;
+        unlit: boolean;
+        private _maxSimultaneousLights;
+        maxSimultaneousLights: number;
+        private _scaledDiffuse;
         constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
@@ -641,132 +629,30 @@ declare module BABYLON {
         getAnimatables(): IAnimatable[];
         getActiveTextures(): BaseTexture[];
         hasTexture(texture: BaseTexture): boolean;
-        getClassName(): string;
         dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): FireMaterial;
+        clone(name: string): LavaMaterial;
         serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): FireMaterial;
+        getClassName(): string;
+        static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial;
     }
 
 
-
-
     /** @internal */
-    export var furPixelShader: {
+    export var lavaVertexShader: {
         name: string;
         shader: string;
     };
 
 
     /** @internal */
-    export var furVertexShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    export 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 _furTime;
-        constructor(name: string, scene?: Scene);
-        get furTime(): number;
-        set furTime(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[];
-    }
-
-
-
-
-    /** @internal */
-    export var gradientPixelShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export var gradientVertexShader: {
+    export var lavaPixelShader: {
         name: string;
         shader: string;
     };
 
 
-    export class GradientMaterial extends PushMaterial {
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        topColor: Color3;
-        topColorAlpha: number;
-        bottomColor: Color3;
-        bottomColorAlpha: number;
-        offset: number;
-        scale: number;
-        smoothness: number;
-        private _disableLighting;
-        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;
-    }
-
-
-
-
-    /** @internal */
-    export var gridPixelShader: {
-        name: string;
-        shader: string;
-    };
 
 
-    /** @internal */
-    export var gridVertexShader: {
-        name: string;
-        shader: string;
-    };
 
 
     /**
@@ -845,44 +731,34 @@ declare module BABYLON {
     }
 
 
-
-
-
-
-
-
     /** @internal */
-    export var lavaPixelShader: {
+    export var gridVertexShader: {
         name: string;
         shader: string;
     };
 
 
     /** @internal */
-    export var lavaVertexShader: {
+    export var gridPixelShader: {
         name: string;
         shader: string;
     };
 
 
-    export 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;
+
+
+    export class GradientMaterial extends PushMaterial {
         private _maxSimultaneousLights;
         maxSimultaneousLights: number;
-        private _scaledDiffuse;
+        topColor: Color3;
+        topColorAlpha: number;
+        bottomColor: Color3;
+        bottomColorAlpha: number;
+        offset: number;
+        scale: number;
+        smoothness: number;
+        private _disableLighting;
+        disableLighting: boolean;
         constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
@@ -890,113 +766,104 @@ declare module BABYLON {
         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;
+        clone(name: string): GradientMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial;
+        static Parse(source: any, scene: Scene, rootUrl: string): GradientMaterial;
     }
 
 
-
-
     /** @internal */
-    export var mixPixelShader: {
+    export var gradientVertexShader: {
         name: string;
         shader: string;
     };
 
 
     /** @internal */
-    export var mixVertexShader: {
+    export var gradientPixelShader: {
         name: string;
         shader: string;
     };
 
 
-    export 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
-         */
+
+
+    export class FurMaterial extends PushMaterial {
+        private _diffuseTexture;
+        diffuseTexture: BaseTexture;
+        private _heightTexture;
+        heightTexture: BaseTexture;
         diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
+        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 _furTime;
         constructor(name: string, scene?: Scene);
+        get furTime(): number;
+        set furTime(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): MixMaterial;
+        clone(name: string): FurMaterial;
         serialize(): any;
         getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): MixMaterial;
+        static Parse(source: any, scene: Scene, rootUrl: string): FurMaterial;
+        static GenerateTexture(name: string, scene: Scene): DynamicTexture;
+        static FurifyMesh(sourceMesh: Mesh, quality: number): Mesh[];
     }
 
 
-
-
     /** @internal */
-    export var normalPixelShader: {
+    export var furVertexShader: {
         name: string;
         shader: string;
     };
 
 
     /** @internal */
-    export var normalVertexShader: {
+    export var furPixelShader: {
         name: string;
         shader: string;
     };
 
 
-    export class NormalMaterial extends PushMaterial {
+
+
+    export class FireMaterial extends PushMaterial {
         private _diffuseTexture;
-        diffuseTexture: BaseTexture;
+        diffuseTexture: Nullable<BaseTexture>;
+        private _distortionTexture;
+        distortionTexture: Nullable<BaseTexture>;
+        private _opacityTexture;
+        opacityTexture: Nullable<BaseTexture>;
         diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
+        speed: number;
+        private _scaledDiffuse;
+        private _lastTime;
         constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
-        needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
         isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
@@ -1004,502 +871,635 @@ declare module BABYLON {
         getAnimatables(): IAnimatable[];
         getActiveTextures(): BaseTexture[];
         hasTexture(texture: BaseTexture): boolean;
+        getClassName(): string;
         dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): NormalMaterial;
+        clone(name: string): FireMaterial;
         serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): NormalMaterial;
+        static Parse(source: any, scene: Scene, rootUrl: string): FireMaterial;
     }
 
 
-
-
     /** @internal */
-    export var shadowOnlyPixelShader: {
+    export var fireVertexShader: {
         name: string;
         shader: string;
     };
 
 
     /** @internal */
-    export var shadowOnlyVertexShader: {
+    export var firePixelShader: {
         name: string;
         shader: string;
     };
 
 
-    export class ShadowOnlyMaterial extends PushMaterial {
-        private _activeLight;
-        private _needAlphaBlending;
-        constructor(name: string, scene?: Scene);
-        shadowColor: Color3;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        get activeLight(): IShadowLight;
-        set activeLight(light: IShadowLight);
-        private _getFirstShadowLightForMesh;
-        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;
+    /**
+     * Albedo parts of the shader
+     */
+    export class ShaderAlbedoParts {
+        constructor();
+        /**
+         * Beginning of the fragment shader
+         */
+        Fragment_Begin: string;
+        /**
+         * Fragment definitions
+         */
+        Fragment_Definitions: string;
+        /**
+         * Beginning of the main function
+         */
+        Fragment_MainBegin: string;
+        /**
+         * End of main function
+         */
+        Fragment_MainEnd: string;
+        /**
+         * Albedo color
+         */
+        Fragment_Custom_Albedo: string;
+        /**
+         * Lights
+         */
+        Fragment_Before_Lights: string;
+        /**
+         * Metallic and roughness
+         */
+        Fragment_Custom_MetallicRoughness: string;
+        /**
+         * Microsurface
+         */
+        Fragment_Custom_MicroSurface: string;
+        /**
+         * Fog computations
+         */
+        Fragment_Before_Fog: string;
+        /**
+         * Alpha
+         */
+        Fragment_Custom_Alpha: string;
+        /**
+         * Color composition
+         */
+        Fragment_Before_FinalColorComposition: string;
+        /**
+         * Fragment color
+         */
+        Fragment_Before_FragColor: string;
+        /**
+         * Beginning of vertex shader
+         */
+        Vertex_Begin: string;
+        /**
+         * Vertex definitions
+         */
+        Vertex_Definitions: string;
+        /**
+         * Vertex main begin
+         */
+        Vertex_MainBegin: string;
+        /**
+         * Vertex before position updated
+         */
+        Vertex_Before_PositionUpdated: string;
+        /**
+         * Vertex before normal updated
+         */
+        Vertex_Before_NormalUpdated: string;
+        /**
+         * Vertex after world pos computed
+         */
+        Vertex_After_WorldPosComputed: string;
+        /**
+         * Vertex main end
+         */
+        Vertex_MainEnd: string;
     }
-
-
-
-
-    /** @internal */
-    export var simplePixelShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export var simpleVertexShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    export class SimpleMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
+    /**
+     * @deprecated use ShaderAlbedoParts instead.
+     */
+    export var ShaderAlebdoParts: typeof ShaderAlbedoParts;
+    export class PBRCustomMaterial extends PBRMaterial {
+        /**
+         * Index for each created shader
+         */
+        static ShaderIndexer: number;
+        /**
+         * Custom shader structure
+         */
+        CustomParts: ShaderAlbedoParts;
+        /**
+         * Name of the shader
+         */
+        _createdShaderName: string;
+        /**
+         * List of custom uniforms
+         */
+        _customUniform: string[];
+        /**
+         * Names of the new uniforms
+         */
+        _newUniforms: string[];
+        /**
+         * Instances of the new uniform objects
+         */
+        _newUniformInstances: {
+            [name: string]: any;
+        };
+        /**
+         * Instances of the new sampler objects
+         */
+        _newSamplerInstances: {
+            [name: string]: Texture;
+        };
+        /**
+         * List of the custom attributes
+         */
+        _customAttributes: string[];
+        /**
+         * Fragment shader string
+         */
+        FragmentShader: string;
+        /**
+         * Vertex shader string
+         */
+        VertexShader: string;
+        /**
+         * Runs after the material is bound to a mesh
+         * @param mesh mesh bound
+         * @param effect bound effect used to render
+         */
+        AttachAfterBind(mesh: Mesh | undefined, effect: Effect): void;
+        /**
+         * @internal
+         */
+        ReviewUniform(name: string, arr: string[]): string[];
+        /**
+         * Builds the material
+         * @param shaderName name of the shader
+         * @param uniforms list of uniforms
+         * @param uniformBuffers list of uniform buffers
+         * @param samplers list of samplers
+         * @param defines list of defines
+         * @param attributes list of attributes
+         * @param options options to compile the shader
+         * @returns the shader name
+         */
+        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: MaterialDefines | string[], attributes?: string[], options?: ICustomShaderNameResolveOptions): string;
+        protected _injectCustomCode(code: string, shaderType: string): string;
+        protected _getCustomCode(shaderType: string): {
+            [pointName: string]: string;
+        };
         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;
-    }
-
-
-
-
-    /** @internal */
-    export var skyPixelShader: {
-        name: string;
-        shader: string;
-    };
+        protected _afterBind(mesh?: Mesh, effect?: Nullable<Effect>, subMesh?: SubMesh): void;
+        /**
+         * Adds a new uniform to the shader
+         * @param name the name of the uniform to add
+         * @param kind the type of the uniform to add
+         * @param param the value of the uniform to add
+         * @returns the current material
+         */
+        AddUniform(name: string, kind: string, param: any): PBRCustomMaterial;
+        /**
+         * Adds a custom attribute
+         * @param name the name of the attribute
+         * @returns the current material
+         */
+        AddAttribute(name: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Begin portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Begin(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Definitions portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Definitions(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_MainBegin portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_MainBegin(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Custom_Albedo portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Custom_Albedo(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Custom_Alpha portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Custom_Alpha(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Before_Lights portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Before_Lights(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Custom_MetallicRoughness portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Custom_MetallicRoughness(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Custom_MicroSurface portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Custom_MicroSurface(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Before_Fog portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Before_Fog(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Before_FinalColorComposition portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Before_FinalColorComposition(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_Before_FragColor portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_Before_FragColor(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Fragment_MainEnd portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Fragment_MainEnd(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Vertex_Begin portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Vertex_Begin(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Vertex_Definitions portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Vertex_Definitions(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Vertex_MainBegin portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Vertex_MainBegin(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Vertex_Before_PositionUpdated portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Vertex_Before_PositionUpdated(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Vertex_Before_NormalUpdated portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Vertex_Before_NormalUpdated(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Vertex_After_WorldPosComputed portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Vertex_After_WorldPosComputed(shaderPart: string): PBRCustomMaterial;
+        /**
+         * Sets the code on Vertex_MainEnd portion
+         * @param shaderPart the code string
+         * @returns the current material
+         */
+        Vertex_MainEnd(shaderPart: string): PBRCustomMaterial;
+    }
 
 
-    /** @internal */
-    export var skyVertexShader: {
-        name: string;
-        shader: string;
-    };
 
 
     /**
-     * This is the sky material which allows to create dynamic and texture free effects for skyboxes.
-     * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
+     * Structure of a custom shader
      */
-    export class SkyMaterial extends PushMaterial {
+    export class CustomShaderStructure {
         /**
-         * Defines the overall luminance of sky in interval ]0, 1[.
+         * Fragment store
          */
-        luminance: number;
+        FragmentStore: string;
         /**
-         * Defines the amount (scattering) of haze as opposed to molecules in atmosphere.
+         * Vertex store
          */
-        turbidity: number;
+        VertexStore: string;
+        constructor();
+    }
+    /**
+     * Parts of a shader
+     */
+    export class ShaderSpecialParts {
+        constructor();
         /**
-         * Defines the sky appearance (light intensity).
+         * Beginning of the fragment shader
          */
-        rayleigh: number;
+        Fragment_Begin: string;
         /**
-         * Defines the mieCoefficient in interval [0, 0.1] which affects the property .mieDirectionalG.
+         * Variable definitions of the fragment shader
          */
-        mieCoefficient: number;
+        Fragment_Definitions: string;
         /**
-         * Defines the amount of haze particles following the Mie scattering theory.
+         * Beginning of the fragment main function
          */
-        mieDirectionalG: number;
+        Fragment_MainBegin: string;
         /**
-         * Defines the distance of the sun according to the active scene camera.
+         * End of the fragment main function
          */
-        distance: number;
+        Fragment_MainEnd: string;
         /**
-         * Defines the sun inclination, in interval [-0.5, 0.5]. When the inclination is not 0, the sun is said
-         * "inclined".
+         * Diffuse color calculation
          */
-        inclination: number;
+        Fragment_Custom_Diffuse: string;
         /**
-         * Defines the solar azimuth in interval [0, 1]. The azimuth is the angle in the horizontal plan between
-         * an object direction and a reference direction.
+         * Before lightning computations
          */
-        azimuth: number;
+        Fragment_Before_Lights: string;
         /**
-         * Defines the sun position in the sky on (x,y,z). If the property .useSunPosition is set to false, then
-         * the property is overridden by the inclination and the azimuth and can be read at any moment.
+         * Before fog computations
          */
-        sunPosition: Vector3;
+        Fragment_Before_Fog: string;
         /**
-         * Defines if the sun position should be computed (inclination and azimuth) according to the given
-         * .sunPosition property.
+         * Alpha calculations
          */
-        useSunPosition: boolean;
+        Fragment_Custom_Alpha: string;
         /**
-         * Defines an offset vector used to get a horizon offset.
-         * @example skyMaterial.cameraOffset.y = camera.globalPosition.y // Set horizon relative to 0 on the Y axis
+         * Before frag color is assigned
          */
-        cameraOffset: Vector3;
+        Fragment_Before_FragColor: string;
         /**
-         * Defines the vector the skyMaterial should consider as up. (default is Vector3(0, 1, 0) as returned by Vector3.Up())
+         * Beginning of the vertex shader
          */
-        up: Vector3;
+        Vertex_Begin: string;
         /**
-         * Defines if sky should be dithered.
+         * Variable definitions of the vertex shader
          */
-        dithering: boolean;
-        private _cameraPosition;
-        private _skyOrientation;
+        Vertex_Definitions: string;
         /**
-         * Instantiates a new sky material.
-         * This material allows to create dynamic and texture free
-         * effects for skyboxes by taking care of the atmosphere state.
-         * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
-         * @param name Define the name of the material in the scene
-         * @param scene Define the scene the material belong to
+         * Start of the main function of the vertex shader
          */
-        constructor(name: string, scene?: Scene);
+        Vertex_MainBegin: string;
         /**
-         * Specifies if the material will require alpha blending
-         * @returns a boolean specifying if alpha blending is needed
+         * Before the world position computation
          */
-        needAlphaBlending(): boolean;
+        Vertex_Before_PositionUpdated: string;
         /**
-         * Specifies if this material should be rendered in alpha test mode
-         * @returns false as the sky material doesn't need alpha testing.
+         * Before the normal computation
          */
-        needAlphaTesting(): boolean;
+        Vertex_Before_NormalUpdated: string;
         /**
-         * Get the texture used for alpha test purpose.
-         * @returns null as the sky material has no texture.
+         * After the world position has been computed
          */
-        getAlphaTestTexture(): Nullable<BaseTexture>;
+        Vertex_After_WorldPosComputed: string;
         /**
-         * Get if the submesh is ready to be used and all its information available.
-         * Child classes can use it to update shaders
-         * @param mesh defines the mesh to check
-         * @param subMesh defines which submesh to check
-         * @returns a boolean indicating that the submesh is ready or not
+         * Main end of the vertex shader
          */
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean;
+        Vertex_MainEnd: string;
+    }
+    /**
+     * Customized material
+     */
+    export class CustomMaterial extends StandardMaterial {
         /**
-         * Binds the submesh to this material by preparing the effect and shader to draw
-         * @param world defines the world transformation matrix
-         * @param mesh defines the mesh containing the submesh
-         * @param subMesh defines the submesh to bind the material to
+         * Index for each created shader
          */
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
+        static ShaderIndexer: number;
         /**
-         * Get the list of animatables in the material.
-         * @returns the list of animatables object used in the material
+         * Custom shader structure
          */
-        getAnimatables(): IAnimatable[];
+        CustomParts: ShaderSpecialParts;
         /**
-         * Disposes the material
-         * @param forceDisposeEffect specifies if effects should be forcefully disposed
+         * Name of the shader
          */
-        dispose(forceDisposeEffect?: boolean): void;
+        _createdShaderName: string;
         /**
-         * Makes a duplicate of the material, and gives it a new name
-         * @param name defines the new name for the duplicated material
-         * @returns the cloned material
+         * List of custom uniforms
          */
-        clone(name: string): SkyMaterial;
+        _customUniform: string[];
         /**
-         * Serializes this material in a JSON representation
-         * @returns the serialized material object
+         * Names of the new uniforms
          */
-        serialize(): any;
+        _newUniforms: string[];
         /**
-         * Gets the current class name of the material e.g. "SkyMaterial"
-         * Mainly use in serialization.
-         * @returns the class name
+         * Instances of the new uniform objects
          */
-        getClassName(): string;
+        _newUniformInstances: {
+            [name: string]: any;
+        };
         /**
-         * Creates a sky material from parsed material data
-         * @param source defines the JSON representation of the material
-         * @param scene defines the hosting scene
-         * @param rootUrl defines the root URL to use to load textures and relative dependencies
-         * @returns a new sky material
+         * Instances of the new sampler objects
          */
-        static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial;
-    }
-
-
-
-
-    /** @internal */
-    export var terrainPixelShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export var terrainVertexShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    export class TerrainMaterial extends PushMaterial {
-        private _mixTexture;
-        mixTexture: BaseTexture;
-        private _diffuseTexture1;
-        diffuseTexture1: Texture;
-        private _diffuseTexture2;
-        diffuseTexture2: Texture;
-        private _diffuseTexture3;
-        diffuseTexture3: Texture;
-        private _bumpTexture1;
-        bumpTexture1: Texture;
-        private _bumpTexture2;
-        bumpTexture2: Texture;
-        private _bumpTexture3;
-        bumpTexture3: Texture;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        constructor(name: string, scene?: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): TerrainMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): TerrainMaterial;
-    }
-
-
-
-
-    /** @internal */
-    export var triplanarPixelShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export var triplanarVertexShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    export 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;
+        _newSamplerInstances: {
+            [name: string]: Texture;
+        };
+        /**
+         * List of the custom attributes
+         */
+        _customAttributes: string[];
+        /**
+         * Fragment shader string
+         */
+        FragmentShader: string;
+        /**
+         * Vertex shader string
+         */
+        VertexShader: string;
+        /**
+         * Runs after the material is bound to a mesh
+         * @param mesh mesh bound
+         * @param effect bound effect used to render
+         */
+        AttachAfterBind(mesh: Mesh | undefined, effect: Effect): void;
+        /**
+         * @internal
+         */
+        ReviewUniform(name: string, arr: string[]): string[];
+        /**
+         * Builds the material
+         * @param shaderName name of the shader
+         * @param uniforms list of uniforms
+         * @param uniformBuffers list of uniform buffers
+         * @param samplers list of samplers
+         * @param defines list of defines
+         * @param attributes list of attributes
+         * @returns the shader name
+         */
+        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: MaterialDefines | string[], attributes?: string[]): string;
+        protected _injectCustomCode(code: string, shaderType: string): string;
+        protected _getCustomCode(shaderType: string): {
+            [pointName: string]: string;
+        };
         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;
-    }
-
-
-
-
-    /** @internal */
-    export var waterPixelShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export var waterVertexShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    export class WaterMaterial extends PushMaterial {
-        renderTargetSize: Vector2;
-        private _bumpTexture;
-        bumpTexture: BaseTexture;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
+        protected _afterBind(mesh?: Mesh, effect?: Nullable<Effect>, subMesh?: SubMesh): void;
         /**
-         * Defines the wind force.
+         * Adds a new uniform to the shader
+         * @param name the name of the uniform to add
+         * @param kind the type of the uniform to add
+         * @param param the value of the uniform to add
+         * @returns the current material
          */
-        windForce: number;
+        AddUniform(name: string, kind: string, param: any): CustomMaterial;
         /**
-         * Defines the direction of the wind in the plane (X, Z).
+         * Adds a custom attribute
+         * @param name the name of the attribute
+         * @returns the current material
          */
-        windDirection: Vector2;
+        AddAttribute(name: string): CustomMaterial;
         /**
-         * Defines the height of the waves.
+         * Sets the code on Fragment_Begin portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        waveHeight: number;
+        Fragment_Begin(shaderPart: string): CustomMaterial;
         /**
-         * Defines the bump height related to the bump map.
+         * Sets the code on Fragment_Definitions portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        bumpHeight: number;
+        Fragment_Definitions(shaderPart: string): CustomMaterial;
         /**
-         * Defines wether or not: to add a smaller moving bump to less steady waves.
+         * Sets the code on Fragment_MainBegin portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        private _bumpSuperimpose;
-        bumpSuperimpose: boolean;
+        Fragment_MainBegin(shaderPart: string): CustomMaterial;
         /**
-         * Defines wether or not color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
+         * Sets the code on Fragment_MainEnd portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        private _fresnelSeparate;
-        fresnelSeparate: boolean;
+        Fragment_MainEnd(shaderPart: string): CustomMaterial;
         /**
-         * Defines wether or not bump Wwves modify the reflection.
+         * Sets the code on Fragment_Custom_Diffuse portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        private _bumpAffectsReflection;
-        bumpAffectsReflection: boolean;
+        Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
         /**
-         * Defines the water color blended with the refraction (near).
+         * Sets the code on Fragment_Custom_Alpha portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        waterColor: Color3;
+        Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
         /**
-         * Defines the blend factor related to the water color.
+         * Sets the code on Fragment_Before_Lights portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        colorBlendFactor: number;
+        Fragment_Before_Lights(shaderPart: string): CustomMaterial;
         /**
-         * Defines the water color blended with the reflection (far).
+         * Sets the code on Fragment_Before_Fog portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        waterColor2: Color3;
+        Fragment_Before_Fog(shaderPart: string): CustomMaterial;
         /**
-         * Defines the blend factor related to the water color (reflection, far).
+         * Sets the code on Fragment_Before_FragColor portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        colorBlendFactor2: number;
+        Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
         /**
-         * Defines the maximum length of a wave.
+         * Sets the code on Vertex_Begin portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        waveLength: number;
+        Vertex_Begin(shaderPart: string): CustomMaterial;
         /**
-         * Defines the waves speed.
+         * Sets the code on Vertex_Definitions portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        waveSpeed: number;
+        Vertex_Definitions(shaderPart: string): CustomMaterial;
         /**
-         * Defines the number of times waves are repeated. This is typically used to adjust waves count according to the ground's size where the material is applied on.
+         * Sets the code on Vertex_MainBegin portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        waveCount: number;
+        Vertex_MainBegin(shaderPart: string): CustomMaterial;
         /**
-         * Sets or gets whether or not automatic clipping should be enabled or not. Setting to true will save performances and
-         * will avoid calculating useless pixels in the pixel shader of the water material.
+         * Sets the code on Vertex_Before_PositionUpdated portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        disableClipPlane: boolean;
+        Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
         /**
-         * Defines whether or not to use world coordinates for wave deformations.
-         * The default value is false, meaning that the deformation is applied in object (local) space.
-         * You will probably need to set it to true if you are using instances or thin instances for your water objects.
+         * Sets the code on Vertex_Before_NormalUpdated portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        private _useWorldCoordinatesForWaveDeformation;
-        useWorldCoordinatesForWaveDeformation: boolean;
-        protected _renderTargets: SmartArray<RenderTargetTexture>;
-        private _mesh;
-        private _refractionRTT;
-        private _reflectionRTT;
-        private _reflectionTransform;
-        private _lastTime;
-        private _lastDeltaTime;
-        private _waitingRenderList;
-        private _imageProcessingConfiguration;
-        private _imageProcessingObserver;
+        Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
         /**
-         * Gets a boolean indicating that current material needs to register RTT
+         * Sets the code on Vertex_After_WorldPosComputed portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        get hasRenderTargetTextures(): boolean;
+        Vertex_After_WorldPosComputed(shaderPart: string): CustomMaterial;
         /**
-         * Constructor
-         * @param name
-         * @param scene
-         * @param renderTargetSize
+         * Sets the code on Vertex_MainEnd portion
+         * @param shaderPart the code string
+         * @returns the current material
          */
-        constructor(name: string, scene?: Scene, renderTargetSize?: Vector2);
-        get refractionTexture(): Nullable<RenderTargetTexture>;
-        get reflectionTexture(): Nullable<RenderTargetTexture>;
-        addToRenderList(node: any): void;
-        removeFromRenderList(node: any): void;
-        enableRenderTargets(enable: boolean): void;
-        getRenderList(): Nullable<AbstractMesh[]>;
-        get renderTargetsEnabled(): boolean;
+        Vertex_MainEnd(shaderPart: string): CustomMaterial;
+    }
+
+
+
+
+    export class CellMaterial extends PushMaterial {
+        private _diffuseTexture;
+        diffuseTexture: BaseTexture;
+        diffuseColor: Color3;
+        _computeHighLevel: boolean;
+        computeHighLevel: boolean;
+        private _disableLighting;
+        disableLighting: boolean;
+        private _maxSimultaneousLights;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene?: Scene);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
         isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
         bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        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;
+        clone(name: string): CellMaterial;
+        serialize(): any;
+        static Parse(source: any, scene: Scene, rootUrl: string): CellMaterial;
     }
 
 
+    /** @internal */
+    export var cellVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var cellPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+