import { Container, Renderer, Ticker } from 'pixi.js';
import { Disposable } from '../utils/Disposable.js';
import { ReelAxis } from './ReelAxis.js';
import { ReelCurve } from './ReelCurve.js';
/**
 * Bend a whole reel, whatever is inside it.
 *
 * {@link ReelCurve}'s per-symbol projection only bends content that IS a
 * texture: a `Container` transform is affine, so Spine skeletons, `Graphics`,
 * text and composites come out moved-but-flat.
 *
 * This renders the reel to a texture and draws it through a mesh whose
 * vertices carry the same projection, so everything inside bends and no symbol
 * cooperates. It also sidesteps the per-symbol path's atlas-frame problem,
 * since a render texture owns its whole source.
 *
 * Costs one render pass per reel per frame and one resample, so hairline art is
 * marginally softer. Symbols are no longer real display objects to the
 * renderer, so use `ReelSet.getCellQuad()` rather than screen-space hit tests.
 */
export declare class ReelWarp extends Container implements Disposable {
    private readonly _source;
    private readonly _renderer;
    private readonly _curve;
    private readonly _axis;
    private readonly _margin;
    private readonly _bleed;
    private readonly _mesh;
    private _texture;
    private _isDestroyed;
    private _width;
    private _height;
    private readonly _tickerRef;
    /**
     * @param _source the reel's own container. It is rendered to a texture rather
     *   than drawn, so the caller must keep it OUT of the scene graph
     * @param _renderer the renderer to draw the reel with
     * @param _curve the projection to displace vertices by
     * @param _axis the reel's travel projection
     * @param width screen width of the reel's box
     * @param height screen height of the reel's box
     */
    constructor(_source: Container, _renderer: Renderer, _curve: ReelCurve, _axis: ReelAxis, width: number, height: number, ticker: Ticker, _margin?: number, _bleed?: number);
    get isDestroyed(): boolean;
    /**
     * Redraw the reel into its texture. Called once per frame, after the motion
     * layer has moved the symbols and before the stage is drawn.
     */
    update(): void;
    /** Re-measure after a reshape, and re-displace the grid. */
    resize(width: number, height: number): void;
    destroy(): void;
    /**
     * Push every grid vertex through the cylinder projection.
     *
     * Grid is screen-space over the reel's box: map each vertex's MAIN
     * coordinate along the drum, pull its CROSS coordinate toward the camera's
     * axis by the same perspective factor. Once per geometry change - the
     * projection does not move while the strip does.
     */
    private _displace;
}
//# sourceMappingURL=ReelWarp.d.ts.map