Class Octree<T>

constructor

• new Octree<T>(bounds: Box3, keyDesign?: KeyDesign): Octree<T>

  Constructs a new octree.

  Each octant can be uniquely identified by a 3D coordinate and a level. The tree depth is defined by the highest number of bits in the key design.

  If the bounds of the octree are defined directly, the cell size will depend on the bounds and the key design. Alternatively, the bounds can be calculated from a desired cell size via KeyDesign.calculateBounds.

  Type Parameters

  • T

    The type of the octant data.

  Parameters

  • bounds: Box3

    The bounds of the octree.

  • keyDesign: KeyDesign = ...

    The bit allotments for the octant coordinates.

  Returns Octree<T>

Readonlyroot

keyDesign

• get keyDesign(): KeyDesign

  The key design.

  Returns KeyDesign

max

• get max(): Vector3

  The upper bounds of the node.

  Returns Vector3

min

• get min(): Vector3

  The lower bounds of this node.

  Returns Vector3

[iterator]

• "[iterator]"(): Iterator<OctantWrapper<T>>

  Returns an iterator that returns all leaf nodes.

  Returns Iterator<OctantWrapper<T>>

  An iterator.

calculateKeyCoordinates

• calculateKeyCoordinates(
      position: Vector3,
      level: number,
      result: Vector3,
  ): Vector3

  Calculates key coordinates based on a given position and level.

  Parameters

  • position: Vector3

    A position.

  • level: number

    The level.

  • result: Vector3

    A vector to store the result in.

  Returns Vector3

  The key coordinates.

clear

• clear(): void

  Removes all octants.

  Returns void

containsPoint

• containsPoint(point: Vector3): boolean

  Checks if the given point lies inside this octree's boundaries.

  Parameters

  • point: Vector3

    A point.

  Returns boolean

  Whether the given point lies inside this octree.

cull

• cull(region: BoxIntersector): OctantWrapper<T>[]

  Recursively collects nodes that intersect with the specified region.

  Parameters

  • region: BoxIntersector

    A region.

  Returns OctantWrapper<T>[]

  The nodes.

delete

• delete(key: number | Vector3, level?: number): void

  Removes a specific octant.

  Children and empty intermediate parent octants will be removed as well.

  Parameters

  • key: number | Vector3

    A packed key or key coordinates.

  • level: number = 0

    The level of the octant.

  Returns void

findNodesByLevel

• findNodesByLevel(level: number): Node[]

  Fetches all nodes of a specific depth level.

  Parameters

  • level: number

    The depth level.

  Returns Node[]

  The nodes.

get

• get(key: number | Vector3, level: number): T | null | undefined

  Retrieves data from a specific octant.

  Parameters

  • key: number | Vector3

    A packed key or key coordinates.

  • level: number

    The level of the octant.

  Returns T | null | undefined

  The data, or undefined if the octant doesn't exist.

getCellSize

• getCellSize(level: number, result: Vector3): Vector3

  Returns the size of the cells in the specified grid.

  Parameters

  • level: number

    The level. Must be a positive integer.

  • result: Vector3

    A vector to store the result in.

  Returns Vector3

  The cell size.

getCenter

• getCenter(result: Vector3): Vector3

  Calculates the center of this node.

  Parameters

  • result: Vector3

    A vector to store the result in.

  Returns Vector3

  A vector that describes the center of this node.

getDepth

• getDepth(): number

  Calculates the depth of this tree.

  Returns number

  The depth.

getDimensions

• getDimensions(result: Vector3): Vector3

  Calculates the size of this node.

  Parameters

  • result: Vector3

    A vector to store the result in.

  Returns Vector3

  A vector that describes the size of this node.

getGrid

• getGrid(level: number): Map<number, Octant<T>>

  Returns the grid of the specified level.

  Parameters

  • level: number

    The level of the grid.

  Returns Map<number, Octant<T>>

  The requested grid.

  Throws

  If the given level is out of bounds.

getIntersectingNodes

• getIntersectingNodes(raycaster: Raycaster): OctantWrapper<T>[]

  Finds nodes that intersect with the given ray. The intersecting nodes are sorted by distance, closest first.

  Parameters

  • raycaster: Raycaster

    A raycaster.

  Returns OctantWrapper<T>[]

  The intersecting nodes.

getLevels

• getLevels(): number

  Returns the amount of depth levels.

  Returns number

  The levels.

getOctantByPoint

• getOctantByPoint(point: Vector3, level?: number): Octant<T> | undefined

  Retrieves an octant of a specific level that contains the given point.

  Parameters

  • point: Vector3

    A point.

  • level: number = 0

    The level.

  Returns Octant<T> | undefined

  The octant, or undefined if it doesn't exist.

octants

• octants(level?: number): OctreeIterator<T>

  Returns a new octree iterator.

  The octants returned by this iterator are augmented wrappers with explicit positional information.

  Parameters

  • level: number = 0

    The depth level.

  Returns OctreeIterator<T>

  An octree iterator.

  See

  OctantWrapper

set

• set(key: number | Vector3, level: number, data: T | null): void

  Adds data to a specific octant.

  Missing intermediate octants will be created automatically.

  Parameters

  • key: number | Vector3

    A packed key or key coordinates.

  • level: number

    The level of the octant.

  • data: T | null

    The data.

  Returns void