The viewer is using three-mesh-bvh as the backbone for it’s BVH implementation. The AccelerationStructure class is a thin wrapper around the library’s MeshBVH class with some additional specific functionality. The speckle viewer uses a dual level BVH for optimal acceleration. The AccelerationStructure is the functional element of the bottom-level acceleration structure. Each individual object will have it’s own BVH, encapsulated by an AccelerationStructure object.

​
Constructors

​
constructor

constructor(bvh: MeshBVH)
Populates/constructs this acceleration structure with the backing BVH. Parameters
  • bvh: The backing BVH as a MeshBVH

​
Accessors

​
bvh

get bvh(): MeshBVH
Gets the backing BVH. Returns: MeshBVH

​
geometry

get geometry(): BufferGeometry
Gets the three.js geometry associated to the BVH.
When building a BVH, three-mesh-bvh library needs a three.js geometry as input. This is that geometry. We don’t use it for rendering.
Returns: BufferGeometry

​
Methods

​
buildBVH

static buildBVH(
    indices: number[],
    position: Float32Array,
    options: BVHOptions = DefaultBVHOptions,
    transform?: Matrix4
): MeshBVH
Build a BVH using the provided geometry data. Parameters
  • indices: Geometry indices
  • position: Geometry vertex positions
  • options: BVHOptions
  • optional transform: A Matrix4 that transforms the geometry data before building the BVH
Returns: MeshBVH

​
getBoundingBox

getBoundingBox(target?: Box3): Box3
Gets the aabb of the entire BVH. Parameters
  • optional target: Box3
Returns: Box3

​
getVertexAtIndex

getVertexAtIndex(index: number): Vector3
Gets position value of a vertex at the given index inside the BVH vertex position array. Parameters
  • index: number
Returns: Vector3

​
raycast

raycast(
    ray: Ray,
    materialOrSide: Side | Material | Material[] = FrontSide
): Intersection<Object3D<Event>>[]
Wrapper over three-mesh-bvh raycast function. Keeps original behavior,but makes sure input and output spaces are correct. Parameters Returns: Intersection

​
raycastFirst

raycastFirst(
    ray: Ray,
    materialOrSide: Side | Material | Material[] = FrontSide
): Intersection<Object3D<Event>>[]
Identical to raycast but stops at first intersection found. Parameters Returns: Intersection

​
shapecast

shapecast(
    callbacks: {
      intersectsBounds: (
        box: Box3,
        isLeaf: boolean,
        score: number | undefined,
        depth: number,
        nodeIndex: number
      ) => ShapecastIntersection | boolean

      traverseBoundsOrder?: (box: Box3) => number
    } & (
      | {
          intersectsRange: (
            triangleOffset: number,
            triangleCount: number,
            contained: boolean,
            depth: number,
            nodeIndex: number,
            box: Box3
          ) => boolean
        }
      | {
          intersectsTriangle: (
            triangle: ExtendedTriangle,
            triangleIndex: number,
            contained: boolean,
            depth: number
          ) => boolean | void
        }
    )
  ): boolean
Generic mechanism to intersect the BVH with various shapes/objects. The callbacks provide granular access to several stages of the BVH intersection process. Parameters
  • callbacks: More details here
Returns: boolean

​
transformInput

transformInput<T extends Vector3 | Ray | Box3>(input: T): T
Transform input vector, ray or box from world space into the acceleration structure’s space.
All the AccelerationStructure methods that deal with querying the BVH: getBoundingBox, getVertexAtIndex, raycast, raycastFirst, shapecast already call this function implicitly.
Parameters Returns: Vector3 | Ray | Box3

​
transformOutput

transformOutput<T extends Vector3 | Ray | Box3>(output: T): T
Transform input vector, ray or box from the acceleration structure’s space into world space. Parameters Returns: Vector3 | Ray | Box3

​
Typedefs

​
VectorLike

type VectorLike = { x: number; y: number; z?: number; w?: number };
Archtype for Vector2, Vector3 and Vector4.

​
BVHOptions

interface BVHOptions {
  strategy: SplitStrategy;
  maxDepth: number;
  maxLeafTris: number;
  verbose: boolean;
  useSharedArrayBuffer: boolean;
  setBoundingBox: boolean;
  onProgress?: () => void;
  [SKIP_GENERATION]: boolean;
}
Based off the original options defined in three-mesh-bvh