@awayjs/renderer/dist/lib/RendererBase.d.ts

Renderer for AwayJS

import { Matrix3D, Plane3D, AbstractionBase, AssetEvent, IAsset, Box, Rectangle, IAbstraction, IAbstractionPool } from '@awayjs/core';
import { BitmapImage2D, IContextGL, Stage, RTTBufferManager, Image2D } from '@awayjs/stage';
import { View, ViewEvent, IPartitionTraverser, IEntityTraverser, INode, ITraversable, ContainerNode } from '@awayjs/view';
import { RenderEntity } from './base/RenderEntity';
import { IMapper } from './base/IMapper';
import { RenderGroup } from './RenderGroup';
import { IRenderEntitySorter } from './sort/IRenderEntitySorter';
import { IRenderable } from './base/IRenderable';
import { _Render_ElementsBase } from './base/_Render_ElementsBase';
import { Style } from './base/Style';
/**
 * RendererBase forms an abstract base class for classes that are used in the rendering pipeline to render the
 * contents of a partition
 *
 * @class away.render.RendererBase
 */
export declare class RendererBase extends AbstractionBase implements IPartitionTraverser, IEntityTraverser, IAbstractionPool {
    private static _store;
    static _collectionMark: number;
    protected _renderMatrix: Matrix3D;
    protected _parentNode: ContainerNode;
    private _boundsPicker;
    _boundsScale: number;
    private _enableDepthAndStencil;
    private _surfaceSelector;
    private _mipmapSelector;
    private _maskConfig;
    private _maskId;
    private _activeMasksDirty;
    private _activeMaskOwners;
    private _paddedBounds;
    private _bounds;
    protected _style: Style;
    private _boundsDirty;
    private _mappers;
    private _elementsPools;
    private _entityMaskId;
    private _entityMaskOwners;
    protected _context: IContextGL;
    _cameraTransform: Matrix3D;
    private _cameraForward;
    _pRttBufferManager: RTTBufferManager;
    protected _depthTextureDirty: boolean;
    protected _depthPrepass: boolean;
    private _snapshotBitmapImage2D;
    private _snapshotRequired;
    private _onInvalidateProperties;
    private _onContextUpdateDelegate;
    private _onSizeInvalidateDelegate;
    _pNumElements: number;
    private _renderEntities;
    protected _opaqueRenderables: IRenderable[];
    protected _blendedRenderables: IRenderable[];
    _disableColor: boolean;
    _disableClear: boolean;
    _renderBlended: boolean;
    private _cullPlanes;
    private _customCullPlanes;
    private _numCullPlanes;
    protected _traverserGroup: RenderGroup;
    protected _maskGroup: RenderGroup;
    private _renderEntity;
    private _zIndex;
    private _renderSceneTransform;
    /**
     *
     */
    get cullPlanes(): Array<Plane3D>;
    set cullPlanes(value: Array<Plane3D>);
    get renderBlended(): boolean;
    set renderBlended(value: boolean);
    get disableColor(): boolean;
    set disableColor(value: boolean);
    get disableClear(): boolean;
    set disableClear(value: boolean);
    /**
     *
     */
    get numElements(): number;
    get context(): IContextGL;
    getPaddedBounds(): Rectangle;
    getBounds(): Box;
    /**
     *
     */
    get style(): Style;
    set style(value: Style);
    parentRenderer: RendererBase;
    /**
     *
     */
    renderableSorter: IRenderEntitySorter;
    get node(): ContainerNode;
    get group(): RenderGroup;
    view: View;
    stage: Stage;
    get blendMode(): string;
    get useNonNativeBlend(): boolean;
    constructor();
    /**
     * Creates a new RendererBase object.
     */
    init(node: INode, group: RenderGroup): void;
    onClear(event: AssetEvent): void;
    onInvalidate(event: AssetEvent): void;
    addRenderEntity(renderEntity: RenderEntity): void;
    removeRenderEntity(renderEntity: RenderEntity): void;
    update(node: INode): void;
    _addMapper(mapper: IMapper): void;
    _removeMapper(mapper: IMapper): void;
    getRenderElements(elements: IAsset): _Render_ElementsBase;
    requestAbstraction(asset: IAsset): IAbstraction;
    storeAbstraction(abstraction: IAbstraction): void;
    /**
     * Renders the potentially visible geometry to the back buffer or texture.
     * @param target An option target texture to render to.
     * @param surfaceSelector The index of a CubeTexture's face to render to.
     * @param additionalClearMask Additional clear mask information, in case extra clear channels are to be omitted.
     */
    render(enableDepthAndStencil?: boolean, surfaceSelector?: number, mipmapSelector?: number, maskConfig?: number): void;
    resetHead(): void;
    traverse(): void;
    _iRenderCascades(enableDepthAndStencil?: boolean, surfaceSelector?: number): void;
    /**
     * Renders the potentially visible geometry to the back buffer or texture. Only executed if everything is set up.
     *
     * @param target An option target texture to render to.
     * @param surfaceSelector The index of a CubeTexture's face to render to.
     * @param additionalClearMask Additional clear mask information, in case extra clear channels are to be omitted.
     */
    executeRender(enableDepthAndStencil?: boolean, surfaceSelector?: number, mipmapSelector?: number): void;
    queueSnapshot(bmd: BitmapImage2D): void;
    /**
     * Draw a list of renderables.
     *
     * @param renderables The renderables to draw.
     */
    drawRenderables(renderRenderables: IRenderable[]): void;
    /**
     * Assign the context once retrieved
     */
    private onContextUpdate;
    /**
     *
     */
    onSizeInvalidate(event: ViewEvent): void;
    /**
     *
     * @param node
     * @returns {boolean}
     */
    enterNode(node: INode): boolean;
    getTraverser(rootNode: ContainerNode): IPartitionTraverser;
    applyEntity(node: ContainerNode): void;
    applyTraversable(traversable: ITraversable): void;
    protected _renderMasks(maskOwners: ContainerNode[]): void;
    private _checkMaskOwners;
    private _invalidateStyle;
    protected _updateBounds(): void;
    _initRender(target: Image2D): void;
}
//# sourceMappingURL=RendererBase.d.ts.map