babylonjs-materials/babylonjs.materials.module.d.ts

Babylon.js Materials Library =====================

declare module "babylonjs-materials/cell/cell.fragment" {
import "babylonjs/Shaders/ShadersInclude/helperFunctions";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/shadowsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragment";
import "babylonjs/Shaders/ShadersInclude/depthPrePass";
import "babylonjs/Shaders/ShadersInclude/lightFragment";
import "babylonjs/Shaders/ShadersInclude/logDepthFragment";
import "babylonjs/Shaders/ShadersInclude/fogFragment";
import "babylonjs/Shaders/ShadersInclude/imageProcessingCompatibility";
/** @internal */
export const cellPixelShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/cell/cell.vertex" {
import "babylonjs/Shaders/ShadersInclude/bonesDeclaration";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimationDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesVertex";
import "babylonjs/Shaders/ShadersInclude/bonesVertex";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimation";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertex";
import "babylonjs/Shaders/ShadersInclude/fogVertex";
import "babylonjs/Shaders/ShadersInclude/shadowsVertex";
import "babylonjs/Shaders/ShadersInclude/vertexColorMixing";
import "babylonjs/Shaders/ShadersInclude/logDepthVertex";
/** @internal */
export const cellVertexShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/cell/cellMaterial" {
import { Nullable } from "babylonjs/types";
import { Matrix } from "babylonjs/Maths/math.vector";
import { Color3 } from "babylonjs/Maths/math.color";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
import { PushMaterial } from "babylonjs/Materials/pushMaterial";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
import { SubMesh } from "babylonjs/Meshes/subMesh";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/scene";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import "babylonjs-materials/cell/cell.fragment";
import "babylonjs-materials/cell/cell.vertex";
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;
    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;
}

}
declare module "babylonjs-materials/cell/index" {
export * from "babylonjs-materials/cell/cellMaterial";

}
declare module "babylonjs-materials/custom/customMaterial" {
import { Texture } from "babylonjs/Materials/Textures/texture";
import { Effect } from "babylonjs/Materials/effect";
import { MaterialDefines } from "babylonjs/Materials/materialDefines";
import { StandardMaterial } from "babylonjs/Materials/standardMaterial";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/scene";
import { Nullable } from "babylonjs/types";
import { SubMesh } from "babylonjs/Meshes/subMesh";
/**
 * Structure of a custom shader
 */
export class CustomShaderStructure {
    /**
     * Fragment store
     */
    FragmentStore: string;
    /**
     * Vertex store
     */
    VertexStore: string;
    constructor();
}
/**
 * Parts of a shader
 */
export class ShaderSpecialParts {
    constructor();
    /**
     * Beginning of the fragment shader
     */
    Fragment_Begin: string;
    /**
     * Variable definitions of the fragment shader
     */
    Fragment_Definitions: string;
    /**
     * Beginning of the fragment main function
     */
    Fragment_MainBegin: string;
    /**
     * End of the fragment main function
     */
    Fragment_MainEnd: string;
    /**
     * Diffuse color calculation
     */
    Fragment_Custom_Diffuse: string;
    /**
     * Before lightning computations
     */
    Fragment_Before_Lights: string;
    /**
     * Before fog computations
     */
    Fragment_Before_Fog: string;
    /**
     * Alpha calculations
     */
    Fragment_Custom_Alpha: string;
    /**
     * Before frag color is assigned
     */
    Fragment_Before_FragColor: string;
    /**
     * Beginning of the vertex shader
     */
    Vertex_Begin: string;
    /**
     * Variable definitions of the vertex shader
     */
    Vertex_Definitions: string;
    /**
     * Start of the main function of the vertex shader
     */
    Vertex_MainBegin: string;
    /**
     * Before the world position computation
     */
    Vertex_Before_PositionUpdated: string;
    /**
     * Before the normal computation
     */
    Vertex_Before_NormalUpdated: string;
    /**
     * After the world position has been computed
     */
    Vertex_After_WorldPosComputed: string;
    /**
     * Main end of the vertex shader
     */
    Vertex_MainEnd: string;
}
/**
 * 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;
    /**
     * Sets the code on Fragment_Begin portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Fragment_Begin(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Fragment_Definitions portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Fragment_Definitions(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Fragment_MainBegin portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Fragment_MainBegin(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Fragment_MainEnd portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Fragment_MainEnd(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Fragment_Custom_Diffuse portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Fragment_Custom_Alpha portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Fragment_Before_Lights portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Fragment_Before_Lights(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Fragment_Before_Fog portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Fragment_Before_Fog(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Fragment_Before_FragColor portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Vertex_Begin portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Vertex_Begin(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Vertex_Definitions portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Vertex_Definitions(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Vertex_MainBegin portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Vertex_MainBegin(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Vertex_Before_PositionUpdated portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Vertex_Before_NormalUpdated portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Vertex_After_WorldPosComputed portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Vertex_After_WorldPosComputed(shaderPart: string): CustomMaterial;
    /**
     * Sets the code on Vertex_MainEnd portion
     * @param shaderPart the code string
     * @returns the current material
     */
    Vertex_MainEnd(shaderPart: string): CustomMaterial;
}

}
declare module "babylonjs-materials/custom/index" {
export * from "babylonjs-materials/custom/customMaterial";
export * from "babylonjs-materials/custom/pbrCustomMaterial";

}
declare module "babylonjs-materials/custom/pbrCustomMaterial" {
import { Texture } from "babylonjs/Materials/Textures/texture";
import { Effect } from "babylonjs/Materials/effect";
import { MaterialDefines } from "babylonjs/Materials/materialDefines";
import { PBRMaterial } from "babylonjs/Materials/PBR/pbrMaterial";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/scene";
import { ICustomShaderNameResolveOptions } from "babylonjs/Materials/material";
import { Nullable } from "babylonjs/types";
import { SubMesh } from "babylonjs/Meshes/subMesh";
/**
 * 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;
}
/**
 * @deprecated use ShaderAlbedoParts instead.
 */
export const 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);
    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;
}

}
declare module "babylonjs-materials/fire/fire.fragment" {
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragment";
import "babylonjs/Shaders/ShadersInclude/depthPrePass";
import "babylonjs/Shaders/ShadersInclude/logDepthFragment";
import "babylonjs/Shaders/ShadersInclude/fogFragment";
import "babylonjs/Shaders/ShadersInclude/imageProcessingCompatibility";
/** @internal */
export const firePixelShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/fire/fire.vertex" {
import "babylonjs/Shaders/ShadersInclude/bonesDeclaration";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimationDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesVertex";
import "babylonjs/Shaders/ShadersInclude/bonesVertex";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimation";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertex";
import "babylonjs/Shaders/ShadersInclude/logDepthVertex";
import "babylonjs/Shaders/ShadersInclude/fogVertex";
import "babylonjs/Shaders/ShadersInclude/vertexColorMixing";
/** @internal */
export const fireVertexShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/fire/fireMaterial" {
import { Nullable } from "babylonjs/types";
import { Matrix } from "babylonjs/Maths/math.vector";
import { Color3 } from "babylonjs/Maths/math.color";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
import { PushMaterial } from "babylonjs/Materials/pushMaterial";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
import { SubMesh } from "babylonjs/Meshes/subMesh";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/scene";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import "babylonjs-materials/fire/fire.fragment";
import "babylonjs-materials/fire/fire.vertex";
export 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 _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 "babylonjs-materials/fire/index" {
export * from "babylonjs-materials/fire/fireMaterial";

}
declare module "babylonjs-materials/fur/fur.fragment" {
import "babylonjs/Shaders/ShadersInclude/helperFunctions";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/shadowsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/fogFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragment";
import "babylonjs/Shaders/ShadersInclude/depthPrePass";
import "babylonjs/Shaders/ShadersInclude/lightFragment";
import "babylonjs/Shaders/ShadersInclude/logDepthFragment";
import "babylonjs/Shaders/ShadersInclude/fogFragment";
import "babylonjs/Shaders/ShadersInclude/imageProcessingCompatibility";
/** @internal */
export const furPixelShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/fur/fur.vertex" {
import "babylonjs/Shaders/ShadersInclude/bonesDeclaration";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimationDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesVertex";
import "babylonjs/Shaders/ShadersInclude/bonesVertex";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimation";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertex";
import "babylonjs/Shaders/ShadersInclude/logDepthVertex";
import "babylonjs/Shaders/ShadersInclude/fogVertex";
import "babylonjs/Shaders/ShadersInclude/shadowsVertex";
import "babylonjs/Shaders/ShadersInclude/vertexColorMixing";
/** @internal */
export const furVertexShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/fur/furMaterial" {
import { Nullable } from "babylonjs/types";
import { Matrix } from "babylonjs/Maths/math.vector";
import { Vector3 } from "babylonjs/Maths/math.vector";
import { Color3 } from "babylonjs/Maths/math.color";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
import { DynamicTexture } from "babylonjs/Materials/Textures/dynamicTexture";
import { PushMaterial } from "babylonjs/Materials/pushMaterial";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
import { SubMesh } from "babylonjs/Meshes/subMesh";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/scene";
import "babylonjs-materials/fur/fur.fragment";
import "babylonjs-materials/fur/fur.vertex";
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[];
}

}
declare module "babylonjs-materials/fur/index" {
export * from "babylonjs-materials/fur/furMaterial";

}
declare module "babylonjs-materials/gradient/gradient.fragment" {
import "babylonjs/Shaders/ShadersInclude/helperFunctions";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/shadowsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragment";
import "babylonjs/Shaders/ShadersInclude/depthPrePass";
import "babylonjs/Shaders/ShadersInclude/lightFragment";
import "babylonjs/Shaders/ShadersInclude/logDepthFragment";
import "babylonjs/Shaders/ShadersInclude/fogFragment";
import "babylonjs/Shaders/ShadersInclude/imageProcessingCompatibility";
/** @internal */
export const gradientPixelShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/gradient/gradient.vertex" {
import "babylonjs/Shaders/ShadersInclude/bonesDeclaration";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimationDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesVertex";
import "babylonjs/Shaders/ShadersInclude/bonesVertex";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimation";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertex";
import "babylonjs/Shaders/ShadersInclude/logDepthVertex";
import "babylonjs/Shaders/ShadersInclude/fogVertex";
import "babylonjs/Shaders/ShadersInclude/shadowsVertex";
import "babylonjs/Shaders/ShadersInclude/vertexColorMixing";
/** @internal */
export const gradientVertexShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/gradient/gradientMaterial" {
import { Nullable } from "babylonjs/types";
import { Matrix } from "babylonjs/Maths/math.vector";
import { Color3 } from "babylonjs/Maths/math.color";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
import { PushMaterial } from "babylonjs/Materials/pushMaterial";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
import { SubMesh } from "babylonjs/Meshes/subMesh";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/scene";
import "babylonjs-materials/gradient/gradient.fragment";
import "babylonjs-materials/gradient/gradient.vertex";
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;
}

}
declare module "babylonjs-materials/gradient/index" {
export * from "babylonjs-materials/gradient/gradientMaterial";

}
declare module "babylonjs-materials/grid/grid.fragment" {
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogFragment";
import "babylonjs/Shaders/ShadersInclude/logDepthFragment";
import "babylonjs/Shaders/ShadersInclude/imageProcessingCompatibility";
/** @internal */
export const gridPixelShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/grid/grid.vertex" {
import "babylonjs/Shaders/ShadersInclude/instancesDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesVertex";
import "babylonjs/Shaders/ShadersInclude/fogVertex";
import "babylonjs/Shaders/ShadersInclude/logDepthVertex";
/** @internal */
export const gridVertexShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/grid/gridMaterial" {
import { Matrix } from "babylonjs/Maths/math.vector";
import { Vector3 } from "babylonjs/Maths/math.vector";
import { Color3 } from "babylonjs/Maths/math.color";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
import { PushMaterial } from "babylonjs/Materials/pushMaterial";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
import { SubMesh } from "babylonjs/Meshes/subMesh";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/scene";
import "babylonjs-materials/grid/grid.fragment";
import "babylonjs-materials/grid/grid.vertex";
/**
 * The grid materials allows you to wrap any shape with a grid.
 * Colors are customizable.
 */
export class GridMaterial extends 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;
    /**
     * Whether to antialias the grid
     */
    antialias: boolean;
    /**
     * Determine RBG output is premultiplied by alpha value.
     */
    preMultiplyAlpha: boolean;
    /**
     * Determines if the max line value will be used instead of the sum wherever grid lines intersect.
     */
    useMaxLine: boolean;
    private _opacityTexture;
    /**
     * Texture to define opacity of the grid
     */
    opacityTexture: BaseTexture;
    private _gridControl;
    /**
     * 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 whether 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 the material and its associated resources.
     * @param forceDisposeEffect will also dispose the used effect when true
     */
    dispose(forceDisposeEffect?: boolean): void;
    clone(name: string): GridMaterial;
    serialize(): any;
    getClassName(): string;
    static Parse(source: any, scene: Scene, rootUrl: string): GridMaterial;
}

}
declare module "babylonjs-materials/grid/index" {
export * from "babylonjs-materials/grid/gridMaterial";

}
declare module "babylonjs-materials/index" {
export * from "babylonjs-materials/cell/index";
export * from "babylonjs-materials/custom/index";
export * from "babylonjs-materials/fire/index";
export * from "babylonjs-materials/fur/index";
export * from "babylonjs-materials/gradient/index";
export * from "babylonjs-materials/grid/index";
export * from "babylonjs-materials/lava/index";
export * from "babylonjs-materials/mix/index";
export * from "babylonjs-materials/normal/index";
export * from "babylonjs-materials/shadowOnly/index";
export * from "babylonjs-materials/simple/index";
export * from "babylonjs-materials/sky/index";
export * from "babylonjs-materials/terrain/index";
export * from "babylonjs-materials/triPlanar/index";
export * from "babylonjs-materials/water/index";

}
declare module "babylonjs-materials/lava/index" {
export * from "babylonjs-materials/lava/lavaMaterial";

}
declare module "babylonjs-materials/lava/lava.fragment" {
import "babylonjs/Shaders/ShadersInclude/helperFunctions";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/shadowsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragment";
import "babylonjs/Shaders/ShadersInclude/depthPrePass";
import "babylonjs/Shaders/ShadersInclude/lightFragment";
import "babylonjs/Shaders/ShadersInclude/logDepthFragment";
import "babylonjs/Shaders/ShadersInclude/fogFragment";
import "babylonjs/Shaders/ShadersInclude/imageProcessingCompatibility";
/** @internal */
export const lavaPixelShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/lava/lava.vertex" {
import "babylonjs/Shaders/ShadersInclude/bonesDeclaration";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimationDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesVertex";
import "babylonjs/Shaders/ShadersInclude/bonesVertex";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimation";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertex";
import "babylonjs/Shaders/ShadersInclude/fogVertex";
import "babylonjs/Shaders/ShadersInclude/shadowsVertex";
import "babylonjs/Shaders/ShadersInclude/vertexColorMixing";
import "babylonjs/Shaders/ShadersInclude/logDepthVertex";
/** @internal */
export const lavaVertexShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/lava/lavaMaterial" {
import { Nullable } from "babylonjs/types";
import { Matrix } from "babylonjs/Maths/math.vector";
import { Color3 } from "babylonjs/Maths/math.color";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
import { PushMaterial } from "babylonjs/Materials/pushMaterial";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
import { SubMesh } from "babylonjs/Meshes/subMesh";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/scene";
import "babylonjs-materials/lava/lava.fragment";
import "babylonjs-materials/lava/lava.vertex";
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;
    private _maxSimultaneousLights;
    maxSimultaneousLights: number;
    private _scaledDiffuse;
    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 "babylonjs-materials/mix/index" {
export * from "babylonjs-materials/mix/mixMaterial";

}
declare module "babylonjs-materials/mix/mix.fragment" {
import "babylonjs/Shaders/ShadersInclude/helperFunctions";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/shadowsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragment";
import "babylonjs/Shaders/ShadersInclude/depthPrePass";
import "babylonjs/Shaders/ShadersInclude/lightFragment";
import "babylonjs/Shaders/ShadersInclude/logDepthFragment";
import "babylonjs/Shaders/ShadersInclude/fogFragment";
import "babylonjs/Shaders/ShadersInclude/imageProcessingCompatibility";
/** @internal */
export const mixPixelShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/mix/mix.vertex" {
import "babylonjs/Shaders/ShadersInclude/bonesDeclaration";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimationDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesVertex";
import "babylonjs/Shaders/ShadersInclude/bonesVertex";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimation";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertex";
import "babylonjs/Shaders/ShadersInclude/fogVertex";
import "babylonjs/Shaders/ShadersInclude/shadowsVertex";
import "babylonjs/Shaders/ShadersInclude/vertexColorMixing";
import "babylonjs/Shaders/ShadersInclude/logDepthVertex";
/** @internal */
export const mixVertexShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/mix/mixMaterial" {
import { Nullable } from "babylonjs/types";
import { Matrix } from "babylonjs/Maths/math.vector";
import { Color3 } from "babylonjs/Maths/math.color";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
import { Texture } from "babylonjs/Materials/Textures/texture";
import { PushMaterial } from "babylonjs/Materials/pushMaterial";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
import { SubMesh } from "babylonjs/Meshes/subMesh";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/scene";
import "babylonjs-materials/mix/mix.fragment";
import "babylonjs-materials/mix/mix.vertex";
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
     */
    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): MixMaterial;
    serialize(): any;
    getClassName(): string;
    static Parse(source: any, scene: Scene, rootUrl: string): MixMaterial;
}

}
declare module "babylonjs-materials/normal/index" {
export * from "babylonjs-materials/normal/normalMaterial";

}
declare module "babylonjs-materials/normal/normal.fragment" {
import "babylonjs/Shaders/ShadersInclude/helperFunctions";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/shadowsFragmentFunctions";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneFragment";
import "babylonjs/Shaders/ShadersInclude/depthPrePass";
import "babylonjs/Shaders/ShadersInclude/lightFragment";
import "babylonjs/Shaders/ShadersInclude/logDepthFragment";
import "babylonjs/Shaders/ShadersInclude/fogFragment";
import "babylonjs/Shaders/ShadersInclude/imageProcessingCompatibility";
/** @internal */
export const normalPixelShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/normal/normal.vertex" {
import "babylonjs/Shaders/ShadersInclude/bonesDeclaration";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimationDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesDeclaration";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/logDepthDeclaration";
import "babylonjs/Shaders/ShadersInclude/fogVertexDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightFragmentDeclaration";
import "babylonjs/Shaders/ShadersInclude/lightUboDeclaration";
import "babylonjs/Shaders/ShadersInclude/instancesVertex";
import "babylonjs/Shaders/ShadersInclude/bonesVertex";
import "babylonjs/Shaders/ShadersInclude/bakedVertexAnimation";
import "babylonjs/Shaders/ShadersInclude/clipPlaneVertex";
import "babylonjs/Shaders/ShadersInclude/logDepthVertex";
import "babylonjs/Shaders/ShadersInclude/fogVertex";
import "babylonjs/Shaders/ShadersInclude/shadowsVertex";
/** @internal */
export const normalVertexShader: {
    name: string;
    shader: string;
};

}
declare module "babylonjs-materials/normal/normalMaterial" {
import { Nullable } from "babylonjs/types";
import { Matrix } from "babylonjs/Maths/math.vector";
import { Color3 } from "babylonjs/Maths/math.color";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
import { PushMaterial } from "babylonjs/Materials/pushMaterial";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
import { SubMesh } from "babylonjs/Meshes/subMesh";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Scene } from "babylonjs/sce