Class BvhLineLoopBoundsTree

Readonlygeometry

Readonlylayout

depth

• get depth(): number

  The deepest box's depth, as traverse reports it (the root's children at 1).

  Returns number

mode

• get mode(): BvhSegmentMode

  How the tree's entries pair up.

  Returns BvhSegmentMode

nodeCount

• get nodeCount(): number

  Returns number

primitiveCount

• get primitiveCount(): number

  Returns number

Staticbuild

• build(
      input: BvhSegmentsInput,
      options?: BvhPrimitiveBuildOptions,
  ): CpuSegmentsBvh

  Builds a tree over the input's segments (see the file comment); keeps input as its source.

  Parameters

  • input: BvhSegmentsInput
  • options: BvhPrimitiveBuildOptions = {}

  Returns CpuSegmentsBvh

closestPointToPoint

• closestPointToPoint(
      point: Vector3,
      target?: Partial<BvhPrimitiveClosestPoint<Vector3>>,
      minThreshold?: number,
      maxThreshold?: number,
  ): BvhPrimitiveClosestPoint<Vector3> | null

  The nearest point on any segment to point (geometry space): { point, distance, index }.

  Parameters

  • point: Vector3
  • target: Partial<BvhPrimitiveClosestPoint<Vector3>> = {}
  • minThreshold: number = 0
  • maxThreshold: number = Infinity

  Returns BvhPrimitiveClosestPoint<Vector3> | null

current

• current(): boolean

  Returns boolean

Staticdeserialize

• deserialize(
      bytes: ArrayBuffer | ArrayBufferView<ArrayBufferLike>,
      options?: BvhPrimitiveTreeOptions,
  ): CpuSegmentsBvh

  Reads bytes from serialize, checked.

  Parameters

  • bytes: ArrayBuffer | ArrayBufferView<ArrayBufferLike>
  • options: BvhPrimitiveTreeOptions = {}

  Returns CpuSegmentsBvh

estimateMemoryInBytes

• estimateMemoryInBytes(): number

  Bytes this object holds: nodes, records and bounds. Not the source.

  Returns number

getBoundingBox

• getBoundingBox<T extends BvhBoxTarget = Float32Array<ArrayBufferLike>>(
      target?: T,
  ): T

  Box around every primitive, current after refit, as CpuMeshBvh.getBoundingBox.

  Type Parameters

  • T extends BvhBoxTarget = Float32Array<ArrayBufferLike>

  Parameters

  • Optionaltarget: T

  Returns T

getSegment

• getSegment<T extends BvhSegmentLike = BvhSegment>(
      treePosition: number,
      target?: T,
  ): T

  The segment at a tree position, as the tree stores it.

  Type Parameters

  • T extends BvhSegmentLike = BvhSegment

  Parameters

  • treePosition: number
  • Optionaltarget: T

  Returns T

raycast

• raycast(
      ray: BvhRayLike,
      options?: BvhPrimitiveRaycastOptions,
  ): BvhPrimitiveRaycastHit[]

  Every primitive within threshold of the ray, sorted by distance (then entry): three's Points.raycast / Line.raycast in the tree's space. The direction is normalized first unless it is unit length (three's rays are).

  Parameters

  • ray: BvhRayLike
  • options: BvhPrimitiveRaycastOptions = {}

  Returns BvhPrimitiveRaycastHit[]

raycastFirst

• raycastFirst(
      ray: BvhRayLike,
      options?: BvhPrimitiveRaycastOptions,
  ): BvhPrimitiveRaycastHit | null

  The closest primitive within threshold of the ray (ties: the lower entry), or null: three-mesh-bvh's firstHitOnly.

  Parameters

  • ray: BvhRayLike
  • options: BvhPrimitiveRaycastOptions = {}

  Returns BvhPrimitiveRaycastHit | null

raycastObject3D

• raycastObject3D(
      object: Line,
      raycaster: Raycaster,
      intersects?: Intersection<Object3D<Object3DEventMap>>[],
  ): Intersection<Object3D<Object3DEventMap>>[]

  three's Line.raycast for object (whose geometry this tree is), over the tree: see the file comment.

  Parameters

  • object: Line
  • raycaster: Raycaster
  • intersects: Intersection<Object3D<Object3DEventMap>>[] = []

  Returns Intersection<Object3D<Object3DEventMap>>[]

refit

• refit(input?: BvhPointsInput): void

  Refits to the geometry's current positions (three-mesh-bvh's refit()); with input, to those arrays.

  Parameters

  • Optionalinput: BvhPointsInput

  Returns void

resolvePrimitiveIndex

• resolvePrimitiveIndex(treePosition: number): number

  The entry of the primitive at a tree position (as traverse reports them).

  Parameters

  • treePosition: number

  Returns number

serialize

• serialize(): ArrayBuffer

  The tree as bytes: a 64-byte header ("BVHP", format 1, kind, mode, entry range, counts, bounds), the nodes, the records. CpuPointsBvh.deserialize and CpuSegmentsBvh.deserialize read it back, checked.

  Returns ArrayBuffer

shapecast

• shapecast(callbacks: BvhSegmentsShapecastCallbacks<Line3, Box3>): boolean

  three-mesh-bvh's LineSegmentsBVH.shapecast, with Box3 boxes and Line3 segments (scratch objects).

  Parameters

  • callbacks: BvhSegmentsShapecastCallbacks<Line3, Box3>

  Returns boolean

traverse

• traverse(callbacks: BvhTraverseCallbacks): boolean

  Walks the tree with CpuMeshBvh.traverse's contract (three-mesh-bvh's shapecast): depth first, the root's box never asked about, each child scored once by boundsTraverseOrder and the lower score first, a falsy intersectsBounds skipping the box, a contained box reported as one range, a truthy intersectsRange stopping the walk. Ranges are tree positions: map them with resolvePrimitiveIndex. Returns true when stopped.

  Parameters

  • callbacks: BvhTraverseCallbacks

  Returns boolean

traverseNodes

• traverseNodes(
      callback: (
          depth: number,
          isLeaf: boolean,
          box: Float32Array,
          offsetOrSplit: number,
          count: number,
      ) => unknown,
  ): void

  three-mesh-bvh's node walk, as CpuMeshBvh.traverseNodes (for the helper and the debug functions): every node depth first, the root at depth 0 with the tree's bounds; a leaf gets its first tree position and count, an inner node the axis its children's centres lie furthest apart on.

  Parameters

  • callback: (
        depth: number,
        isLeaf: boolean,
        box: Float32Array,
        offsetOrSplit: number,
        count: number,
    ) => unknown

  Returns void

writePrimitiveRangeBounds

• writePrimitiveRangeBounds(
      offset: number,
      count: number,
      target:
          | Float32Array<ArrayBufferLike>
          | number[]
          | Float64Array<ArrayBufferLike>,
      targetOffset?: number,
  ): void

  The box around the primitives at tree positions offset to offset + count - 1: read from the source when the tree has one (so edits since the last refit show, as validateBounds wants), else from the records.

  Parameters

  • offset: number
  • count: number
  • target: Float32Array<ArrayBufferLike> | number[] | Float64Array<ArrayBufferLike>
  • targetOffset: number = 0

  Returns void