import Shader, { ShaderDefineValue, ShaderPrecision, ShaderType, VertexShader, FragmentShader, UniformType } from './Shader';
import Texture2D from './Texture2D';
import TextureCube from './TextureCube';
import Texture2DArray from './Texture2DArray';
import Texture3D from './Texture3D';
export interface MaterialOpts {
    name: string;
    depthTest: boolean;
    depthMask: boolean;
    transparent: boolean;
    shader: Shader;
    precision: ShaderPrecision;
    /**
     * Blend func is a callback function when the material
     * have custom blending
     * The gl context will be the only argument passed in tho the
     * blend function
     * Detail of blend function in WebGL:
     * http://www.khronos.org/registry/gles/specs/2.0/es_full_spec_2.0.25.pdf
     *
     * Example :
     * function(_gl) {
     *  _gl.blendEquation(_gl.FUNC_ADD);
     *  _gl.blendFunc(_gl.SRC_ALPHA, _gl.ONE_MINUS_SRC_ALPHA);
     * }
     */
    blend?: (gl: WebGL2RenderingContext) => void;
    vertexDefines: Record<string, ShaderDefineValue>;
    fragmentDefines: Record<string, ShaderDefineValue>;
}
type CreateSamplerMaterialUniformObject<Type, Value> = {
    type: Type;
    array: false;
    value: Value | null;
} | {
    type: Type;
    array: true;
    value: Value[] | null;
};
export type GeneralMaterialUniformObject = CreateSamplerMaterialUniformObject<'sampler2D', Texture2D> | CreateSamplerMaterialUniformObject<'samplerCube', TextureCube> | CreateSamplerMaterialUniformObject<'sampler2DArray', Texture2DArray> | CreateSamplerMaterialUniformObject<'sampler3D', Texture3D> | {
    type: Exclude<UniformType, 'sampler2D' | 'samplerCube' | 'sampler2DArray' | 'sampler3D'>;
    array: boolean;
    value: any;
};
type UniformValueRecord<T extends Shader['uniformTpls']> = {
    [key in keyof T]?: T[key]['value'] | null;
};
type PickTextureUniforms<T extends Shader['uniformTpls']> = Pick<T, {
    [key in keyof T]: T[key]['type'] extends 'sampler2D' | 'samplerCube' ? key : never;
}[keyof T]>;
interface Material extends Omit<MaterialOpts, 'shader'> {
}
/**
 * Material defines the appearance of mesh surface, like `color`, `roughness`, `metalness`, etc.
 * It contains a {@link clay.Shader} and corresponding uniforms.
 *
 * Here is a basic example to create a standard material
```js
const material = new clay.Material(createStandardShader());
```
 */
declare class Material<T extends Shader = Shader<VertexShader<any, any, any, any>, FragmentShader<any, any, any>>> {
    readonly uid: number;
    name: string;
    /**
     * If update texture status automatically.
     */
    autoUpdateTextureStatus: boolean;
    readonly uniforms: T['uniformTpls'];
    vertexDefines: Record<string, ShaderDefineValue>;
    fragmentDefines: Record<string, ShaderDefineValue>;
    private readonly _shader;
    private _textureStatus;
    private _enabledUniforms;
    private _textureUniforms;
    private _programKey?;
    constructor(shader: T, opts?: Partial<MaterialOpts>);
    get shader(): T;
    /**
     * Set material uniform
     * @example
     *  mat.set('color', [1, 1, 1, 1]);
     * @param symbol
     * @param value
     */
    set<K extends keyof T['uniformTpls']>(symbol: K, value: T['uniformTpls'][K]['value'] | null): void;
    setUniforms(obj: UniformValueRecord<T['uniformTpls']>): void;
    isUniformEnabled(symbol: keyof T['uniformTpls']): boolean;
    getEnabledUniforms(): (keyof T['uniformTpls'])[];
    getTextureUniforms(): (T["uniformTpls"] extends infer T_1 extends import("./core/type").Dict<{
        type: UniformType;
        value?: unknown;
        semantic?: import("./Shader").AttributeSemantic | import("./Shader").UniformSemantic | import("./Shader").MatrixSemantic | undefined;
        len?: string | number | undefined;
        array?: boolean | undefined;
    }> ? { [key in keyof T_1]: T["uniformTpls"][key]["type"] extends "sampler2D" | "samplerCube" ? key : never; } : never)[keyof T["uniformTpls"]][];
    /**
     * Get uniform value
     *
     */
    get<K extends keyof T['uniformTpls']>(symbol: K): T["uniformTpls"][K]["value"] | undefined;
    /**
     * Clone a new material and keep uniforms, shader will not be cloned
     */
    clone(): Material<T>;
    /**
     * Add a #define macro in shader code
     * @param  {string} shaderType Can be vertex, fragment or both
     * @param  {string} symbol
     * @param  {number} [val]
     */
    define(symbol: string, val?: ShaderDefineValue): void;
    define(shaderType: ShaderType | 'both', symbol?: string, val?: ShaderDefineValue): void;
    /**
     * Remove a #define macro in shader code
     * @param  {string} shaderType Can be vertex, fragment or both
     * @param  {string} symbol
     */
    undefine(symbol?: string): void;
    undefine(shaderType: ShaderType | 'both', symbol?: string): void;
    /**
     * If macro is defined in shader.
     * @param  {string} shaderType Can be vertex, fragment or both
     * @param  {string} symbol
     */
    isDefined(shaderType: ShaderType, symbol: string): boolean;
    /**
     * Get macro value defined in shader.
     * @param  {string} shaderType Can be vertex, fragment or both
     * @param  {string} symbol
     */
    getDefine(shaderType: ShaderType, symbol: string): ShaderDefineValue;
    /**
     * Enable a texture, actually it will add a #define macro in the shader code
     * For example, if texture symbol is diffuseMap, it will add a line `#define DIFFUSEMAP_ENABLED` in the shader code
     * @param  {string} symbol
     */
    enableTexture(symbol: keyof PickTextureUniforms<T['uniformTpls']> | keyof PickTextureUniforms<T['uniformTpls']>[]): void;
    /**
     * Enable all textures used in the shader
     */
    enableTexturesAll(): void;
    /**
     * Disable a texture, it remove a #define macro in the shader
     * @param  {string} symbol
     */
    disableTexture(symbol: keyof PickTextureUniforms<T['uniformTpls']>): void;
    /**
     * Disable all textures used in the shader
     */
    disableTexturesAll(): void;
    /**
     * If texture of given type is enabled.
     * @param  {string}  symbol
     * @return {boolean}
     */
    isTextureEnabled(symbol: keyof PickTextureUniforms<T['uniformTpls']>): boolean;
    /**
     * Get all enabled textures
     * @return {string[]}
     */
    getEnabledTextures(): (T["uniformTpls"] extends infer T_1 extends import("./core/type").Dict<{
        type: UniformType;
        value?: unknown;
        semantic?: import("./Shader").AttributeSemantic | import("./Shader").UniformSemantic | import("./Shader").MatrixSemantic | undefined;
        len?: string | number | undefined;
        array?: boolean | undefined;
    }> ? { [key in keyof T_1]: T["uniformTpls"][key]["type"] extends "sampler2D" | "samplerCube" ? key : never; } : never)[keyof T["uniformTpls"]][];
    /**
     * Mark defines are updated.
     */
    dirtyDefines(): void;
    getProgramKey(): string;
}
export default Material;