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

Renderer for AwayJS

import { Matrix3D, Plane3D, Vector3D, AbstractionBase, IAsset, Box, Rectangle, IAbstraction, IAbstractionPool } from '@awayjs/core';
import { BitmapImage2D, IContextGL, Stage, StageEvent, RTTBufferManager, Image2D } from '@awayjs/stage';
import { View, ViewEvent, IPartitionTraverser, IEntityTraverser, INode, ContainerNode } from '@awayjs/view';
import { _Render_RenderableBase } from './base/_Render_RenderableBase';
import { IMapper } from './base/IMapper';
import { RenderGroup } from './RenderGroup';
import { IRenderEntitySorter } from './sort/IRenderEntitySorter';
import { _Render_Renderer } from './CacheRenderer';
import { _Render_ElementsBase } from './base/_Render_ElementsBase';
import { Style } from './base/Style';
import { IRenderable } from './base/IRenderable';
import { AbstractionSet } from '@awayjs/core/dist/lib/base/AbstractionSet';
/**
 * 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;
    readonly abstractions: AbstractionSet;
    _renderObjects: Record<number, _Render_Renderer>;
    protected _renderMatrix: Matrix3D;
    protected _parentNode: ContainerNode;
    private _boundsPicker;
    private _boundsScale;
    private _parentPosition;
    private _maskConfig;
    private _maskId;
    private _activeMasksDirty;
    private _activeMaskOwners;
    protected _paddedBounds: Rectangle;
    private _bounds;
    protected _style: Style;
    private _boundsDirty;
    private _mappers;
    private _elementsPools;
    protected _context: IContextGL;
    _cameraTransform: Matrix3D;
    private _cameraForward;
    _pRttBufferManager: RTTBufferManager;
    protected _depthTextureDirty: boolean;
    protected _depthPrepass: boolean;
    private _snapshotBitmapImage2D;
    private _snapshotRequired;
    private _onInvalidateProperties;
    private _onContextUpdateDelegate;
    protected _onSizeInvalidateDelegate: (event: ViewEvent | StageEvent) => void;
    _pNumElements: number;
    protected _opaqueRenderables: _Render_RenderableBase[];
    protected _blendedRenderables: _Render_RenderableBase[];
    _disableColor: boolean;
    _disableClear: boolean;
    _renderBlended: boolean;
    private _cullPlanes;
    private _customCullPlanes;
    private _numCullPlanes;
    protected _traverserGroup: RenderGroup;
    protected _maskGroup: RenderGroup;
    private _pickEntity;
    private _renderEntity;
    /**
     *
     */
    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;
    getBoundsScale(): number;
    getParentPosition(): Vector3D;
    /**
     *
     */
    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(): void;
    onInvalidate(): 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: _Render_RenderableBase[]): void;
    /**
     * Assign the context once retrieved
     */
    private onContextUpdate;
    /**
     *
     */
    onSizeInvalidate(event: ViewEvent | StageEvent): void;
    /**
     *
     * @param node
     * @returns {boolean}
     */
    enterNode(node: INode): boolean;
    getTraverser(rootNode: ContainerNode): IPartitionTraverser | void;
    applyEntity(node: ContainerNode): void;
    applyTraversable(renderable: IRenderable): void;
    protected _renderMasks(maskOwners: ContainerNode[]): void;
    private _checkMaskOwners;
    _onInvalidateStyle(): void;
    protected _updateBounds(): void;
    _initRender(target: Image2D): void;
}
//# sourceMappingURL=RendererBase.d.ts.map