@awayjs/stage/dist/lib/Stage.d.ts

Stage for AwayJS

import { EventDispatcher, Rectangle, IAssetClass, IAbstractionPool, IAbstractionClass, Point, ColorTransform, IAsset, IAbstraction } from '@awayjs/core';
import { ContextMode } from './base/ContextMode';
import { ContextGLProfile } from './base/ContextGLProfile';
import { IContextGL } from './base/IContextGL';
import { IVertexBuffer } from './base/IVertexBuffer';
import { ImageBase } from './image/ImageBase';
import { ImageSampler } from './image/ImageSampler';
import { ProgramData } from './image/ProgramData';
import { StageManager } from './managers/StageManager';
import { ContextGLClearMask } from './base/ContextGLClearMask';
import { Image2D } from './image/Image2D';
import { TouchPoint } from './base/TouchPoint';
import { FilterManager } from './managers/FilterManager';
/**
 * Stage provides a proxy class to handle the creation and attachment of the Context
 * (and in turn the back buffer) it uses. Stage should never be created directly,
 * but requested through StageManager.
 *
 * @see away.managers.StageManager
 *
 */
export declare class Stage extends EventDispatcher implements IAbstractionPool {
    private static _abstractionClassPool;
    private _programData;
    private _programDataPool;
    private _context;
    private _container;
    private _width;
    private _height;
    private _x;
    private _y;
    _screenX: number;
    _screenY: number;
    _touchPoints: Array<TouchPoint>;
    private _stageIndex;
    private _usesSoftwareRendering;
    private _profile;
    private _stageManager;
    private _antiAlias;
    private readonly savedTargetStack;
    private readonly _activeTargetConf;
    private _color;
    private _backBufferDirty;
    private _sizeDirty;
    private _lastScissorBox;
    private _frameEndCallbackOnce;
    private _initialised;
    globalDisableMipmap: boolean;
    globalDisableSmooth: boolean;
    numUsedStreams: number;
    numUsedTextures: number;
    readonly filterManager: FilterManager;
    set pixelRatio(v: number);
    get pixelRatio(): number;
    get glVersion(): number;
    get screenX(): number;
    get screenY(): number;
    get touchPoints(): Array<TouchPoint>;
    readonly id: number;
    constructor(container: HTMLCanvasElement, stageIndex: number, stageManager: StageManager, forceSoftware?: boolean, profile?: ContextGLProfile);
    requiestFrameEnd(func: () => void): void;
    /**
     * @description Should be executed AFTER rendering process
     */
    present(): void;
    getProgramData(vertexString: string, fragmentString: string): ProgramData;
    /**
     * Safe current target config to stack
     */
    pushRenderTargetConfig(): void;
    /**
     * Pop render target config and apply it, used for deep caching
     */
    popRenderTarget(): void;
    setRenderTarget(target: ImageBase & {
        antialiasQuality?: number;
    }, enableDepthAndStencil?: boolean, surfaceSelector?: number, mipmapSelector?: number, disableMSAA?: boolean): void;
    copyPixels(source: Image2D, target: Image2D, rect: Rectangle, destPoint: Point, alphaBitmapData?: Image2D, alphaPoint?: Point, mergeAlpha?: boolean): void;
    threshold(source: Image2D, target: Image2D, rect: Rectangle, destPoint: Point, operation: string, threshold: number, color: number, mask: number, copySource: boolean): void;
    colorTransform(source: Image2D, target: Image2D, rect: Rectangle, colorTransform: ColorTransform): void;
    requestAbstraction(asset: IAsset): IAbstraction;
    storeAbstraction(abstraction: IAbstraction): void;
    /**
     *
     * @param imageObjectClass
     */
    static registerAbstraction(abstractionClass: IAbstractionClass, assetClass: IAssetClass): void;
    /**
     * Requests a Context object to attach to the managed gl canvas.
     */
    requestContext(forceSoftware?: boolean, profile?: ContextGLProfile, _mode?: ContextMode, alpha?: boolean): void;
    /**
     * The width of the gl canvas
     */
    get width(): number;
    set width(val: number);
    /**
     * The height of the gl canvas
     */
    get height(): number;
    set height(val: number);
    /**
     * The x position of the gl canvas
     */
    get x(): number;
    set x(val: number);
    /**
     * The y position of the gl canvas
     */
    get y(): number;
    set y(val: number);
    set visible(val: boolean);
    get visible(): boolean;
    set container(value: HTMLElement);
    get container(): HTMLElement;
    /**
     * The Context object associated with the given stage object.
     */
    get context(): IContextGL;
    private _invalidateSize;
    get profile(): ContextGLProfile;
    /**
     * Disposes the Stage object, freeing the Context attached to the Stage.
     */
    dispose(): void;
    /**
     * Configures the back buffer associated with the Stage object.
     * @param backBufferWidth The width of the backbuffer.
     * @param backBufferHeight The height of the backbuffer.
     * @param antiAlias The amount of anti-aliasing to use.
     * @param enableDepthAndStencil Indicates whether the back buffer contains a depth and stencil buffer.
     */
    configureBackBuffer(backBufferWidth: number, backBufferHeight: number, antiAlias: number, enableDepthAndStencil: boolean): void;
    get enableDepthAndStencil(): boolean;
    set enableDepthAndStencil(enableDepthAndStencil: boolean);
    get renderSurfaceSelector(): number;
    clear(red?: number, green?: number, blue?: number, alpha?: number, depth?: number, stencil?: number, mask?: ContextGLClearMask): void;
    /**
     * The index of the Stage which is managed by this instance of StageProxy.
     */
    get stageIndex(): number;
    /**
     * Indicates whether the Stage managed by this proxy is running in software mode.
     * Remember to wait for the CONTEXT_CREATED event before checking this property,
     * as only then will it be guaranteed to be accurate.
     */
    get usesSoftwareRendering(): boolean;
    /**
     * The antiAliasing of the Stage.
     */
    get antiAlias(): number;
    set antiAlias(antiAlias: number);
    /**
     * The background color of the Stage.
     */
    get color(): number;
    set color(color: number);
    registerProgram(programData: ProgramData): void;
    unRegisterProgram(programData: ProgramData): void;
    interactionHandler(event: MouseEvent | TouchEvent): void;
    mapWindowToStage(x: number, y: number, out?: {
        x: number;
        y: number;
    }): {
        x: number;
        y: number;
    };
    /**
     * Frees the Context associated with this StageProxy.
     */
    private freeContext;
    private onContextLost;
    private onContextRestored;
    recoverFromDisposal(): boolean;
    private _callback;
    setVertexBuffer(index: number, buffer: IVertexBuffer, size: number, dimensions: number, offset: number, unsigned?: boolean): void;
    setScissor(rectangle: Rectangle): void;
    setSamplerAt(index: number, sampler: ImageSampler): void;
}
//# sourceMappingURL=Stage.d.ts.map