import { type NodeFrame, type NodeMaterial, QuadMesh, RenderTarget, type RenderTargetOptions, Texture, TextureNode, type WebGPURenderer } from 'three/webgpu';
/**
 * Base class for TSL texture nodes whose texture is a render target, filled by rendering a full screen quad.
 *
 * The quad is rendered only when something changed since the last render:
 * subclasses list what the result depends on in {@link RenderTargetNode._getState}
 * and the other render target nodes they read from in {@link RenderTargetNode._getDependencies}.
 * Sampling the node costs a single texture read, like any other texture.
 *
 * The node renders itself before rendering whenever it is part of a rendered node graph
 * (material, `scene.backgroundNode`, ...). When only its texture is used (`node.value`)
 * call {@link RenderTargetNode.render} yourself.
 *
 * @category Nodes
 * @group Nodes
 */
export declare abstract class RenderTargetNode extends TextureNode {
    /**
     * The render target holding the result
     */
    readonly renderTarget: RenderTarget;
    /**
     * Incremented every time the render target is rendered,
     * nodes depending on this one use it to know when to render again
     */
    revision: number;
    protected _quadMesh: QuadMesh;
    protected _material: NodeMaterial;
    private _rendererState;
    private _state;
    /**
     * @param material the material rendered on the full screen quad
     * @param renderTargetOptions options of the render target, it is created with a 1x1 size
     * and resized to {@link RenderTargetNode.width} x {@link RenderTargetNode.height} before rendering
     */
    constructor(material: NodeMaterial, renderTargetOptions: RenderTargetOptions);
    /** Width of the result, the node doesn't render while it's 0 */
    abstract get width(): number;
    /** Height of the result, the node doesn't render while it's 0 */
    abstract get height(): number;
    /**
     * Values the result depends on, compared with `===` to the ones of the last render
     */
    protected abstract _getState(): unknown[];
    /**
     * Render target nodes read by this node, rendered (if needed) before this one
     */
    protected _getDependencies(): RenderTargetNode[];
    /**
     * Called after the render target has been rendered
     */
    protected _onRender(): void;
    /**
     * Forces a render the next time {@link RenderTargetNode.render} is called,
     * use it when something the node can't track changed (e.g. a custom input node)
     */
    invalidate(): this;
    /**
     * Renders into {@link RenderTargetNode.renderTarget}, only if something changed since the last render.
     *
     * Called automatically when the node is part of a rendered node graph.
     *
     * @param renderer
     * @returns `true` if the render target was rendered
     */
    render(renderer: WebGPURenderer): boolean;
    /**
     * Called by three.js before rendering, renders the node when needed
     * @internal
     */
    updateBefore(frame: NodeFrame): undefined;
    set value(value: Texture);
    get value(): Texture;
    /**
     * Clones created by `sample()` & co. are plain TextureNodes reading this node's texture,
     * they keep it updated before rendering as well
     */
    clone(): this;
    /**
     * Disposes the render target and the material
     */
    dispose(): void;
}