@awayjs/renderer/dist/lib/elements/LineElements.d.ts

Renderer for AwayJS

import { Box, Matrix, Rectangle, Sphere, Vector3D } from '@awayjs/core';
import { AttributesBuffer, AttributesView, Byte4Attributes, Float1Attributes } from '@awayjs/stage';
import { PickingCollision, ContainerNode } from '@awayjs/view';
import { ElementsBase } from './ElementsBase';
/**
 * @class LineElements
 */
export declare class LineElements extends ElementsBase {
    static assetType: string;
    private _positions;
    private _thickness;
    private _colors;
    private _thicknessScale;
    hitTestCache: Object;
    half_thickness: number;
    scaleMode: LineScaleMode;
    dimension: number;
    getThicknessScale(node: ContainerNode, strokeFlag: boolean): Vector3D;
    /**
     *
     * @returns {string}
     */
    get assetType(): string;
    /**
     *
     */
    get positions(): AttributesView;
    /**
     *
     */
    get thickness(): Float1Attributes;
    /**
     *
     */
    get colors(): Byte4Attributes;
    /**
     *
     */
    constructor(concatenatedBuffer?: AttributesBuffer);
    prepareScale9(bounds: Rectangle, grid: Rectangle, clone: boolean, _emitUV?: boolean, _uvMatrix?: Matrix): LineElements;
    updateScale9(scaleX: number, scaleY: number): void;
    getBoxBounds(node?: ContainerNode, strokeFlag?: boolean, matrix3D?: Matrix3D, cache?: Box, target?: Box, count?: number, offset?: number): Box;
    getSphereBounds(center: Vector3D, matrix3D?: Matrix3D, strokeFlag?: boolean, cache?: Sphere, target?: Sphere, count?: number, offset?: number): Sphere;
    hitTestPoint(node: ContainerNode, x: number, y: number, z: number, box: Box, count?: number, offset?: number, idx_count?: number, idx_offset?: number): boolean;
    /**
     *
     */
    setPositions(array: Array<number>, offset?: number): void;
    setPositions(arrayBufferView: ArrayBufferView, offset?: number): void;
    setPositions(attributesView: AttributesView, offset?: number): void;
    /**
     * Updates the thickness.
     */
    setThickness(array: Array<number>, offset?: number): any;
    setThickness(float32Array: Float32Array, offset?: number): any;
    setThickness(float1Attributes: Float1Attributes, offset?: number): any;
    /**
     *
     */
    setColors(array: Array<number>, offset?: number): any;
    setColors(float32Array: Float32Array, offset?: number): any;
    setColors(uint8Array: Uint8Array, offset?: number): any;
    setColors(byte4Attributes: Byte4Attributes, offset?: number): any;
    /**
     *
     */
    dispose(): void;
    /**
     * Clones the current object
     * @return An exact duplicate of the current object.
     */
    clone(): LineElements;
    testCollision(collision: PickingCollision, box: Box, closestFlag: boolean, material: IMaterial, count: number, offset?: number): boolean;
}
import { Matrix3D } from '@awayjs/core';
import { Stage, ShaderRegisterCache, ShaderRegisterData } from '@awayjs/stage';
import { IMaterial } from '../base/IMaterial';
import { _Stage_ElementsBase } from '../base/_Stage_ElementsBase';
import { _Render_RenderableBase } from '../base/_Render_RenderableBase';
import { ShaderBase } from '../base/ShaderBase';
import { _Render_ElementsBase } from '../base/_Render_ElementsBase';
import { LineScaleMode } from './LineScaleMode';
/**
 *
 * @class away.pool._Stage_LineElements
 */
export declare class _Stage_LineElements extends _Stage_ElementsBase {
    private _scale;
    private _vao;
    private _vaoIsInvalid;
    get lineElements(): LineElements;
    init(lineElements: LineElements, stage: Stage): void;
    onInvalidate(): void;
    onClear(): void;
    transformMatrix(renderRenderable: _Render_RenderableBase, matrix: Matrix): Matrix;
    _setRenderState(renderRenderable: _Render_RenderableBase, shader: ShaderBase): void;
    draw(renderRenderable: _Render_RenderableBase, shader: ShaderBase, count: number, offset: number): void;
    /**
     * //TODO
     *
     * @param pool
     * @param renderRenderable
     * @param level
     * @param indexOffset
     * @returns {away.pool.LineSubSpriteRenderable}
     * @protected
     */
    _pGetOverflowElements(): _Stage_ElementsBase;
}
/**
 * @class away.pool._Render_LineElements
 */
export declare class _Render_LineElements extends _Render_ElementsBase {
    secondaryPositionIndex: number;
    thicknessIndex: number;
    uOffsets: {
        oMisc: number;
    };
    _includeDependencies(shader: ShaderBase): void;
    _getVertexCode(shader: ShaderBase, registerCache: ShaderRegisterCache, sharedRegisters: ShaderRegisterData): string;
    _getFragmentCode(shader: ShaderBase, registerCache: ShaderRegisterCache, sharedRegisters: ShaderRegisterData): string;
}
//# sourceMappingURL=LineElements.d.ts.map