场景管理：BSP算法C++实现（https://download.csdn.net/download/wondeful18/3549437）

最新推荐文章于 2021-03-13 15:49:51 发布
最新推荐文章于 2021-03-13 15:49:51 发布
阅读量1k 收藏
点赞数

转载：https://blog.csdn.net/u012234115/article/details/47156463

简单的实现了下BSP树

代码结构：

 

face.hpp 被管理的模型面片类
bsp_tree.hpp BSP树类
main.cpp程序入口
 

face.hpp

#pragma once
/*
//被管理的对象类
*/

//点结构
template <typename T>
struct Point
{
    T x;
    T y;
    T z;
    Point(){} //要声明这个空构造函数，否则下面的类编译出错
    Point(T _x,T _y,T _z):x(_x),y(_y),z(_z){}
    Point(const Point<T> &point)
    {
        x=point.x;
        y=point.y;
        z=point.z;
    }
    Point &operator+=(const T &n)
    {
        x+=n;
        y+=n;
        z+=n;
        return *this;
    }
};

//面结构，带三个顶点
template <typename T>
struct Face
{
    Point<T> point[3];
    void operator+=(const T &offset)
    {
        for(int i=0;i<3;++i)
            point[i]+=offset;
    }
};

bsp_tree.hpp

#pragma once
/*
//BSP树
//按照AABB包围盒分隔，按照最长边切分轴，然后把场景面片递归地划分到两个子节点，一开始就划分完毕，主要是作为静态场景管理
*/
#include <vector>
#include "face.hpp"

enum Axis
{
    AXIS_X,
    AXIS_Y,
    AXIS_Z
};


template <typename T>
struct BspTreeNode
{
    std::vector<Face<T>> faces;
    Axis axis;
    int depth;
    T splitter; //某个方向的分隔值
    Point<T> minPoint; //节点的包围盒顶点
    Point<T> maxPoint;
    BspTreeNode *lChild;
    BspTreeNode *rChild;
    BspTreeNode():lChild(nullptr),rChild(nullptr){}
};


template <typename T>
class BspTree
{
public:
    BspTree();
    ~BspTree();
public:
    //构造树根以及整体AABB包围盒，由min和max两个点来设置
    void InitBspTree(std::vector<Face<T>> &_faces,Point<T> min_point,Point<T> max_point,int max_depth);
    void DeleteBspTree();
    void TraverseBspTree() const;
private:
    void cutFace(const Face<T> &face,Axis axis,const T &splitter,int &leftCount,int &rightCount,int &bothCount);
    void splitSpace(BspTreeNode<T> *node,Axis axis,int depth);
    void traverse(BspTreeNode<T> *node) const;
    void deleteTree(BspTreeNode<T> *root);
private:
    BspTreeNode<T> *root; //根节点
    int maxDepth; //最大递归深度，防止堆栈溢出

};

template <typename T>
BspTree<T>::BspTree()
{

}

template <typename T>
BspTree<T>::~BspTree()
{
}

template <typename T>
void BspTree<T>::InitBspTree(std::vector<Face<T>> &_faces,Point<T> min_point,Point<T> max_point,int max_depth)
{
    maxDepth=max_depth;
    root=new BspTreeNode<T>;
    root->depth=1;
    root->faces=_faces;
    root->lChild=nullptr;
    root->rChild=nullptr;

    root->maxPoint=max_point;
    root->minPoint=min_point;

    //初始化后就开始分割所有场景
    splitSpace(root,AXIS_X,1);
}

template <typename T>
void BspTree<T>::deleteTree(BspTreeNode<T> *root)
{
    if(root)
    {
        deleteTree(root->lChild);
        deleteTree(root->rChild);
        delete root;
        root=nullptr;
    }
}

template <typename T>
void BspTree<T>::DeleteBspTree()
{
    deleteTree(root);
}

template <typename T>
void BspTree<T>::cutFace(const Face<T> &face,Axis axis,const T &splitter,int &leftCount,int &rightCount,int &bothCount)
{
    T p[3]; //记录某个方向的点分量
    switch(axis)
    {
    case AXIS_X:
        p[0]=face.point[0].x;
        p[1]=face.point[1].x;
        p[2]=face.point[2].x;
        break;
    case AXIS_Y:
        p[0]=face.point[0].y;
        p[1]=face.point[1].y;
        p[2]=face.point[2].y;
        break;
    case AXIS_Z:
        p[0]=face.point[0].z;
        p[1]=face.point[1].z;
        p[2]=face.point[2].z;
        break;
    }
    //对分隔到两边的顶点计数
    for(int i=0;i<3;++i)
    {
        if(p[i]<splitter)
            leftCount++;
        else if(p[i]>splitter)
            rightCount++;
        else if(fabs(p[i]-splitter)<1e-6)
            bothCount++;
    }
}

template <typename T>
void BspTree<T>::splitSpace(BspTreeNode<T> *node,Axis axis,int depth)
{
    //在当前层节点做分割处理，为下层子节点数据做填充

    if(!node) 
        return;
    node->axis=axis;
    node->depth=depth;
    if(depth==maxDepth)
        return;
    if(node->faces.size()<2) //上层节点拥有的面片数太少就不再划分
        return;

    node->lChild=new BspTreeNode<T>;
    node->rChild=new BspTreeNode<T>;
    //先给子节点包围盒赋值
    node->lChild->maxPoint=node->maxPoint;
    node->lChild->minPoint=node->minPoint;
    node->rChild->maxPoint=node->maxPoint;
    node->rChild->minPoint=node->minPoint;

    T xLen=node->maxPoint.x-node->minPoint.x;
    T yLen=node->maxPoint.y-node->minPoint.y;
    T zLen=node->maxPoint.z-node->minPoint.z;
    //设置该节点的划分点
    Axis mAxis=AXIS_X;
    if(yLen>xLen&&yLen>zLen)
        mAxis=AXIS_Y;
    if(zLen>xLen&&zLen>yLen)
        mAxis=AXIS_Z;
    switch(mAxis)
    {
    case AXIS_X:
        node->splitter=(node->maxPoint.x+node->minPoint.x)/2; //取中间值
        //修改子节点的包围盒值
        node->lChild->maxPoint.x=node->splitter;
        node->rChild->minPoint.x=node->splitter;
        break;
    case AXIS_Y:
        node->splitter=(node->maxPoint.y+node->minPoint.y)/2;
        node->lChild->maxPoint.y=node->splitter;
        node->rChild->minPoint.y=node->splitter;
        break;
    case AXIS_Z:
        node->splitter=(node->maxPoint.z+node->minPoint.z)/2;
        node->lChild->maxPoint.z=node->splitter;
        node->rChild->minPoint.z=node->splitter;
        break;
    }

    
    for(int i=0;i<node->faces.size();++i)
    {
            // 重置计数
            int leftCount=0;
        int rightCount=0;
        int bothCount=0;

        //对每个面做切分到子节点
        cutFace(node->faces[i],mAxis,node->splitter,leftCount,rightCount,bothCount);
        if(leftCount||bothCount)
        node->lChild->faces.push_back(node->faces[i]);
        if(rightCount||bothCount)
        node->rChild->faces.push_back(node->faces[i]);
    }

    //关键的一步，分割完了之后，把当前层节点的面片清空
    node->faces.clear(); 

    //递归
    splitSpace(node->lChild,mAxis,depth+1);
    splitSpace(node->rChild,mAxis,depth+1);
    
}

template <typename T>
void BspTree<T>::traverse(BspTreeNode<T> *node) const
{
    if(!node)
        return;
    traverse(node->lChild);
    //中序遍历
    std::cout<<"节点深度 "<<node->depth<<" 面片数 "<<node->faces.size()<<std::endl;
    switch(node->axis)
    {
    case AXIS_X:
        std::cout<<"沿X轴分割 "<<"分割点x "<<node->splitter<<std::endl;
        break;
    case AXIS_Y:
        std::cout<<"沿Y轴分割 "<<"分割点y "<<node->splitter<<std::endl;
        break;
    case AXIS_Z:
        std::cout<<"沿Z轴分割 "<<"分割点z "<<node->splitter<<std::endl;
        break;
    }
    traverse(node->rChild);
}

template <typename T>
void BspTree<T>::TraverseBspTree() const
{
    //封装一层再遍历
    traverse(root);
}

main.cpp

#include <iostream>
#include <vector>
#include <time.h>
#include "bsp_tree.hpp"
using namespace std;

int main()
{
    BspTree<float> bspTree;

    //创造一些面片
    vector<Face<float>> face_vec;
    srand(time(0));
    for(int i=0;i<16;++i)
    {
        Face<float> face;
        for(int j=0;j<3;++j)
            face.point[j]=Point<float>(-200+rand()%400,-200+rand()%400,-200+rand()%400);
        face_vec.push_back(face);
    }    
    //初始化bsp树并遍历
    bspTree.InitBspTree(face_vec,Point<float>(-200,-200,-200),Point<float>(200,200,200),5);
    bspTree.TraverseBspTree();
    bspTree.DeleteBspTree();

    system("pause");
    return 0;
}
--------------------- 
作者：踏莎行hyx 
来源：CSDN 
原文：https://blog.csdn.net/u012234115/article/details/47156463 
版权声明：本文为博主原创文章，转载请附上博文链接！

寒月望山
关注
minijson使用_故事书-Godot中的JSON用法
weixin_39524741的博客
12-19 700
JSON(JavaScript对象表示法)是一种轻量级的数据可互换格式。读写很简单。机器很容易解析和生成。它基于JavaScript编程语言(标准ECMA-262第3版, 1999年12月)的子集。JSON是一种完全独立于语言的文本格式, 但是它使用C语言家族的程序员所熟悉的约定, 并且还包括C, C ++, C＃, Java, JavaScript, Perl, Python等。这些属性使JSO...
DirectX 框架（二）-- bsp场景管理
sd008009的专栏
03-16 2343
翻来覆去的考虑最终还是选用了bsp碰撞检测，由于之前对bsp不太了解，所以研究起来特别吃力，可是结果是可喜的！说“bsp格式的地图”不太准确，应该说是“bsp方式的场景管理”。之所以这样讲是因为一个bsp文件不仅承载了场景顶点位置、纹理坐标等信息，它还可以存储场景各个部分的可视信息、lightmap等数据。一旦你成功载入了bsp文件，你可以继续读取里面的信息来优化你的程序：1、可以利用里面可视
3D场景的BSP分割算法
06-20
此篇论文描述了前一些年的3D游戏中广泛使用的BSP场景组织结构的算法，全篇英文，不过却是深入简出，对于想了解和研究BSP场景组织算法的朋友是份非常好的资料
场景管理：BSP算法C++实现
踏莎行的博客
07-30 3293
简单的实现了下BSP树 代码结构：   face.hpp 被管理的模型面片类 bsp_tree.hpp BSP树类 main.cpp程序入口   face.hpp #pragma once /* //被管理的对象类 */ //点结构 template &lt;typename T&gt; struct Point { T x; T y; T z; Point(){} //...
3D引擎场景管理
我的学习空间
09-03 2271
 我认为对于一个3D引擎来说，最核心的部分应该算是场景组织（scene graph）了，如果这部分你都没有设计好， 那么就别指望开发一个成熟的3D引擎了。为了开发3d引擎，所以我首先就研究这方面的内容，对一个3D的场景来说，又很多的物体，最简单的组织方法就是把他们用一个List连接起来，然后在绘制没一帧的时候依次送入渲染器（render）进行处理。　　这显然不是一个很有效的方法，当处理
[3D游戏开发]场景管理
weixin_30516243的博客
09-06 195
一、场景管理有很多种方法，如四叉树、八叉树、BSP、模糊K-D树、包围球层次结构等。室内环境主要是BSP为主，从quake3一直延续到现在主流的引擎都是以BSP为基础，BSP使用并不难，关键是数据的生成，这就牵涉到场景编辑器。 Quake3、Unreal：BSP,有自己的编辑器。 FarCry：场景分为室内和室外两部分，室内场景使用BSP, 室外不清楚但应该跟地形有很大关...
基于BSP的场景管理
weixin_30765577的博客
05-09 217
经过几天的努力，完成了一个基于BSP的室内场景管理，包括BSP编译、渲染、碰撞检测，地图文件是从一个网站下载的BSP演示程序中拿来的，该网站的地址：http://home.planet.nl/~monstrous/mons.html ，不过现在不能访问了。 这里是我的BSP演示程序，点此下载(包括源码) ，该程序仅使用了视截体进行剔除，如果采用基于入口的剔除，性能无疑会大大提高。 转载...
八年级英语上册综合能力测试题3.pdf
10-21
2. 第二题"w_______ time"，答案为"wondeful"，表达对美好时光的期待。 3. "m_______"则需填入"more"，提示不要多说话，会议即将开始。 4. "by h_______"应该填写"himself"，表示不能把女儿单独留下。 5. "c_______ ...
BSP场景管理方法简介
weixin_34049032的博客
01-28 284
BSP（Binary Space Partition,二叉空间分割）方法，在大型3d游戏场景管理方面，可以认为是已经证明了的，最成熟的，最经得起考验的场景管理方法。诸如虚幻系列引擎（Unreal 1,2,3），ID系列以及衍生产品（Quake,DOOM,Half-Life2），都采用了BSP方法来管理场景，尽管他们各自在实现上略有不同，但是基本原理都是相同的，下面将...
Ogre bsp场景管理笔记
weixin_30716725的博客
04-26 128
1.用到的知识点 　　如何判断点在平面哪一边？ 以及判断aabb盒子在面的哪一边？ 　　 Real Plane::getDistance (const Vector3& rkPoint) const { return normal.dotProduct(rkPoint) + d; } //-----------------------...
3D游戏中的场景管理(八叉树和BSP树简介).doc
03-29
好东西，[转]3D游戏中的场景管理(八叉树和BSP树简介).doc
BSP概念分析和讲解
09-25
BSP概念分析 讲述BSP的概念，让读者通俗易懂
BSP(二叉空间划分树).pdf
08-15
非常详细的BSP树生成过程的图形描述.
Bsp分割算法简述
weixin_34281477的博客
07-08 216
来源：中国IT实验室收集整理　作者：CC   BSP分割算法也是有不少文章可以借鉴的，就我目前能掌握的资料来看，泛泛而谈者大有人在，实际去作的时候却总是抓瞎。知道是什么永远不如知道怎么做，BSP分割是BSP分析的基础，虽然它很简单，但是，如果连简单的都不会做，又怎么能胜任复杂的工作呢？    趁这段时间有空，遂埋头钻研BSP，一周之后，分割和自动Portal生成均已解决，遂做此文，希望能对初学...
BSP分割算法简述（原创、PDF、链接）
noslopforever ［天堂里的死神］
12-26 5034
 本文不能保证所贴空间的稳定性，有可能一段时间之后会发生所链接PDF已经失效，遇到这种情况，我将尽快寻找可以使用的新的空间。其中对大家造成的不便，请大家原谅。PDF有时候可能会让您的IE变得很慢，所以，请下载到硬盘上进行阅读。原创文章，著作权属本人所有，本人也对一切言行负有责任，望大家能尊重劳动者的辛勤努力，不要侵犯我们这些底层劳动人民的知识产权。谢谢大家。 http://dev.
场景管理
深入思考
02-06 1435
场景管理是3D引擎的一个核心部分，因为它是引擎的用户每天都要用到的一个特性。通常的做法是通过场景图（可能这样称呼不太准确）来实现，场景图就是一个数据结构，有：层次结构（火炬在英雄的手中），空间结构（一个兽人在英雄的旁边）以及状态结构（火炬当中的火是alpha混合的）。 　　这样一个结构的问题是，它试图成为一个万事通，但是最后在任何一方面都没有优势。互联网上已经有过许多对此的讨论，一般的共识是这样
场景管理：四叉树算法C++实现
踏莎行的博客
07-30 8061
简单实现了游戏中场景管理用到的四叉树算法 代码结构： object.h，object.cpp被管理的对象类quad_tree_node.h，quad_tree_node.cpp四叉树类main.cpp程序入口 object.h /* //被管理的对象类 */ #pragma once class Object { public: Object(float _x,float
BSP二叉树算法
daojin505的专栏
04-25 530
  概念解释：   结构化面： 参与分割的多变形。多边形对应的平面列表为其 分割面列表。   备选平面：在这里就是结构化面。   细节面：不参与分割的平面。     首先，自然是要先产生一个根节点，并把所有的顶点表、结构化三角形表和平面表一股脑塞进这个根节点中咯。 然后，分割的流程大抵如下：1 遍历当前节点的所有备选平面，寻找一个合适的分割平面。       满足一定条件...
BSP Tree算法简述
packdge_black的博客
03-13 5876
本文会简述BSP树的应用和其算法原理。 正文：
3D游戏中的场景管理（八叉树和BSP树简介）
maosong00的专栏
09-04 1799
如何很好地表示出包含着成千上万物体的复杂场景，是设计系统必须要考虑的。这也是场景管理需要做得，给场景提供良好的层次关系，以便更好地进行筛选 (Culling)和隐藏面消除(Hidden surface removal)。 场景管理涉及到可视性处理(Visibility processing)和碰撞检测(Collision detection)，系统需要判断场景的哪些部分在视见约束体之
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值