Box2d源码学习<七>Broad-phase的实现

本系列博客是由扭曲45原创,欢迎转载,转载时注明出处,http://blog.csdn.net/cg0206/article/details/8300658

在一个物理步长内,碰撞处理可以被划分成narrow-phase和broad-phase两个阶段。在narrow-phase阶段计算一对形状的接触。假设有N个形状,直接使用蛮力进行计算,我们需要调用N*N/2次narrow-phase算法。

 

b2BroadPhase类通过使用动态树降低了管理数据方面的开销。这极大的降低了调用narrow-phase算法的次数。

 

一般情况下,你不需要直接和broad-phase打交道。Box2D来内部来创建和管理broad-phase。另外,b2BroadPhase是使用Box2D的模拟循环的思路来设计的,所以它可能不适合用于其他用途。

                                                                                           ---摘自oh!coder的博客

Box2d中broad-phase用于计算pairs【相交记录】,执行容量查询和光线投射。主要还是调用上一节我们说的动态树进行数据方面的管理。首先,我们还是看看头文件b2BroadPhase.h中的定义部分。

[cpp]  view plain copy
  1. //pair定义  
  2. struct b2Pair  
  3. {  
  4.     int32 proxyIdA;  //代理a  
  5.     int32 proxyIdB;  //代理b  
  6.     int32 next;      //下一个pair  
  7. };  
  8.   
  9. // broad-phase用于计算pairs,执行体积查询和光线投射  
  10. // broad-phase不会持续pairs.相反,它会汇报新的pairs。这取决于客户端是否用掉新的pairs和是否跟踪后续重叠。  
  11. class b2BroadPhase  
  12. {  
  13. public:  
  14.     //空节点代理  
  15.     enum  
  16.     {  
  17.         e_nullProxy = -1  
  18.     };  
  19.   
  20.     b2BroadPhase();  
  21.     ~b2BroadPhase();  
  22.     /************************************************************************** 
  23.     * 功能描述:创建一个代理,并用aabb初始化。pairs不会汇报直到UpdatePairs被调用 
  24.     * 参数说明: allocator :soa分配器对象指针 
  25.                  userData  :用户数据 
  26.     * 返 回 值: (void) 
  27.     ***************************************************************************/  
  28.     int32 CreateProxy(const b2AABB& aabb, void* userData);  
  29.     /************************************************************************** 
  30.     * 功能描述:销毁一个代理,任何pairs的删除都取决于客户端 
  31.     * 参数说明: proxyId :代理id 
  32.     * 返 回 值: (void) 
  33.     ***************************************************************************/  
  34.     void DestroyProxy(int32 proxyId);  
  35.   
  36.     /************************************************************************** 
  37.     * 功能描述:移动一个代理。只要你喜欢可以多次调用MoveProxy, 
  38.                 当你完成后调用UpdatePairs用于完成代理pairs(在你的时间步内) 
  39.     * 参数说明: proxyId      :代理id 
  40.                  aabb         :aabb变量 
  41.                  displacement :移动坐标向量 
  42.     * 返 回 值: (void) 
  43.     ***************************************************************************/  
  44.     void MoveProxy(int32 proxyId, const b2AABB& aabb, const b2Vec2& displacement);  
  45.   
  46.     /************************************************************************** 
  47.     * 功能描述: 在下次调用UpdatePairs时,调用一个触发器触发它的pairs 
  48.     * 参数说明: proxyId      :代理id 
  49.     * 返 回 值: (void) 
  50.     ***************************************************************************/  
  51.     void TouchProxy(int32 proxyId);  
  52.     /************************************************************************** 
  53.     * 功能描述: 获取宽大的aabb 
  54.     * 参数说明: proxyId      :代理id 
  55.     * 返 回 值: (void) 
  56.     ***************************************************************************/  
  57.     const b2AABB& GetFatAABB(int32 proxyId) const;  
  58.     /************************************************************************** 
  59.     * 功能描述: 通过一个代理获取userData,如果id无效,返回NULL 
  60.     * 参数说明: proxyId      :代理id 
  61.     * 返 回 值: 用户数据 
  62.     ***************************************************************************/  
  63.     void* GetUserData(int32 proxyId) const;  
  64.     /************************************************************************** 
  65.     * 功能描述: 测试宽大aabb的重复部分 
  66.     * 参数说明: proxyIdA    :A代理id 
  67.                  proxyIdB    :B代理id 
  68.     * 返 回 值: true :不重叠 
  69.                  false:重  叠 
  70.     ***************************************************************************/  
  71.     bool TestOverlap(int32 proxyIdA, int32 proxyIdB) const;  
  72.     /************************************************************************** 
  73.     * 功能描述: 获取代理数量 
  74.     * 参数说明: (void) 
  75.     * 返 回 值: 代理数量 
  76.     ***************************************************************************/  
  77.     int32 GetProxyCount() const;  
  78.     /************************************************************************** 
  79.     * 功能描述: 更新pairs.这会对pair进行回调。只能添加pairs 
  80.     * 参数说明: callback :回调对象 
  81.     * 返 回 值: (void) 
  82.     ***************************************************************************/  
  83.     template <typename T>  
  84.     void UpdatePairs(T* callback);  
  85.     /************************************************************************** 
  86.     * 功能描述: 在重叠代理中查询一个aabb.每个提供aabb重叠的代理将会被回调类调用 
  87.     * 参数说明: callback :回调对象类 
  88.                  aabb     :aabb变量 
  89.     * 返 回 值: (void) 
  90.     ***************************************************************************/  
  91.     template <typename T>  
  92.     void Query(T* callback, const b2AABB& aabb) const;  
  93.     /************************************************************************** 
  94.     * 功能描述: 光线投射在树上的代理。 
  95.                  这依赖于回调被执行一个精确的光线投射在一个代理包含一个形状 
  96.     * 参数说明: callback : 一个回调对象类,当被调用时,光线将会撒到每个代理中。 
  97.                  input    :光线投射输入数据。这个光线从p1扩展到p1+maxFraction *(p2 - p1) 
  98.     * 返 回 值: (void) 
  99.     ***************************************************************************/  
  100.     template <typename T>  
  101.     void RayCast(T* callback, const b2RayCastInput& input) const;  
  102.     /************************************************************************** 
  103.     * 功能描述: 获取嵌入树的高度 
  104.     * 参数说明: (void) 
  105.     * 返 回 值: (void) 
  106.     ***************************************************************************/  
  107.     int32 GetTreeHeight() const;  
  108.     /************************************************************************** 
  109.     * 功能描述: 获取嵌入树的平衡值 
  110.     * 参数说明: (void) 
  111.     * 返 回 值: (void) 
  112.     ***************************************************************************/  
  113.     int32 GetTreeBalance() const;  
  114.     /************************************************************************** 
  115.     * 功能描述: 获取嵌入树的质量,即是树的总aabbs周长与根节点aabb周长的比 
  116.     * 参数说明: (void) 
  117.     * 返 回 值: 树的质量 
  118.     ***************************************************************************/  
  119.     float32 GetTreeQuality() const;  
  120.   
  121. private:  
  122.     //友元类  
  123.     friend class b2DynamicTree;  
  124.     /************************************************************************** 
  125.     * 功能描述: 根据代理id添加代理到移动缓冲区中 
  126.     * 参数说明: proxyId :代理id 
  127.     * 返 回 值: (void) 
  128.     ***************************************************************************/  
  129.     void BufferMove(int32 proxyId);  
  130.     /************************************************************************** 
  131.     * 功能描述: 将代理移出移动缓存区 
  132.     * 参数说明: proxyId :代理id 
  133.     * 返 回 值: (void) 
  134.     ***************************************************************************/  
  135.     void UnBufferMove(int32 proxyId);  
  136.     /************************************************************************** 
  137.     * 功能描述: 查询回调函数 
  138.     * 参数说明: proxyId :代理id 
  139.     * 返 回 值: true :表示正常回调 
  140.     ***************************************************************************/  
  141.     bool QueryCallback(int32 proxyId);  
  142.     //动态树声明  
  143.     b2DynamicTree m_tree;  
  144.     //代理数量  
  145.     int32 m_proxyCount;  
  146.     //移动的缓冲区  
  147.     int32* m_moveBuffer;  
  148.     //移动缓冲区的总容量  
  149.     int32 m_moveCapacity;  
  150.     //需要移动的代理数量  
  151.     int32 m_moveCount;  
  152.     //pair缓冲区  
  153.     b2Pair* m_pairBuffer;  
  154.     //pair缓冲区中的总容量  
  155.     int32 m_pairCapacity;  
  156.     //pair数量  
  157.     int32 m_pairCount;  
  158.     //查询代理id  
  159.     int32 m_queryProxyId;  
  160. };  

在这类中,可以看到b2BroadPhase将b2DynamicTree定义为友元类,也就是说b2DynamicTree每一个对象均可访问b2BroadPhase的任何成员,不管是否是私有的。同时我们又可以看到在b2BrodPhase类中,我们定义了个动态树对象m_tree,这样我们形成的好像是形成了一个环,但m_tree并不能访问b2DynamicTree中的私有变量。其他部分,不多说了,看注释。再来看内联函数的实现。

[cpp]  view plain copy
  1. /************************************************************************** 
  2. * 功能描述: 用于pairs的排序 
  3. * 参数说明: pair1:Pari对象引用 
  4.              pair2: Pari对象引用 
  5. * 返 回 值: true : pair1较小 
  6.              fasle:pair2较小 
  7. ***************************************************************************/  
  8. inline bool b2PairLessThan(const b2Pair& pair1, const b2Pair& pair2)  
  9. {  
  10.     //比对pair的代理idA  
  11.     if (pair1.proxyIdA < pair2.proxyIdA)  
  12.     {  
  13.         return true;  
  14.     }  
  15.     //再比对代理idB  
  16.     if (pair1.proxyIdA == pair2.proxyIdA)  
  17.     {  
  18.         return pair1.proxyIdB < pair2.proxyIdB;  
  19.     }  
  20.   
  21.     return false;  
  22. }  
  23.   
  24.   
  25. //根据代理id获取userData  
  26. inline void* b2BroadPhase::GetUserData(int32 proxyId) const  
  27. {  
  28.     return m_tree.GetUserData(proxyId);  
  29. }  
  30. //测试重叠  
  31. inline bool b2BroadPhase::TestOverlap(int32 proxyIdA, int32 proxyIdB) const  
  32. {  
  33.     const b2AABB& aabbA = m_tree.GetFatAABB(proxyIdA);  
  34.     const b2AABB& aabbB = m_tree.GetFatAABB(proxyIdB);  
  35.     return b2TestOverlap(aabbA, aabbB);  
  36. }  
  37. //获取aabb  
  38. inline const b2AABB& b2BroadPhase::GetFatAABB(int32 proxyId) const  
  39. {  
  40.     return m_tree.GetFatAABB(proxyId);  
  41. }  
  42. //获取代理数量  
  43. inline int32 b2BroadPhase::GetProxyCount() const  
  44. {  
  45.     return m_proxyCount;  
  46. }  
  47. //获取树的高度  
  48. inline int32 b2BroadPhase::GetTreeHeight() const  
  49. {  
  50.     return m_tree.GetHeight();  
  51. }  
  52. //获取树的平衡值  
  53. inline int32 b2BroadPhase::GetTreeBalance() const  
  54. {  
  55.     return m_tree.GetMaxBalance();  
  56. }  
  57. //获取树的质量  
  58. inline float32 b2BroadPhase::GetTreeQuality() const  
  59. {  
  60.     return m_tree.GetAreaRatio();  
  61. }  
  62. //更新pairs  
  63. template <typename T>  
  64. void b2BroadPhase::UpdatePairs(T* callback)  
  65. {  
  66.     //重置pair缓存区  
  67.     m_pairCount = 0;  
  68.     //执行查询树上所有需要移动代理  
  69.     for (int32 i = 0; i < m_moveCount; ++i)  
  70.     {  
  71.         m_queryProxyId = m_moveBuffer[i];  
  72.         if (m_queryProxyId == e_nullProxy)  
  73.         {  
  74.             continue;  
  75.         }  
  76.         // 我们需要查询树的宽大的AABB,以便当我们创建pair失败时,可以再次创建  
  77.         const b2AABB& fatAABB = m_tree.GetFatAABB(m_queryProxyId);  
  78.         // 查询树,创建多个pair并将他们添加到pair缓冲区中  
  79.         m_tree.Query(this, fatAABB);  
  80.     }  
  81.     //重置移动缓冲区  
  82.     m_moveCount = 0;  
  83.     // 排序pair缓冲区  
  84.     std::sort(m_pairBuffer, m_pairBuffer + m_pairCount, b2PairLessThan);  
  85.     // 发送pair到客户端  
  86.     int32 i = 0;  
  87.     while (i < m_pairCount)  
  88.     {  
  89.         //在pair缓冲区中获取当前的pair  
  90.         b2Pair* primaryPair = m_pairBuffer + i;  
  91.         //根据相交记录  
  92.         void* userDataA = m_tree.GetUserData(primaryPair->proxyIdA);  
  93.         void* userDataB = m_tree.GetUserData(primaryPair->proxyIdB);  
  94.   
  95.         callback->AddPair(userDataA, userDataB);  
  96.         ++i;  
  97.   
  98.         //跳过重复的pair  
  99.         while (i < m_pairCount)  
  100.         {  
  101.             b2Pair* pair = m_pairBuffer + i;  
  102.             if (pair->proxyIdA != primaryPair->proxyIdA || pair->proxyIdB != primaryPair->proxyIdB)  
  103.             {  
  104.                 break;  
  105.             }  
  106.             ++i;  
  107.         }  
  108.     }  
  109.   
  110.     // Try to keep the tree balanced.  
  111.     //m_tree.Rebalance(4);  
  112. }  
  113. //区域查询  
  114. template <typename T>  
  115. inline void b2BroadPhase::Query(T* callback, const b2AABB& aabb) const  
  116. {  
  117.     m_tree.Query(callback, aabb);  
  118. }  
  119. //光线投射  
  120. template <typename T>  
  121. inline void b2BroadPhase::RayCast(T* callback, const b2RayCastInput& input) const  
  122. {  
  123.     m_tree.RayCast(callback, input);  
  124. }  

关于这部分,就是对动态树中相关方法的封装,如果还有童鞋有疑问的话,不妨看看我的上一篇文章《Box2d源码学习<>动态树的实现》,接下来来看看b2BroadPhase部分。

[cpp]  view plain copy
  1. //构造函数,初始化数据  
  2. b2BroadPhase::b2BroadPhase()  
  3. {  
  4.     m_proxyCount = 0;  
  5.   
  6.     m_pairCapacity = 16;  
  7.     m_pairCount = 0;  
  8.     m_pairBuffer = (b2Pair*)b2Alloc(m_pairCapacity * sizeof(b2Pair));  
  9.   
  10.     m_moveCapacity = 16;  
  11.     m_moveCount = 0;  
  12.     m_moveBuffer = (int32*)b2Alloc(m_moveCapacity * sizeof(int32));  
  13. }  
  14. //析构函数  
  15. b2BroadPhase::~b2BroadPhase()  
  16. {  
  17.     b2Free(m_moveBuffer);  
  18.     b2Free(m_pairBuffer);  
  19. }  
  20. //创建一个代理  
  21. int32 b2BroadPhase::CreateProxy(const b2AABB& aabb, void* userData)  
  22. {  
  23.     //获取代理id  
  24.     int32 proxyId = m_tree.CreateProxy(aabb, userData);  
  25.     //代理数量自增  
  26.     ++m_proxyCount;  
  27.     //添加代理到移动缓冲区中  
  28.     BufferMove(proxyId);  
  29.     return proxyId;  
  30. }  
  31. //销毁一个代理  
  32. void b2BroadPhase::DestroyProxy(int32 proxyId)  
  33. {  
  34.     UnBufferMove(proxyId);  
  35.     --m_proxyCount;  
  36.     m_tree.DestroyProxy(proxyId);  
  37. }  
  38. //移动一个代理  
  39. void b2BroadPhase::MoveProxy(int32 proxyId, const b2AABB& aabb, const b2Vec2& displacement)  
  40. {  
  41.     bool buffer = m_tree.MoveProxy(proxyId, aabb, displacement);  
  42.     if (buffer)  
  43.     {  
  44.         BufferMove(proxyId);  
  45.     }  
  46. }  
  47. //在下次调用UpdatePairs时,调用一个触发器触发它的pairs  
  48. void b2BroadPhase::TouchProxy(int32 proxyId)  
  49. {  
  50.     BufferMove(proxyId);  
  51. }  
  52. //根据代理id添加代理到移动缓冲区中  
  53. void b2BroadPhase::BufferMove(int32 proxyId)  
  54. {  
  55.     //移动缓冲区过小,增容  
  56.     if (m_moveCount == m_moveCapacity)  
  57.     {  
  58.         //获取移动缓冲区  
  59.         int32* oldBuffer = m_moveBuffer;  
  60.         //将容量扩增为原来的2倍  
  61.         m_moveCapacity *= 2;  
  62.         //重新申请移动缓冲区  
  63.         m_moveBuffer = (int32*)b2Alloc(m_moveCapacity * sizeof(int32));  
  64.         //拷贝旧的移动缓冲区内容到新的里面去,并释放旧的移动缓冲区  
  65.         memcpy(m_moveBuffer, oldBuffer, m_moveCount * sizeof(int32));  
  66.         b2Free(oldBuffer);  
  67.     }  
  68.     //添加代理id到移动缓冲区中  
  69.     m_moveBuffer[m_moveCount] = proxyId;  
  70.     //自增  
  71.     ++m_moveCount;  
  72. }  
  73. //移除移动缓存区  
  74. void b2BroadPhase::UnBufferMove(int32 proxyId)  
  75. {  
  76.     //查找相应的代理  
  77.     for (int32 i = 0; i < m_moveCount; ++i)  
  78.     {  
  79.         //找到代理,并置空  
  80.         if (m_moveBuffer[i] == proxyId)  
  81.         {  
  82.             m_moveBuffer[i] = e_nullProxy;  
  83.             return;  
  84.         }  
  85.     }  
  86. }  
  87. //当我们聚集pairs时这个函数将会被b2DynamicTree:Query调用  
  88. bool b2BroadPhase::QueryCallback(int32 proxyId)  
  89. {  
  90.     // 一个代理不需要自己pair更新自己的pair  
  91.     if (proxyId == m_queryProxyId)  
  92.     {  
  93.         return true;  
  94.     }  
  95.     // 如果需要增加pair缓冲区  
  96.     if (m_pairCount == m_pairCapacity)  
  97.     {  
  98.         //获取旧的pair缓冲区,并增加容量  
  99.         b2Pair* oldBuffer = m_pairBuffer;  
  100.         m_pairCapacity *= 2;  
  101.         //重新申请pair缓冲区,并拷贝旧缓冲区中的内容  
  102.         m_pairBuffer = (b2Pair*)b2Alloc(m_pairCapacity * sizeof(b2Pair));  
  103.         memcpy(m_pairBuffer, oldBuffer, m_pairCount * sizeof(b2Pair));  
  104.         //释放旧的pair缓冲区  
  105.         b2Free(oldBuffer);  
  106.     }  
  107.     //设置最新的pair  
  108.     //并自增pair数量  
  109.     m_pairBuffer[m_pairCount].proxyIdA = b2Min(proxyId, m_queryProxyId);  
  110.     m_pairBuffer[m_pairCount].proxyIdB = b2Max(proxyId, m_queryProxyId);  
  111.     ++m_pairCount;  
  112.   
  113.     return true;  
  114. }  

通过源代码我们可以看到,它的实现主要靠移动缓冲区(m_moveBuffer)和pair缓冲区(m_pariBuffer)。构造函数b2BroadPhase()主要是申请这两个缓冲区,析构函数~b2BroadPhase()释放这两个缓冲区,创建一个代理函数CreateProxy()主要添加代理到移动缓冲区,销毁代理函数DestroyProxy主要是销毁一个在移动缓冲区的代理,MoveProxy()、TouchProxy()、BufferMove()均是在移动缓冲区中添加代理,UnBufferMove()是在移动缓冲区中移除代理,QueryCallback()是对pair缓冲区的操作。

突然我们心中有一个疑问,这两个缓冲区各自操作各自的,通过这段代码我们看不到任何的联系,它们到底是如何通信的呢?请先大家思考下。。。

好了,大家知道了吗?有人猜到是通过UpdatePairs函数实现的,这是正确的,但具体的还是通过动态树中的Query函数来实现的,我们不妨回顾一下updatepairs中的代码段。

[cpp]  view plain copy
  1. //执行查询树上所有需要移动代理  
  2.     for (int32 i = 0; i < m_moveCount; ++i)  
  3.     {  
  4.         m_queryProxyId = m_moveBuffer[i];  
  5.         if (m_queryProxyId == e_nullProxy)  
  6.         {  
  7.             continue;  
  8.         }  
  9.         // 我们需要查询树的宽大的AABB,以便当我们创建pair失败时,可以再次创建  
  10.         const b2AABB& fatAABB = m_tree.GetFatAABB(m_queryProxyId);  
  11.         // 查询树,创建多个pair并将他们添加到pair缓冲区中  
  12.         m_tree.Query(this, fatAABB);  
  13.     }  

有人也许会说,这段代码我们只看到移动缓冲区(m_moveBuffer),看不出来与 pair缓冲区(m_pariBuffer)有任何关系,它们怎么产生联系的呢?注意m_tree.Query(this,fatAABB)这句代码和它传递的参数,this表示当前类的对象,fatAABB表示移动缓冲区中一个代理的AABB,存储了代理的信息。我们再回顾一下query函数:

[cpp]  view plain copy
  1.        /************************************************************************** 
  2. * 功能描述:查询一个aabb重叠代理,每个重叠提供AABB的代理都将回调回调类 
  3. * 参数说明:callback :回调对象 
  4.             aabb     :要查询的aabb 
  5. * 返 回 值:aabb对象 
  6.        ***************************************************************************/  
  7. template <typename T>  
  8. void Query(T* callback, const b2AABB& aabb) const;  
再看Query函数中的代码片段

[cpp]  view plain copy
  1.     //是否成功  
  2.     bool proceed = callback->QueryCallback(nodeId);  
  3.     if (proceed == false)  
  4.     {  
  5. return;  
  6.     }  
看这句代码 bool proceed = callback->QueryCallback(nodeId);  此处的callback就是刚刚传进去的this,也就是说我们调用的QueryCallback也就是b2BroadPhase::QueryCallback(int32 proxyId)函数。到此处相信大家已经明白了。


ps:

以上文章仅是一家之言,若有不妥、错误之处,请大家多多之出。同时也希望能与大家多多交流,共同进步

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值