import Texture2D from '../Texture2D';
import Renderer, { RendererViewport } from '../Renderer';
import Camera from '../Camera';
import Scene from '../Scene';
import { GLRenderHooks } from '../gl/GLPipeline';
export interface DeferredGBufferOpts {
    enableTargetTexture1: boolean;
    enableTargetTexture2: boolean;
    enableTargetTexture3: boolean;
    enableTargetTexture4: boolean;
    enableTargetTexture5: boolean;
    renderOpaque: boolean;
    renderTransparent: boolean;
}
interface DeferredGBuffer extends DeferredGBufferOpts {
}
/**
 * GBuffer is provided for deferred rendering and SSAO, SSR pass.
 * It will do three passes rendering to four target textures. See
 * + {@link clay.DeferredGBuffer#getTargetTexture1}
 * + {@link clay.DeferredGBuffer#getTargetTexture2}
 * + {@link clay.DeferredGBuffer#getTargetTexture3}
 * + {@link clay.DeferredGBuffer#getTargetTexture4}
 * @constructor
 * @alias clay.deferred.GBuffer
 * @extends clay.core.Base
 */
declare class DeferredGBuffer {
    private _gBufferRenderList;
    private _gBufferTex1;
    private _gBufferTex2;
    private _gBufferTex3;
    private _gBufferTex4;
    private _gBufferTex5;
    private _defaultNormalMap;
    private _defaultRoughnessMap;
    private _defaultMetalnessMap;
    private _defaultDiffuseMap;
    private _defaultEmissiveMap;
    private _frameBuffer;
    private _outputs;
    private _gBufferMat?;
    private _debugPass;
    private _depthWritePass;
    constructor(opts?: Partial<DeferredGBufferOpts>);
    /**
     * Set G Buffer size.
     * @param {number} width
     * @param {number} height
     */
    resize(width: number, height: number): void;
    setViewport(x: RendererViewport): void;
    setViewport(x: number, y: number, width: number, height: number, dpr?: number): void;
    getViewport(): RendererViewport;
    /**
     * Update GBuffer
     * @param {clay.Renderer} renderer
     * @param {clay.Scene} scene
     * @param {clay.Camera} camera
     * @param {Object} opts
     */
    update(renderer: Renderer, scene: Scene, camera: Camera, opts?: {
        filter?: GLRenderHooks['filter'];
        /**
         * Depth texture as mask
         */
        depthMaskTexture?: Texture2D;
        targetTexture1?: Texture2D;
        targetTexture2?: Texture2D;
        targetTexture3?: Texture2D;
        targetTexture4?: Texture2D;
        targetTexture5?: Texture2D;
    }): void;
    /**
     * Debug output of gBuffer. Use `type` parameter to choos the debug output type, which can be:
     *
     * + 'normal'
     * + 'depth'
     * + 'position'
     * + 'glossiness'
     * + 'metalness'
     * + 'albedo'
     * + 'emission'
     * + 'velocity'
     *
     * @param {clay.Renderer} renderer
     * @param {clay.Camera} camera
     * @param {string} [type='normal']
     */
    renderDebug(renderer: Renderer, camera: Camera, type?: 'normal' | 'depth' | 'position' | 'glossiness' | 'metalness' | 'albedo' | 'emission' | 'velocity', viewport?: RendererViewport): void;
    /**
     * Get first target texture.
     * Channel storage:
     * + R: normal.x * 0.5 + 0.5
     * + G: normal.y * 0.5 + 0.5
     * + B: normal.z * 0.5 + 0.5
     * + A: glossiness
     *
     * Normal is in the world space.
     * @return {clay.Texture2D}
     */
    getTargetTexture1(): Texture2D;
    /**
     * Get second target texture.
     * Channel storage:
     * + R: depth
     * @return {clay.Texture2D}
     */
    getTargetTexture2(): Texture2D;
    /**
     * Get third target texture.
     * Channel storage:
     * + R: albedo.r
     * + G: albedo.g
     * + B: albedo.b
     * + A: metalness
     * @return {clay.Texture2D}
     */
    getTargetTexture3(): Texture2D;
    /**
     * Get fourth target texture.
     * Channel storage:
     * + R: emission.r
     * + G: emission.g
     * + B: emission.b
     * + A: 1.0
     */
    getTargetTexture4(): Texture2D;
    /**
     * Get fourth target texture.
     * Channel storage:
     * + R: velocity.r
     * + G: velocity.g
     * @return {clay.Texture2D}
     */
    getTargetTexture5(): Texture2D;
    /**
     * @param  {clay.Renderer} renderer
     */
    dispose(renderer: Renderer): void;
}
export default DeferredGBuffer;