Class CpuPrimitiveBvhAbstract

constructor

• new CpuPrimitiveBvh(
      layout: BvhPrimitiveLayout,
      options?: BvhPrimitiveTreeOptions,
  ): CpuPrimitiveBvh

  Parameters

  • layout: BvhPrimitiveLayout
  • options: BvhPrimitiveTreeOptions = {}

  Returns CpuPrimitiveBvh

Readonlylayout

depth

• get depth(): number

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

  Returns number

nodeCount

• get nodeCount(): number

  Returns number

primitiveCount

• get primitiveCount(): number

  Returns number

closestPointToPoint

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

  The primitive nearest point and the nearest point on it (ties: the lower entry), as CpuMeshBvh.closestPointToPoint: null when none is within maxThreshold; the walk stops at the first one within minThreshold. target.point is written in place when present.

  Parameters

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

  Returns BvhPrimitiveClosestPoint<BvhVector3Like> | null

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

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

refit

• refit(input?: BvhPointsInput | BvhSegmentsInput): void

  Rereads the primitives' positions (from input, else the source the tree was built from) and refits every box, keeping the tree's shape: three-mesh-bvh's refit(). The index and range must be the build's.

  Parameters

  • Optionalinput: BvhPointsInput | BvhSegmentsInput

  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

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