八叉树（Octree）Typescript 实现

export class Octree {

  // 父&子树
  private parent_node: any;
  private children_nodes: Octree[];

  // 原点
  private oringePosition: THREE.Vector3;
  private halfX: number;
  private halfY: number;
  private halfZ: number;

  // 树深度
  public depth: number;

  // 内部实体
  private entities: any[];

  private _all_entities = new Array();
  private _to_update: THREE.Mesh[];
  // 叶子？叶节点
  private _leaves: any;

  private _need_leaves_update: boolean;
  private _need_all_entities_update: boolean;

  private BoxGeo: THREE.Geometry;
  public BoxMesh: THREE.Mesh;

  entities_per_node = 1;
  max_depth = 5;

  constructor(parent: Octree, origin, halfwidth, halfheight, halfdepth) {
    this.oringePosition = origin;
    this.halfX = halfwidth;
    this.halfY = halfheight;
    this.halfZ = halfdepth;

    this.depth = parent === null ? 0 : parent.depth + 1;

    // 设置当前树内无实体
    this.entities = new Array();
    // 父子节点
    this.parent_node = parent;
    this.children_nodes = new Array();

    this._to_update = parent === null ? new Array() : parent._to_update;

    this._leaves = new Array();
    this._leaves.push(this);

    this._need_leaves_update = false;
    this._need_all_entities_update = false;

    // 视觉感受
    this.BoxGeo = new THREE.CubeGeometry(this.halfX * 2, this.halfY * 2, this.halfZ * 2);
    this.BoxMesh = new THREE.Mesh(this.BoxGeo, new THREE.MeshBasicMaterial({color: 0x0, opacity: 1, wireframe: true}));
    this.BoxMesh.position.set(this.oringePosition.clone().x, this.oringePosition.clone().y, this.oringePosition.clone().z);

    if (parent !== null) {
      this.BoxMesh.position.sub(parent.oringePosition);
      parent.BoxMesh.add(this.BoxMesh);
    }
  }

  // 当实体位置改变
  onEntityPoseChanged(entity) {
    if (this._to_update.indexOf(entity) === -1) {
      this._to_update.push(entity);
    }
  }

  // 判断交叉
  intersects(entity) {
    return this.contains(entity.position);
  };

  // 是否包含
  contains(point) {
    let diff = new THREE.Vector3();
    // subVectors方法用来将三维向量的(x,y,z)坐标值分别于参数(a,b)的(x,y,z)相减.并返回新的坐标值的三维向量.
    diff.subVectors(point, this.oringePosition);
    return Math.abs(diff.x) <= this.halfX
      && Math.abs(diff.y) <= this.halfY
      && Math.abs(diff.z) <= this.halfZ;
  };

  // 子节点更新
  needLeavesUpdate() {
    let iter = this;
    while (iter !== null) {
      iter._need_leaves_update = true;
      iter = iter.parent_node;
    }
  };

  // 将实体从当前节点中删除，并将当前this指向根节点
  remove(entity) {
    for (let i = 0; i < this.entities.length; i++) {
      if (this.entities[i] === entity) {
        this.entities.splice(i, 1);
        break;
      }
    }
    // 删除过后将当前this指向根结点
    let iter = this;
    while (iter !== null) {
      iter._need_all_entities_update = true;
      iter = iter.parent_node;
    }
  };

  // 细分
  subdivide() {
    /*       _____________
         /  4   /  5   /   |         y
        /_____ /______/ |  |         |
       /      /      /  |  |         |___ x
      /_____ / _____/   |/ |        /
      |   0  |  1   |  |/7 /       /
      |_____ |_____ |/ | /       z
      |   2  |  3   | |/
      |_____ |_____ |/ (lol)
    */

    if (this.depth >= this.max_depth) {
      return;
    }

    this.needLeavesUpdate();

    let qwidth = this.halfX / 2;
    let qheight = this.halfY / 2;
    let qdepth = this.halfZ / 2;

    this.children_nodes[0] = new Octree(this, new THREE.Vector3(this.oringePosition.x - qwidth,
      this.oringePosition.y + qheight,
      this.oringePosition.z + qdepth),
      qwidth, qheight, qdepth);

    this.children_nodes[1] = new Octree(this, new THREE.Vector3(this.oringePosition.x + qwidth,
      this.oringePosition.y + qheight,
      this.oringePosition.z + qdepth),
      qwidth, qheight, qdepth);

    this.children_nodes[2] = new Octree(this, new THREE.Vector3(this.oringePosition.x - qwidth,
      this.oringePosition.y - qheight,
      this.oringePosition.z + qdepth),
      qwidth, qheight, qdepth);

    this.children_nodes[3] = new Octree(this, new THREE.Vector3(this.oringePosition.x + qwidth,
      this.oringePosition.y - qheight,
      this.oringePosition.z + qdepth),
      qwidth, qheight, qdepth);

    this.children_nodes[4] = new Octree(this, new THREE.Vector3(this.oringePosition.x - qwidth,
      this.oringePosition.y + qheight,
      this.oringePosition.z - qdepth),
      qwidth, qheight, qdepth);

    this.children_nodes[5] = new Octree(this, new THREE.Vector3(this.oringePosition.x + qwidth,
      this.oringePosition.y + qheight,
      this.oringePosition.z - qdepth),
      qwidth, qheight, qdepth);

    this.children_nodes[6] = new Octree(this, new THREE.Vector3(this.oringePosition.x - qwidth,
      this.oringePosition.y - qheight,
      this.oringePosition.z - qdepth),
      qwidth, qheight, qdepth);

    this.children_nodes[7] = new Octree(this, new THREE.Vector3(this.oringePosition.x + qwidth,
      this.oringePosition.y - qheight,
      this.oringePosition.z - qdepth),
      qwidth, qheight, qdepth);
  };

  add(entity) {

    let _this = this;

    function addToThis() {
      let iter = _this;
      while (iter !== null) {
        iter._need_all_entities_update = true;
        iter = iter.parent_node;
      }
      _this.entities.push(entity);
      _this.BoxMesh.visible = true;
    }

    // 如果不包含=>返回
    // 也就是说如果新增的Mesh 不在大Mesh中，不进行查找
    if (!this.intersects(entity)) {
      return;
    }

    if (this.depth >= this.max_depth) {
      addToThis();
    }
    else if (this.children_nodes.length === 0) {
      // ↑小于最大深度&没有子节点并且它里面没有实体的时候
      // ↓每个节点中的数量小于规定要求
      if (this.entities.length < this.entities_per_node) {
        addToThis();
      }
      else {
        // 如果它里面有实体，则拆分
        this.subdivide();
        // 拆分过后，如果内部有实体，则从这个节点中删除，并重新对所有实体做add动作（通过this值的变化）
        if (this.entities.length !== 0) {
          let entities_tmp = this.entities.slice();
          this.entities.length = 0;
          while (entities_tmp.length > 0) {
            let ent = entities_tmp.pop();
            this.remove(ent);
            this.add(ent);
          }
        }
        // 然后再将这个节点添加到指定位置
        this.add(entity);
      }
    }
    else {
      // ↑如果它当前有节点，已经分成八份
      // check if the obb intersects multiple children
      let child_id = -1;
      let multiple_intersect = false;
      for (let i = 0; i < this.children_nodes.length; i++) {
        if (this.children_nodes[i].intersects(entity)) {
          if (child_id !== -1) {
            multiple_intersect = true;
            break;
          }
          child_id = i;
        }
      }
      // 把当前结点放入制定的位置中
      if (multiple_intersect) {
        addToThis();
      }
      else {
        // 放入0节点中
        this.children_nodes[child_id].add(entity);
      }
    }
  }

  empty() {
    if (this.entities.length > 0) {
      return false;
    }

    for (let i = 0; i < this.children_nodes.length; i++) {
      if (!this.children_nodes[i].empty()) {
        return false;
      }
    }
    return true;
  };

  countChildrenIntersections(max, entity) {
    let children_idx = new Array();
    for (let j = 0; j < this.children_nodes.length; j++) {
      if (this.children_nodes[j].intersects(entity)) {
        children_idx.push(j);
      }
      if (children_idx.length === max) {
        break;
      }
    }
    return children_idx;
  }

  // updates children entities reference
  updateChildrenEntities() {
    if (this._need_all_entities_update) {
      this._all_entities.length = 0;
      for (let i = 0; i < this.children_nodes.length; i++) {
        this.children_nodes[i].updateChildrenEntities();
        this._all_entities = this._all_entities.concat(this.children_nodes[i]._all_entities);
      }

      for (let i = 0; i < this.entities.length; i++) {
        this._all_entities.push([this.entities[i], this]);
      }
    }
  }

  // updates leaves reference
  updateLeaves() {
    if (this._need_leaves_update) {
      this._leaves.length = 0;
      for (let i = 0; i < this.children_nodes.length; i++) {

        this.children_nodes[i].updateLeaves();
        this._leaves = this._leaves.concat(this.children_nodes[i]._leaves);
      }

      if (this.children_nodes.length === 0) {
        this._leaves.push(this);
      }

      this._need_leaves_update = false;
    }
  }

  update() {
    let _this = this;
    _this.updateChildrenEntities();
    let entities_tmp = this._all_entities.slice();
    entities_tmp.forEach(function (element) {
      let entity = element[0];

      for (let i = 0; i < _this._to_update.length; i++) {
        if (entity === _this._to_update[i]) {
          let octree;
          let intersections;

          // check if multiple intersection with children
          // if yes do same recursively with parents till we can fit it entirely
          // in one node, and add it to this node
          octree = element[1];
          while (octree !== null) {
            intersections = octree.countChildrenIntersections(2, entity);

            if (intersections.length === 1) {
              // don‘t perform any operation if no update is required
              if (element[1] === octree.children_nodes[intersections[0]]) {
                break;
              }
              element[1].remove(entity);
              octree.children_nodes[intersections[0]].add(entity);
              break;
            }
            else if (octree.parent_node === null && intersections.length > 0) {
              element[1].remove(entity);
              octree.add(entity);
              break;
            }
            else {
              octree = octree.parent_node;
            }
          }
          _this._to_update.splice(i, 1);
          break;
        }
      }
    });

    // update _all_entities arrays
    _this.updateChildrenEntities();

    // get rid of dead leaves
    _this.updateLeaves();

    function pruneUp(node) {
      if (node._all_entities.length <= 1) {
        // remove the children from the leaves array and detach their mesh from parents
        let removeChildrenNodes = function (nodes) {
          for (let i = 0; i < nodes.children_nodes.length; i++) {
            removeChildrenNodes(nodes.children_nodes[i]);
            let idx = _this._leaves.indexOf(nodes.children_nodes[i]);
            if (idx !== -1) {
              _this._leaves.splice(idx, 1);
            }
            nodes.BoxMesh.remove(nodes.children_nodes[i].BoxMesh);
          }
        };

        removeChildrenNodes(node);

        node.needLeavesUpdate();
        node.children_nodes.length = 0;

        if (node._all_entities.length === 1 && (node._all_entities[0])[1] !== node) {
          // if the entity was in a one of the child, put it in current node
          node._all_entities[0][1] = node;	// will update this ref for parents node too
          node.add(node._all_entities[0][0]);
        }
        if (node.parent_node !== null) {
          pruneUp(node.parent_node);
        }
      }
    }

    this._leaves.forEach(function (node) {
      pruneUp(node);
    });
  };

}