import { Dict, UnionToIntersection } from './core/type';
import { mat2, mat3, mat4, vec2, vec3, vec4 } from './glmatrix';
import Texture2D from './Texture2D';
import Texture2DArray from './Texture2DArray';
import Texture3D from './Texture3D';
import TextureCube from './TextureCube';
export type ShaderDefineValue = boolean | string | number | undefined | null;
export type ShaderPrecision = 'highp' | 'lowp' | 'mediump';
export type ShaderType = 'vertex' | 'fragment';
export type UniformType = 'bool' | 'int' | 'sampler2D' | 'sampler2DArray' | 'sampler3D' | 'samplerCube' | 'isampler2D' | 'usampler2D' | 'float' | 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' | 'mat2' | 'mat3' | 'mat4';
export type NativeUniformType = Exclude<UniformType, '_struct'>;
declare const attributeSizeMap: {
    readonly vec2: 2;
    readonly vec3: 3;
    readonly vec4: 4;
    readonly ivec2: 2;
    readonly ivec3: 3;
    readonly ivec4: 4;
    readonly float: 1;
    readonly int: 1;
};
type NativeUniformValueMap = {
    bool: number;
    int: number;
    sampler2D: Texture2D;
    samplerCube: TextureCube;
    sampler3D: Texture3D;
    sampler2DArray: Texture2DArray;
    isampler2D: Texture2D;
    usampler2D: Texture2D;
    float: number;
    vec2: vec2.Vec2Array;
    vec3: vec3.Vec3Array;
    vec4: vec4.Vec4Array;
    ivec2: vec2.Vec2Array;
    ivec3: vec3.Vec3Array;
    ivec4: vec4.Vec4Array;
    mat2: mat2.Mat2Array;
    mat3: mat3.Mat3Array;
    mat4: mat4.Mat4Array;
};
type NativeUniformArrayValueMap = {
    bool: ArrayLike<number>;
    int: ArrayLike<number>;
    sampler2D: Texture2D[];
    samplerCube: TextureCube[];
    sampler3D: Texture3D[];
    sampler2DArray: Texture2DArray[];
    isampler2D: Texture2D[];
    usampler2D: Texture2D[];
    float: ArrayLike<number>;
    vec2: ArrayLike<number>;
    vec3: ArrayLike<number>;
    vec4: ArrayLike<number>;
    ivec2: ArrayLike<number>;
    ivec3: ArrayLike<number>;
    ivec4: ArrayLike<number>;
    mat2: ArrayLike<number>;
    mat3: ArrayLike<number>;
    mat4: ArrayLike<number>;
};
type NativeAttributeType = keyof typeof attributeSizeMap;
export type AttributeSemantic = 'POSITION' | 'NORMAL' | 'BINORMAL' | 'TANGENT' | 'TEXCOORD_0' | 'TEXCOORD_1' | 'COLOR' | 'JOINT' | 'WEIGHT';
export type UniformSemantic = 'VIEWPORT_SIZE' | 'VIEWPORT' | 'DEVICEPIXELRATIO' | 'WINDOW_SIZE' | 'NEAR' | 'FAR' | 'TIME' | 'LOG_DEPTH_BUFFER_FC';
export declare const BASIC_MATRIX_SEMANTICS: readonly ["WORLD", "VIEW", "PROJECTION", "WORLDVIEW", "VIEWPROJECTION", "WORLDVIEWPROJECTION"];
type MatrixSemanticNoTranpose = 'WORLD' | 'VIEW' | 'PROJECTION' | 'WORLDVIEW' | 'VIEWPROJECTION' | 'WORLDVIEWPROJECTION' | 'WORLDINVERSE' | 'VIEWINVERSE' | 'PROJECTIONINVERSE' | 'WORLDVIEWINVERSE' | 'VIEWPROJECTIONINVERSE' | 'WORLDVIEWPROJECTIONINVERSE';
export type MatrixSemantic = MatrixSemanticNoTranpose | 'WORLDTRANSPOSE' | 'VIEWTRANSPOSE' | 'PROJECTIONTRANSPOSE' | 'WORLDVIEWTRANSPOSE' | 'VIEWPROJECTIONTRANSPOSE' | 'WORLDVIEWPROJECTIONTRANSPOSE' | 'WORLDINVERSETRANSPOSE' | 'VIEWINVERSETRANSPOSE' | 'PROJECTIONINVERSETRANSPOSE' | 'WORLDVIEWINVERSETRANSPOSE' | 'VIEWPROJECTIONINVERSETRANSPOSE' | 'WORLDVIEWPROJECTIONINVERSETRANSPOSE';
export declare function glsl(strings: TemplateStringsArray, ...values: string[]): string;
type ShaderUniformLoose = {
    type: UniformType;
    value?: unknown;
    semantic?: AttributeSemantic | UniformSemantic | MatrixSemantic;
    len?: number | string;
    array?: boolean;
};
type ShaderAttributeLoose = {
    type: NativeAttributeType;
    semantic?: AttributeSemantic;
};
type ShaderVaringLoose = {
    type: UniformType;
};
export declare function createUniform<T extends NativeUniformType, S extends MatrixSemantic | UniformSemantic>(type: T, value?: Exclude<NativeUniformValueMap[T], string>, semantic?: S): {
    type: T;
    value: NativeUniformValueMap[T];
    semantic: S | undefined;
};
export declare function createSemanticUniform<T extends UniformType, S extends MatrixSemantic | UniformSemantic>(type: T, semantic: S): {
    type: T;
    semantic: S;
};
export declare function createArrayUniform<T extends NativeUniformType>(type: T, len: string | number, // Can be a define SKIN_COUNT or literal number
value?: NativeUniformArrayValueMap[T]): {
    type: T;
    value: NativeUniformArrayValueMap[T] | undefined;
    len: string | number;
    array: true;
};
export declare function createAttribute<T extends NativeAttributeType, S extends AttributeSemantic>(type: T, semantic?: S): {
    type: T;
    semantic: S | undefined;
};
export declare function createVarying<T extends UniformType>(type: T): {
    type: T;
};
type ShaderFunctionLoose = (functionName?: string) => string;
export interface ShaderMixinLoose {
    defines: Dict<ShaderDefineValue>;
    uniforms: Dict<ShaderUniformLoose>;
    attributes: Dict<ShaderAttributeLoose>;
    varyings: Dict<ShaderVaringLoose>;
    functions?: ShaderFunctionLoose[];
    main?: string | Dict<string>;
}
export declare const FUNCTION_NAME_PLACEHOLDER = "<function_name>";
/**
 * Shader function is only a plain string that can be reused.
 * It's not magical. So any shader code can be used here.
 * It can include multiple functions. Can use #ifdef.
 * Or even uniforms that want to be not configured
 */
export declare function createShaderFunction<T extends string>(code: string, defaultName?: T): {
    (functionName?: string): string;
    displayName: T | undefined;
};
export declare function createShaderMixin<TDefines extends Dict<ShaderDefineValue> = {}, TUniforms extends Dict<ShaderUniformLoose> = {}, TAttributes extends Dict<ShaderAttributeLoose> = {}, TVaryings extends Dict<ShaderVaringLoose> = {}, TCode extends Dict<string> | string = string>(options: {
    defines?: TDefines;
    uniforms?: TUniforms;
    attributes?: TAttributes;
    varyings?: TVaryings;
    /**
     * Shader funcitons chunk will be assembled before main code.
     */
    functions?: ShaderFunctionLoose[];
    main?: TCode;
} | string): {
    defines: TDefines;
    uniforms: TUniforms;
    attributes: TAttributes;
    varyings: TVaryings;
    functions: ShaderFunctionLoose[];
    main: TCode;
};
type MergeChunk<Chunks extends ShaderMixinLoose[], P extends 'defines' | 'uniforms' | 'attributes' | 'varyings'> = UnionToIntersection<Chunks[number][P]>;
declare class StageShader<TDefines extends Dict<ShaderDefineValue> = Dict<ShaderDefineValue>, TUniforms extends Dict<ShaderUniformLoose> = {}, TAttributes extends Dict<ShaderAttributeLoose> = {}, TVaryings extends Dict<ShaderVaringLoose> = {}, TMixins extends ShaderMixinLoose[] = never> {
    readonly defines: TDefines & MergeChunk<TMixins, 'defines'>;
    readonly uniforms: TUniforms & MergeChunk<TMixins, 'uniforms'>;
    readonly attributes: TAttributes & MergeChunk<TMixins, 'attributes'>;
    readonly varyings: TVaryings & MergeChunk<TMixins, 'varyings'>;
    readonly functions: ShaderFunctionLoose[];
    readonly main: string;
    constructor(options: {
        name?: string;
        defines?: TDefines;
        uniforms?: TUniforms;
        attributes?: TAttributes;
        varyings?: TVaryings;
        includes?: TMixins;
        main: string;
    });
}
export declare class VertexShader<TDefines extends Dict<ShaderDefineValue> = Dict<ShaderDefineValue>, TUniforms extends Dict<ShaderUniformLoose> = {}, TAttributes extends Dict<ShaderAttributeLoose> = {}, TVaryings extends Dict<ShaderVaringLoose> = {}, TMixins extends ShaderMixinLoose[] = never> extends StageShader<TDefines, TUniforms, TAttributes, TVaryings, TMixins> {
    constructor(options: {
        name?: string;
        defines?: TDefines;
        uniforms?: TUniforms;
        attributes?: TAttributes;
        varyings?: TVaryings;
        /**
         * uniform, defines, attributes, varyings，functions in mixins will be merged automatically.
         */
        includes?: TMixins;
        main: string;
    });
}
export declare class FragmentShader<TDefines extends Dict<ShaderDefineValue> = Dict<ShaderDefineValue>, TUniforms extends Dict<ShaderUniformLoose> = {}, TMixins extends ShaderMixinLoose[] = never> extends StageShader<TDefines, TUniforms, never, never, TMixins> {
    outputs: string[];
    constructor(options: {
        name?: string;
        defines?: TDefines;
        uniforms?: TUniforms;
        /**
         * uniform, defines, attributes, varyings，functions in mixins will be merged automatically.
         */
        includes?: TMixins;
        /**
         * Fragment shader outputs. Default to be ['color']
         */
        outputs?: string[];
        main: string;
    });
}
export type VertexShaderLoose = VertexShader<Dict<ShaderDefineValue>, Dict<ShaderUniformLoose>, Dict<ShaderAttributeLoose>, Dict<ShaderVaringLoose>>;
export type FragmentShaderLoose = FragmentShader<Dict<ShaderDefineValue>, Dict<ShaderUniformLoose>>;
export type PickFragmentTextureUniforms<T extends FragmentShader<Dict<ShaderDefineValue>, Dict<ShaderUniformLoose>>['uniforms']> = Pick<T, {
    [key in keyof T]: T[key]['type'] extends 'sampler2D' | 'samplerCube' | 'isampler2D' | 'usampler2D' | 'sampler3D' | 'sampler2DArray' ? key : never;
}[keyof T]>;
export declare class Shader<V extends VertexShader = VertexShader<Dict<ShaderDefineValue>, Dict<ShaderUniformLoose>, Dict<ShaderAttributeLoose>, Dict<ShaderVaringLoose>>, F extends FragmentShader = FragmentShader<Dict<ShaderDefineValue>, Dict<ShaderUniformLoose>>> {
    readonly vertexDefines: Dict<ShaderDefineValue>;
    readonly fragmentDefines: Dict<ShaderDefineValue>;
    readonly textures: Record<string, {
        shaderType: 'fragment' | 'vertex';
        type: 'sampler2D' | 'samplerCube' | 'isampler2D' | 'usampler2D' | 'sampler3D' | 'sampler2DArray';
    }>;
    /**
     * Processed uniform for material
     */
    readonly uniformTpls: V['uniforms'] & F['uniforms'];
    /**
     * Processed attributes for geometry
     */
    readonly attributes: Record<string, {
        type: 'float' | 'int';
        size: number;
        semantic?: string;
    }>;
    readonly semanticsMap: Partial<Record<AttributeSemantic, {
        name: string;
    }> & Record<MatrixSemantic | UniformSemantic, {
        name: string;
        type: UniformType;
        isTranspose?: boolean;
        isInverse?: boolean;
        semanticNoTranspose?: MatrixSemanticNoTranpose;
    }>>;
    readonly matrixSemantics: MatrixSemantic[];
    readonly vertex: string;
    readonly fragment: string;
    readonly outputs: string[];
    private readonly _shaderID;
    /**
     * If enable parallel compile.
     * Only available when renderer#parallelShaderCompile is true.
     */
    parallelCompile?: boolean;
    version: 3;
    get shaderID(): string;
    createUniforms(): V["uniforms"] & F["uniforms"];
    constructor(vert: V, frag: F);
    static uniform: typeof createUniform;
    static arrayUniform: typeof createArrayUniform;
    static attribute: typeof createAttribute;
    static varying: typeof createVarying;
    static semanticUniform: typeof createSemanticUniform;
    static Vertex: typeof VertexShader;
    static Fragment: typeof FragmentShader;
}
export declare function isTextureUniform(uniform: {
    type: UniformType;
}): boolean;
export default Shader;