@awayjs/view/dist/lib/pick/RaycastPicker.d.ts

View for AwayJS

import { Vector3D, AbstractionBase, AssetEvent } from '@awayjs/core';
import { IPartitionTraverser } from '../partition/IPartitionTraverser';
import { INode } from '../partition/INode';
import { PickingCollision } from './PickingCollision';
import { PickEntity } from '../base/PickEntity';
import { PickGroup, RaycastPickerPool } from '../PickGroup';
import { IEntity } from '../base/IEntity';
import { ContainerNode } from '../partition/ContainerNode';
import { IContainer } from '../base/IContainer';
/**
 * Picks a 3d object from a view or scene by 3D raycast calculations. Performs
 * an initial coarse boundary calculation to return a subset of entities whose
 * bounding volumes intersect with the specified ray, then triggers an optional
 * picking collider on individual renderable objects to further determine the
 * precise values of the picking ray collision.
 *
 * @class away.pick.RaycastPicker
 */
export declare class RaycastPicker extends AbstractionBase implements IPartitionTraverser {
    private static _rayPosition;
    private static _rayDirection;
    private _dragNode;
    get node(): INode;
    pickGroup: PickGroup;
    shapeFlag: boolean;
    findClosestCollision: boolean;
    /**
     *
     */
    layeredView: boolean;
    private _rootNode;
    private _shapeFlag;
    private _globalRayPosition;
    private _globalRayDirection;
    private _ignoredEntities;
    private _entities;
    private _pickers;
    private _collectedEntities;
    init(node: ContainerNode, pool: RaycastPickerPool): void;
    onClear(event: AssetEvent): void;
    traverse(): void;
    getTraverser(node: ContainerNode): IPartitionTraverser;
    get dragNode(): ContainerNode;
    set dragNode(node: ContainerNode);
    /**
     * Returns true if the current node is at least partly in the frustum. If
     * so, the partition node knows to pass on the traverser to its children.
     *
     * @param node The Partition3DNode object to frustum-test.
     */
    enterNode(node: ContainerNode): boolean;
    /**
     * @inheritDoc
     */
    isIntersectingRay(globalRayPosition: Vector3D, globalRayDirection: Vector3D, shapeFlag?: boolean): boolean;
    /**
     * @inheritDoc
     */
    _isIntersectingRayInternal(rootNode: INode, globalRayPosition: Vector3D, globalRayDirection: Vector3D, shapeFlag: boolean): boolean;
    /**
     * @inheritDoc
     */
    getCollision(rayPosition: Vector3D, rayDirection: Vector3D, shapeFlag?: boolean, startingCollision?: PickingCollision): PickingCollision;
    getViewCollision(x: number, y: number, shapeFlag?: boolean, startingCollision?: PickingCollision): PickingCollision;
    _getCollisionInternal(rayPosition: Vector3D, rayDirection: Vector3D, shapeFlag: boolean, maskFlag: boolean, startingCollision: PickingCollision): PickingCollision;
    getObjectsUnderPoint(rayPosition: Vector3D, rayDirection: Vector3D): IContainer[];
    _collectEntities(collectedEntities: PickEntity[], dragNode?: INode): void;
    setIgnoreList(entities: Array<IEntity>): void;
    private isIgnored;
    private static sortOnNearT;
    private _getPickingCollision;
    private _getColliders;
    private static updatePosition;
    dispose(): void;
    /**
     *
     * @param entity
     */
    applyEntity(node: INode): void;
}
//# sourceMappingURL=RaycastPicker.d.ts.map