Class QuadTree

constructor

• new QuadTree(
      world: World,
      bounds: Bounds,
      max_objects?: number,
      max_levels?: number,
      level?: number,
  ): QuadTree

  Parameters

  • world: World

    the physic world this QuadTree belongs to

  • bounds: Bounds

    bounds of the node

  • Optionalmax_objects: number = 4

    max objects a node can hold before splitting into 4 subnodes

  • Optionalmax_levels: number = 4

    total max levels inside root Quadtree

  • Optionallevel: number = 0

    deepth level, required for subnodes

  Returns QuadTree

bounds

level

max_levels

max_objects

nodes

objects

world

clear

• clear(bounds?: Bounds): void

  clear the quadtree

  Parameters

  • Optionalbounds: Bounds

    the bounds to be cleared

  Returns void

getIndex

• getIndex(item: any): number

  Parameters

  • item: any

  Returns number

hasChildren

• hasChildren(): boolean

  return true if the node has any children

  Returns boolean

  true if the node has any children

insert

• insert(item: object): void

  Insert the given object into the node. If the node exceeds the capacity, it will split and add all objects to their corresponding subnodes.

  Parameters

  • item: object

    object to be added

  Returns void

insertContainer

• insertContainer(container: Container): void

  Insert the given object container into the node.

  Parameters

  • container: Container

    group of objects to be added

  Returns void

isPrunable

• isPrunable(): boolean

  return true if the node is prunable

  Returns boolean

  true if the node is prunable

remove

• remove(item: object): boolean

  Remove the given item from the quadtree. (this function won't recalculate the impacted node)

  Parameters

  • item: object

    object to be removed

  Returns boolean

  true if the item was found and removed.

removeContainer

• removeContainer(container: Container): void

  Recursively remove the given container and its descendants from the quadtree. Mirrors insertContainer so the broadphase can be kept in sync when a subtree is detached via Container.removeChildNow between two world.update() rebuilds (pointer events fire async in that window and would otherwise hit destroyed renderables).

  Parameters

  • container: Container

    group of objects to be removed

  Returns void

retrieve

• retrieve(item: object, fn?: object, result?: object[]): object[]

  Return all objects that could collide with the given object.

  Re-entrancy contract: when called with no explicit result argument, this method reuses a single root-level scratch array to avoid per-frame allocations. The returned reference is therefore not safe to retain past the next retrieve() call, AND it is not safe to issue another scratch-mode retrieve() while iterating the previous result — the second call clears the scratch and refills it, corrupting the outer iteration. In-engine callers (pointerevent.ts, detector.js) iterate synchronously and never recurse into retrieve(), so they're fine. User-facing portable APIs (adapter.queryAABB, adapter.raycast) pass their own array via the result parameter, which bypasses the scratch entirely and is safe to call from inside collision handlers.

  Parameters

  • item: object

    object to be checked against

  • Optionalfn: object

    a sorting function for the returned array

  • Optionalresult: object[]

    optional caller-supplied result array. Pass an explicit (typically empty) array to sidestep the shared scratch — required for re-entrancy safety.

  Returns object[]

  array with all detected objects

split

• split(): void

  Returns void