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

Renderer for AwayJS

import { Box, Sphere, Matrix3D, Vector3D, Rectangle, Matrix } from '@awayjs/core';
import { PickingCollision, ContainerNode } from '@awayjs/view';
import { AttributesView, Float4Attributes, Float3Attributes, Short3Attributes } from '@awayjs/stage';
import { IMaterial } from '../base/IMaterial';
import { ElementsBase } from './ElementsBase';
/**
 * @class away.base.TriangleElements
 */
export declare class TriangleElements extends ElementsBase {
    private static isIE;
    static assetType: string;
    private _faceNormalsDirty;
    private _faceTangentsDirty;
    private _positions;
    private _normals;
    private _tangents;
    private _uvs;
    private _jointIndices;
    private _jointWeights;
    private _jointsPerVertex;
    private _faceNormals;
    private _faceTangents;
    hitTestCache: Object;
    get assetType(): string;
    /**
     *
     */
    get jointsPerVertex(): number;
    set jointsPerVertex(value: number);
    /**
     *
     */
    get positions(): AttributesView;
    /**
     *
     */
    get normals(): Float3Attributes;
    /**
     *
     */
    get tangents(): Float3Attributes;
    /**
     * The raw data of the face normals, in the same order as the faces are listed in the index list.
     */
    get faceNormals(): Float4Attributes;
    /**
     * The raw data of the face tangets, in the same order as the faces are listed in the index list.
     */
    get faceTangents(): Float3Attributes;
    /**
     *
     */
    get uvs(): AttributesView;
    /**
     *
     */
    get jointIndices(): AttributesView;
    /**
     *
     */
    get jointWeights(): AttributesView;
    prepareScale9(bounds: Rectangle, grid: Rectangle, clone: boolean, emitUV?: boolean, uvMatrix?: Matrix): TriangleElements;
    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): any;
    setPositions(arrayBufferView: ArrayBufferView, offset?: number): any;
    setPositions(attributesView: AttributesView, offset?: number): any;
    /**
     * Updates the vertex normals based on the geometry.
     */
    setNormals(array: Array<number>, offset?: number): any;
    setNormals(float32Array: Float32Array, offset?: number): any;
    setNormals(float3Attributes: Float3Attributes, offset?: number): any;
    /**
     * Updates the vertex tangents based on the geometry.
     */
    setTangents(array: Array<number>, offset?: number): any;
    setTangents(float32Array: Float32Array, offset?: number): any;
    setTangents(float3Attributes: Float3Attributes, offset?: number): any;
    /**
     * Updates the uvs based on the geometry.
     */
    setUVs(array: Array<number>, offset?: number): any;
    setUVs(arrayBufferView: ArrayBufferView, offset?: number): any;
    setUVs(attributesView: AttributesView, offset?: number): any;
    /**
     * Updates the joint indices
     */
    setJointIndices(array: Array<number>, offset?: number): any;
    setJointIndices(float32Array: Float32Array, offset?: number): any;
    setJointIndices(attributesView: AttributesView, offset?: number): any;
    /**
     * Updates the joint weights.
     */
    setJointWeights(array: Array<number>, offset?: number): any;
    setJointWeights(float32Array: Float32Array, offset?: number): any;
    setJointWeights(attributesView: AttributesView, offset?: number): any;
    /**
     *
     */
    dispose(): void;
    /**
     * Updates the face indices of the TriangleElements.
     *
     * @param indices The face indices to upload.
     */
    setIndices(array: Array<number>, offset?: number): any;
    setIndices(uint16Array: Uint16Array, offset?: number): any;
    setIndices(short3Attributes: Short3Attributes, offset?: number): any;
    copyTo(elements: TriangleElements): void;
    /**
     * Clones the current object
     * @return An exact duplicate of the current object.
     */
    clone(): TriangleElements;
    scaleUV(scaleU?: number, scaleV?: number, count?: number, offset?: number): void;
    /**
     * Scales the geometry.
     * @param scale The amount by which to scale.
     */
    scale(scale: number, count?: number, offset?: number): void;
    applyTransformation(transform: Matrix3D, count?: number, offset?: number): void;
    /**
     * Updates the tangents for each face.
     */
    private updateFaceTangents;
    /**
     * Updates the normals for each face.
     */
    private updateFaceNormals;
    testCollision(collision: PickingCollision, box: Box, closestFlag: boolean, material: IMaterial, count: number, offset?: number): boolean;
}
import { Stage, ShaderRegisterCache, ShaderRegisterData } from '@awayjs/stage';
import { _Stage_ElementsBase } from '../base/_Stage_ElementsBase';
import { ElementsEvent } from '../events/ElementsEvent';
import { _Render_RenderableBase } from '../base/_Render_RenderableBase';
import { ShaderBase } from '../base/ShaderBase';
import { _Render_ElementsBase } from '../base/_Render_ElementsBase';
/**
 *
 * @class away.pool._Stage_TriangleElements
 */
export declare class _Stage_TriangleElements extends _Stage_ElementsBase {
    private _vao;
    private _vaoIsInvalid;
    get triangleElements(): TriangleElements;
    init(triangleElements: TriangleElements, stage: Stage): void;
    _onInvalidateIndices(event: ElementsEvent): void;
    _onInvalidateVertices(event: ElementsEvent): void;
    onInvalidate(): void;
    onClear(): void;
    _setRenderState(renderRenderable: _Render_RenderableBase, shader: ShaderBase): void;
    draw(renderRenderable: _Render_RenderableBase, shader: ShaderBase & {
        supportModernAPI?: boolean;
        syncUniforms?: () => void;
    }, count: number, offset: number): void;
    /**
     * //TODO
     *
     * @param pool
     * @param renderable
     * @param level
     * @param indexOffset
     * @returns {away.pool.GL_ShapeRenderable}
     * @protected
     */
    _pGetOverflowElements(): _Stage_ElementsBase;
}
/**
 * @class away.pool.LineMaterialPool
 */
export declare class _Render_TriangleElements extends _Render_ElementsBase {
    _includeDependencies(shader: ShaderBase): void;
    _getVertexCode(shader: ShaderBase, registerCache: ShaderRegisterCache, sharedRegisters: ShaderRegisterData): string;
    _getFragmentCode(shader: ShaderBase, registerCache: ShaderRegisterCache, sharedRegisters: ShaderRegisterData): string;
}
//# sourceMappingURL=TriangleElements.d.ts.map