场景管理：八叉树算法C++实现

简单实现了场景管理八叉树算法

代码结构：

object.h，object.cpp 被管理的对象类
octree_node.h，octree_node.cpp 八叉树类
main.cpp程序入口

object.h

#pragma once
/*
//被管理的对象类
*/
class Object
{
public:
Object(float _x,float _y,float _z,float _xSize,float _ySize,float _zSize);
~Object();
public:
//对象的属性，例如坐标和长宽高，以左上角为锚点
float x;
float y;
float z;
float xSize;
float ySize;
float zSize;
};

object.cpp

#include "object.h"

Object::Object(float _x,float _y,float _z,float _xSize,float _ySize,float _zSize):
x(_x),
y(_y),
z(_z),
xSize(_xSize),
ySize(_ySize),
zSize(_zSize)
{
}

Object::~Object()
{
}

octree_node.h

/*
//八叉树节点类，用头节点代表八叉树
//采用opengl右手坐标系，靠近原点的那个角为锚点，方便计算
//本八叉树的策略是：1，一次划分所有节点，是满树；2，当立方体空间完全包含某物体才剔除,当立方体空间与某物体相交或者完全包含时才查询；3，对象放在完全包含它的区域叶子节点内，非根节点不存储对象，默认为物体不可能跨多个叶子节点，都在一个叶子节点的空间范围内部，未考虑交叉的情况
*/
#pragma once
#include <list>

//八叉树节点类型
enum OctreeType
{
ROOT,                   //根
BOTTOM_LEFT_FRONT,		// 1
BOTTOM_RIGHT_FRONT,		// 2
BOTTOM_LEFT_BACK,		// 3
BOTTOM_RIGHT_BACK,      // 4
TOP_LEFT_FRONT,         // 5
TOP_RIGHT_FRONT,        // 6
TOP_LEFT_BACK,          // 7
TOP_RIGHT_BACK          // 8
};

template <class T>
class OctreeNode
{
public:
OctreeNode(float _x,float _y,float _z,float _xSize,float _ySize,float _zSize,OctreeType _octreeNodeType,int _level,int _maxLevel);
~OctreeNode();
public:
void BuildTree(int level); //建立八叉树，划分到所有子节点
void InsertObject(T *object); //插入对象
std::list<T *> GetObjectsAt(float px,float py,float pz,float x_size,float y_size,float z_size); //查询对象,获得一片区域里的对象链表,考虑包含或相交,由于
void RemoveObjectsAt(float px,float py,float pz,float x_size,float y_size,float z_size); //删除对象，删除一片区域里的对象，此处只考虑完全包含的
private:
bool IsContain(float px,float py,float pz,float x_size,float y_size,float z_size,T *object) const; //判断某个区域是否包含某对象
bool IsContain(float px,float py,float pz,float x_size,float y_size,float z_size,OctreeNode<T> *octreeNode) const; //重载，判断某个区域是否包含某个节点
bool IsInterSect(float px,float py,float pz,float x_size,float y_size,float z_size,OctreeNode<T> *octreeNode) const; //判断某个区域是否与节点相交，如果相交，则查询时要递归到其子节点
public:
std::list<T *> objectList; //节点存储的对象列表
private:
//节点属性
OctreeType octreeNodeType;
float x;
float y;
float z;
float xSize;
float ySize;
float zSize;
int level;
int maxLevel;
//子节点,根据opengl坐标系，依次坐标增大
OctreeNode *bottom_left_front_node;
OctreeNode *bottom_right_front_node;
OctreeNode *bottom_left_back_node;
OctreeNode *bottom_right_back_node;
OctreeNode *top_left_front_node;
OctreeNode *top_right_front_node;
OctreeNode *top_left_back_node;
OctreeNode *top_right_back_node;
};

octree_node.cpp

#include "octree_node.h"

template <class T>
OctreeNode<T>::OctreeNode(float _x,float _y,float _z,float _xSize,float _ySize,float _zSize,OctreeType _octreeNodeType,int _level,int _maxLevel):
x(_x),
y(_y),
z(_z),
xSize(_xSize),
ySize(_ySize),
zSize(_zSize),
octreeNodeType(_octreeNodeType),
level(_level),
maxLevel(_maxLevel)
{
//初始子节点都赋空值
bottom_left_front_node=nullptr;
bottom_right_front_node=nullptr;
bottom_left_back_node=nullptr;
bottom_right_back_node=nullptr;
top_left_front_node=nullptr;
top_right_front_node=nullptr;
top_left_back_node=nullptr;
top_right_back_node=nullptr;
}

template <class T>
OctreeNode<T>::~OctreeNode()
{

}

template <class T>
bool OctreeNode<T>::IsContain(float px,float py,float pz,float x_size,float y_size,float z_size,T *object) const
{
if(object->x>=px
&&object->x+object->xSize<=px+x_size
&&object->y>=py
&&object->y+object->ySize<=py+y_size
&&object->z>=pz
&&object->z+object->zSize<=pz+z_size)
return true;
return false;
}

template <class T>
bool OctreeNode<T>::IsContain(float px,float py,float pz,float x_size,float y_size,float z_size,OctreeNode<T> *octreeNode) const
{
if(octreeNode->x>=px
&&octreeNode->x+octreeNode->xSize<=px+x_size
&&octreeNode->y>=py
&&octreeNode->y+octreeNode->ySize<=py+y_size
&&octreeNode->z>=pz
&&octreeNode->z+octreeNode->zSize<=pz+z_size)
return true;
return false;
}

template <class T>
bool OctreeNode<T>::IsInterSect(float px,float py,float pz,float x_size,float y_size,float z_size,OctreeNode<T> *octreeNode) const
{
if(octreeNode->x>px+x_size
||octreeNode->x+xSize<px
||octreeNode->y>py+y_size
||octreeNode->y+ySize<py
||octreeNode->z+zSize<pz
||octreeNode->z>pz+z_size)
return false;
return true;
}

template <class T>
void OctreeNode<T>::BuildTree(int level)
{
//递归地进行八叉树空间划分，直到最大深度
if(level==maxLevel)
return;
//创建子节点
bottom_left_front_node=new OctreeNode(x,y,z,xSize/2,ySize/2,zSize/2,BOTTOM_LEFT_FRONT,level+1,maxLevel);
bottom_right_front_node=new OctreeNode(x+xSize/2,y,z,xSize/2,ySize/2,zSize/2,BOTTOM_RIGHT_FRONT,level+1,maxLevel);
bottom_left_back_node=new OctreeNode(x,y+ySize/2,z,xSize/2,ySize/2,zSize/2,BOTTOM_LEFT_BACK,level+1,maxLevel);
bottom_right_back_node=new OctreeNode(x+xSize/2,y+ySize/2,z,xSize/2,ySize/2,zSize/2,BOTTOM_RIGHT_BACK,level+1,maxLevel);
top_left_front_node=new OctreeNode(x,y,z+zSize/2,xSize/2,ySize/2,zSize/2,TOP_LEFT_FRONT,level+1,maxLevel);
top_right_front_node=new OctreeNode(x+xSize/2,y,z+zSize/2,xSize/2,ySize/2,zSize/2,TOP_RIGHT_FRONT,level+1,maxLevel);
top_left_back_node=new OctreeNode(x,y+ySize/2,z+zSize/2,xSize/2,ySize/2,zSize/2,TOP_LEFT_BACK,level+1,maxLevel);
top_right_back_node=new OctreeNode(x+xSize/2,y+ySize/2,z+zSize/2,xSize/2,ySize/2,zSize/2,TOP_RIGHT_BACK,level+1,maxLevel);
//递归构造
bottom_left_front_node->BuildTree(level+1);
bottom_right_front_node->BuildTree(level+1);
bottom_left_back_node->BuildTree(level+1);
bottom_right_back_node->BuildTree(level+1);
top_left_front_node->BuildTree(level+1);
top_right_front_node->BuildTree(level+1);
top_left_back_node->BuildTree(level+1);
top_right_back_node->BuildTree(level+1);
}

template <class T>
void OctreeNode<T>::InsertObject(T *object)
{
if(level==maxLevel)
{
objectList.push_back(object);
return;
}
//递归地插入，直到叶子节点
//1
if(bottom_left_front_node&&IsContain(x,y,z,xSize/2,ySize/2,zSize/2,object))
{
bottom_left_front_node->InsertObject(object);
return;
}
//2
if(bottom_right_front_node&&IsContain(x+xSize/2,y,z,xSize/2,ySize/2,zSize/2,object))
{
bottom_right_front_node->InsertObject(object);
return;
}
//3
if(bottom_left_back_node&&IsContain(x,y+ySize/2,z,xSize/2,ySize/2,zSize/2,object))
{
bottom_left_back_node->InsertObject(object);
return;
}
//4
if(bottom_right_back_node&&IsContain(x+xSize/2,y+ySize/2,z,xSize/2,ySize/2,zSize/2,object))
{
bottom_right_back_node->InsertObject(object);
return;
}
//5
if(top_left_front_node&&IsContain(x,y,z+zSize/2,xSize/2,ySize/2,zSize/2,object))
{
top_left_front_node->InsertObject(object);
return;
}
//6
if(top_right_front_node&&IsContain(x+xSize/2,y,z+zSize/2,xSize/2,ySize/2,zSize/2,object))
{
top_right_front_node->InsertObject(object);
return;
}
//7
if(top_left_back_node&&IsContain(x,y+ySize/2,z+zSize/2,xSize/2,ySize/2,zSize/2,object))
{
top_left_back_node->InsertObject(object);
return;
}
//8
if(top_right_back_node&&IsContain(x+xSize/2,y+ySize/2,z+zSize/2,xSize/2,ySize/2,zSize/2,object))
{
top_right_back_node->InsertObject(object);
return;
}
}

template <class T>
std::list<T *> OctreeNode<T>::GetObjectsAt(float px,float py,float pz,float x_size,float y_size,float z_size)
{
if(level==maxLevel)
return objectList;
std::list<T *> resObjects;
//递归地判断选定区域是否与某个节点相交（包含或被包含都算）
//1
if(bottom_left_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_left_front_node))
{
std::list<T *> childObjects1=bottom_left_front_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
resObjects.insert(resObjects.end(),childObjects1.begin(),childObjects1.end());
}
//2
if(bottom_right_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_right_front_node))
{
std::list<T *> childObjects2=bottom_right_front_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
resObjects.insert(resObjects.end(),childObjects2.begin(),childObjects2.end());
}
//3
if(bottom_left_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_left_back_node))
{
std::list<T *> childObjects3=bottom_left_back_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
resObjects.insert(resObjects.end(),childObjects3.begin(),childObjects3.end());
}
//4
if(bottom_right_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_right_back_node))
{
std::list<T *> childObjects4=bottom_right_back_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
resObjects.insert(resObjects.end(),childObjects4.begin(),childObjects4.end());
}
//5
if(top_left_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_left_front_node))
{
std::list<T *> childObjects5=top_left_front_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
resObjects.insert(resObjects.end(),childObjects5.begin(),childObjects5.end());
}
//6
if(top_right_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_right_front_node))
{
std::list<T *> childObjects6=top_right_front_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
resObjects.insert(resObjects.end(),childObjects6.begin(),childObjects6.end());
}
//7
if(top_left_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_left_back_node))
{
std::list<T *> childObjects7=top_left_back_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
resObjects.insert(resObjects.end(),childObjects7.begin(),childObjects7.end());
}
//8
if(top_right_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_right_back_node))
{
std::list<T *> childObjects8=top_right_back_node->GetObjectsAt(px,py,pz,x_size,y_size,z_size);
resObjects.insert(resObjects.end(),childObjects8.begin(),childObjects8.end());
}

return resObjects;
}

template <class T>
void OctreeNode<T>::RemoveObjectsAt(float px,float py,float pz,float x_size,float y_size,float z_size)
{
if(level==maxLevel)
{
if(IsContain(px,py,pz,x_size,y_size,z_size,this))
objectList.clear(); //到了叶子节点且完全被包含就把该节点存储的对象清空
return;
}
//递归地判断选定区域是否与某个节点相交（包含或被包含都算）,没有相交就不用再递归了
//1
if(bottom_left_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_left_front_node))
bottom_left_front_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
//2
if(bottom_right_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_right_front_node))
bottom_right_front_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
//3
if(bottom_left_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_left_back_node))
bottom_left_back_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
//4
if(bottom_right_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,bottom_right_back_node))
bottom_right_back_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
//5
if(top_left_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_left_front_node))
top_left_front_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
//6
if(top_right_front_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_right_front_node))
top_right_front_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
//7
if(top_left_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_left_back_node))
top_left_back_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
//8
if(top_right_back_node&&IsInterSect(px,py,pz,x_size,y_size,z_size,top_right_back_node))
top_right_back_node->RemoveObjectsAt(px,py,pz,x_size,y_size,z_size);
}

main.cpp

#include <iostream>
#include "object.h"
#include "octree_node.h"
#include "octree_node.cpp" //模板分开写要包含h和cpp
using namespace std;
int main()
{
OctreeNode<Object> *octree=new OctreeNode<Object>(0,0,0,200,200,200,ROOT,1,3);
octree->BuildTree(1);

octree->InsertObject(new Object(10,10,10,30,30,30));
octree->InsertObject(new Object(11,11,11,32,32,32));
octree->InsertObject(new Object(110,60,60,30,30,30));
octree->InsertObject(new Object(110,110,110,30,30,30));

octree->RemoveObjectsAt(0,0,0,110,70,70);
list<Object *> resObjects=octree->GetObjectsAt(0,0,0,130,130,130);
cout<<resObjects.size()<<endl;
for(auto &t:resObjects)
cout<<t->x<<' '<<t->y<<' '<<t->z<<' '<<t->xSize<<' '<<t->ySize<<' '<<t->zSize<<endl;

delete octree;
system("pause");
return 0;
}