Box2D一：基礎知識

一、box2d基礎知識

1、關於

 Box2D 是一個用於游戲的 2D 剛體仿真庫。從游戲的視角來看，物理引擎就是一個程序性動畫(procedural animation)的系統，而不是由動畫師去移動你的物體。

1、核心概念 

剛體(rigid body)

一塊十分堅硬的物質，它上面的任何兩點之間的距離都是完全不變的。

形狀(shape)

一塊嚴格依附於物體(body)的 2D 碰撞幾何結構(collision geometry)。形狀具有摩擦(friction)和恢

復(restitution)的材料性質。

約束(constraint) 

一個約束(constraint)就是消除物體自由度的物理連接。在 2D 中，一個物體有 3 個自由度。如果我

們把一個物體釘在牆上(像擺錘那樣)，那我們就把它約束到了牆上。這樣，此物體就只能繞着這個釘子旋

轉，所以這個約束消除了它 2 個自由度。

接觸約束(contact constraint)

一個防止剛體穿透，以及用於模擬摩擦(friction)和恢復(restitution)的特殊約束。你永遠都不必創建

一個接觸約束，它們會自動被 Box2D 創建。

關節(joint)

它是一種用於把兩個或多個物體固定到一起的約束。Box2D 支持的關節類型有：旋轉，棱柱，距離等

等。關節可以支持限制(limits)和馬達(motors)。

關節限制(joint limit)

一個關節限制(joint limit)限定了一個關節的運動范圍。例如人類的胳膊肘只能做某一范圍角度的運

動。

關節馬達(joint motor)

一個關節馬達能依照關節的自由度來驅動所連接的物體。例如，你可以使用一個馬達來驅動一個肘的

旋轉。

世界(world)

一個物理世界就是物體，形狀和約束相互作用的集合。Box2D 支持創建多個世界，但這通常是不必要

的。 

 

 3、 創建一個世界

 每個 Box2D 程序都將從一個世界對象(world object)的創建開始。這是一個管理內存，對象和模擬的中心。

要創建一個世界對象，我們首先需要定義一個世界的包圍盒。Box2D 使用包圍盒來加速碰撞檢測。尺寸並不關鍵，但合適的尺寸有助於性能。這個包圍盒過大總比過小好。

            b2AABB worldAABB; 
           
worldAABB.lowerBound.Set(- 
           100.0f, - 
           100.0f); 
           
worldAABB.upperBound.Set( 
           100.0f,  
           100.0f);  
          

接下來我們定義重力矢量。

            b2Vec2 gravity( 
           0.0f, - 
           10.0f); 
           
 
           bool doSleep =  
           true;  
           // 
           當動態物體靜止時使它休眠，減少性能開銷 
          

 現在我們創建世界對象。

b2World world(worldAABB, gravity, doSleep);//在棧上創建world

那么現在我們有了自己的物理世界，讓我們再加些東西進去。

4、創建一個地面

 第一步，我們創建地面體。要創建它我們需要一個物體定義(body definition)，通過物體定義我們來指定地面體的初始位置。

            b2BodyDef groundBodyDef; 
           
groundBodyDef.position.Set( 
           0.0f, - 
           10.0f); 
          

 

 第二步，將物體定義傳給世界對象來創建地面體。世界對象並不保存到物體定義的引用。地面體是作為靜態物體(static body)創建的，靜態物體之間並沒有碰撞，它們是固定的。當一個物體具有零質量的時候 Box2D 就會確定它為靜態物體，物體的默認質量是零，所以它們默認就是靜態的。

b2Body* ground = world.CreateBody(&groundBodyDef);

 

第三步，我們創建一個地面的多邊形定義。我們使用 SetAsBox 簡捷地把地面多邊形規定為一個盒子(矩形)形狀，盒子的中點就位於父物體的原點上。

            b2PolygonDef groundShapeDef; 
           
groundShapeDef.SetAsBox( 
           50.0f,  
           10.0f); 
          

其中，SetAsBox 函數接收了半個寬度和半個高度，這樣的話，地面盒就是 100 個單位寬(x 軸)以及 20 個單位高(y 軸)。Box2D 已被調諧使用米，千克和秒來作單位，所以你可以用米來考慮長度。

 

 在第四步中，我們在地面體上創建地面多邊形，以完成地面體。

groundBody->CreateShape(&groundShapeDef); // 創建形狀用於碰撞檢測等

5、 創建一個動態物體

首先我們用 CreateBody 創建物體。

             b2BodyDef bodyDef; 
            
bodyDef.position.Set( 
            0.0f,  
            4.0f); 
            
b2Body* body = world.CreateBody(&bodyDef);  
           

 

接下來我們創建並添加一個多邊形形狀到物體上。注意我們把密度設置為 1，默認的密度是 0。並且，形狀的摩擦設置到了 0.3。形狀添加好以后，我們就使用 SetMassFromShapes 方法來命令物體通過形狀去計算其自身的質量。這暗示了你可以給單個物體添加一個以上的形狀。如果質量計算結果為 0，那么物體會變成真正的靜態。

  b2PolygonDef shapeDef;

shapeDef.SetAsBox(1.0f, 1.0f);
shapeDef.density = 1.0f;
shapeDef.friction = 0.3f;
body->CreateShape(&shapeDef);
body->SetMassFromShapes();

 

 6、模擬(Box2D 的)世界

 

 我們已經初始化好了地面盒和一個動態盒。現在我們只有少數幾個問題需要考慮。Box2D 中有一些數學代碼構成的積分器(integrator)，積分器在離散的時間點上模擬物理方程，它將與游戲動畫循環一同運行。所以我們需要為 Box2D 選取一個時間步，通常來說游戲物理引擎需要至少 60Hz 的速度，也就是 1/60 的時間步。你可以使用更大的時間步，但是你必須更加小心地為你的世界調整定義。我們也不喜歡時間步變化得太大，所以不要把時間步關聯到幀頻(除非你真的必須這樣做)。直截了當地，這個就是時間步：float32 timeStep = 1.0f / 60.0f; 

 除了積分器之外，Box2D 中還有約束求解器(constraint solver)。約束求解器用於解決模擬中的所有約束，一次一個。單個的約束會被完美的求解，然而當我們求解一個約束的時候，我們就會稍微耽誤另一個。要得到良好的解，我們需要迭代所有約束多次。建議的 Box2D 迭代次數是 10 次。你可以按自己的喜好去調整這個數，但要記得它是速度與質量之間的平衡。更少的迭代會增加性能並降低精度，同樣地，更多的迭代會減少性能但提高模擬質量。這是我們選擇的迭代次數：

 int32 iterations = 10;//一個時間步遍歷10次約束

 

 現在我們可以開始模擬循環了，在游戲中模擬循環應該並入游戲循環。每次循環你都應該調用 b2World::Step，通常調用一次就夠了，這取決於幀頻以及物理時間步。

 這就是模擬 1 秒鍾內 60 個時間步的循環

for (int32 i =  0; i <  60; ++i)
{
    world.Step(timeStep, iterations);
}

 

 

 7、API 設計

 

單位

 

 Box2D 使用浮點數，所以必須使用一些公差來保證它正常工作。這些公差已經被調諧得適合米-千克-秒(MKS)單位。尤其是，Box2D 被調諧得能良好地處理 0.1 到 10 米之間的移動物體。這意味着從罐頭盒到公共汽車大小的對象都能良好地工作。 

• 注意：Box2D 已被調諧至 MKS 單位。移動物體的尺寸大約應該保持在 0.1 到 10 米之間。你可能需要一些縮放系統來渲染你的場景和物體。Box2D 中的例子是使用 OpenGL 的視口來變換的。

 

用戶數據

b2Shape，b2Body 和 b2Joint 類都允許你通過一個 void 指針來附加用戶數據。這在你測試 Box2D 數據結構，以及你想把它們聯系到自己的引擎中的時候是較方便的。舉個典型的例子，在角色上的剛體中附加到角色的指針，這就構成了一個循環引用。如果你有角色，你就能得到剛體。如果你有剛體，你就能得到角色。

             GameActor* actor = GameCreateActor(); 
            
b2BodyDef bodyDef; 
            
bodyDef.userData = actor; 
            
actor->body = box2Dworld->CreateBody(&bodyDef); 
           

這是一些需要用戶數據的案例： 

• 使用碰撞結果給角色施加傷害

• 當玩家進入一個包圍盒時播放一段腳本事件

• 當 Box2D 通知你一個關節即將摧毀時訪問一個游戲結構

記得用戶數據是可選的，並且能放入任何東西。然而，你需要保持一致性。例如，如果你想在一個物體中保存一個角色的指針，那你就應該在所有物體中都保存一個角色指針。不要在一個物體中保存角色指針，卻在另一個物體中保存一個其它指針。這可能會導致程序崩潰。 

 

8、世界 

 b2World 類包含着物體和關節。它管理着模擬的方方面面，並允許異步查詢(就像 AABB 查詢)。你與 Box2D 的大部分交互都將通過 b2World 對象來完成。

 要創建或摧毀一個世界你需要使用 new 和 delete：

             b2World* myWorld =  
            new b2World(aabb, gravity, doSleep); 
            
 
            // 
             ... do stuff ... 
            
delete myWorld; 
           

 世界類用於驅動模擬。你需要指定一個時間步和一個迭代次數。例如：

             float32 timeStep =  
            1.0f /  
            60.f; 
            
int32 iterationCount =  
            10; 
            
myWorld->Step(timeStep, iterationCount); 
           

 

 在時間步完成之后，你可以調查物體和關節的信息。最可能的情況是你會獲取物體的位置，這樣你才能更新你的角色並渲染它們。你可以在游戲循環的任何地方執行時間步，但你應該意識到事情發生的順序。例如，如果你想要在一幀中得到新物體的碰撞結果，你必須在時間步之前創建物體。推薦使用固定的時間步。使用大一些的時間步你可以在低幀率的情況下提升性能。1/60 的時間步通常會呈現一個高質量的模擬。

 

  掃描世界：

世界就是一個物體和關節的容器。你可以獲取世界中所有物體和關節並遍歷它們。例如，這段代碼會喚醒世界中的所有物體：

 
            for (b2Body* b = myWorld->GetBodyList(); b; b = b->GetNext()) 
            
{ 
            
    b->WakeUp(); 
            
}  
           

 

 AABB 查詢：

有時你需要求出一個區域內的所有形狀。b2World 類為此使用了 broad-phase 數據結構，提供了一個 log(N) 的快速方法。你提供一個世界坐標的 AABB，而 b2World 會返回一個所有大概相交於此 AABB 的形狀之數組。這不是精確的，因為函數實際上返回那些 AABB 與規定之 AABB 相交的形狀。例如，下面的代碼找到所有大概與指定 AABB 相交的形狀並喚醒所有關聯的物體。

             b2AABB aabb; 
            
aabb.minVertex.Set(- 
            1.0f, - 
            1.0f); 
            
aabb.maxVertex.Set( 
            1.0f,  
            1.0f); 
            
 
            const int32 k_bufferSize =  
            10; 
            
b2Shape *buffer[k_bufferSize]; 
            
int32 count = myWorld->Query(aabb, buffer, k_bufferSize); 
            
 
            for (int32 i =  
            0; i < count; ++i) 
            
{ 
            
    buffer[i]->GetBody()->WakeUp(); 
            
}  
           

 

 9、 物體

 物體具有位置和速度。你可以應用力，扭矩和沖量到物體。物體可以是靜態的或動態的，靜態物體永遠不會移動，並且不會與其它靜態物體發生碰撞。物體是形狀的主干，物體攜帶形狀在世界中運動。在 Box2D 中物體總是剛體，這意味着同一剛體上的兩個形狀永遠不會相對移動。通常你會保存所有你所創建的物體的指針，這樣你就能查詢物體的位置，並在圖形實體中更新它的位置。另外在不需要它們的時候你也需要通過它們的指針摧毀它們。

  質量性質：

1）在物體定義中顯式地設置 

 bodyDef.massData.mass = 2.0f;//物體的質量是2kg

 2）顯式地在物體上設置(在其創建之后)

3）基於物體上的形狀來進行密度設置 

 b2PolygonDef shapeDef;

            shapeDef.SetAsBox( 
           1.0f,  
           1.0f); 
           
shapeDef.density =  
           1.0f; 
           
body->CreateShape(&shapeDef); 
           
body->SetMassFromShapes();//這個函數成本較高，所以你應該只在需要時使用它。 
          

你可以在運行時調整一個物體的質量，這通常是在添加或移除物體上之形狀時完成的。可能你會根據物體上的當前形狀來調整其質量。

可能你也會直接設置質量。例如，你可能會改變形狀，但你只想使用自己的質量公式。

void SetMass( const b2MassData* massData);

通過以下這些函數可以獲得物體的質量數據：

             float32 GetMass()  
            const; 
            
float32 GetInertia()  
            const; 
            
 
            const b2Vec2& GetLocalCenter()  
            const;  
           

 

位置和角度：

 
                        bodyDef.position.Set( 
            0.0f,  
            2.0f);    
            // 
             the body's origin position. 
            
bodyDef.angle =  
            0.25f * b2_pi;       
            // 
             the body's angle in radians. 
            
          

你可以訪問一個物體的位置和角度，這在你渲染相關游戲角色時很常用。你也可以設置位置，盡管這不怎么常用。

 
            bool SetXForm( 
            const b2Vec2& position, float32 angle); 
            
 
            const b2XForm& GetXForm()  
            const; 
            
 
            const b2Vec2& GetPosition()  
            const; 
            
float32 GetAngle()  
            const;  
           

 

 你可以訪問線速度與角速度，線速度是對於質心所言的。

 
            void SetLinearVelocity( 
            const b2Vec2& v); 
            
b2Vec2 GetLinearVelocity()  
            const; 
            
 
            void SetAngularVelocity(float32 omega); 
            
float32 GetAngularVelocity()  
            const; 
           

 

阻尼：

阻尼用於減小物體在世界中的速率。阻尼與摩擦是不同的，因為摩擦僅在物體有接觸的時候才會發生，而阻尼的模擬要比摩擦便宜多了。然而，阻尼並不能取代摩擦，往往這兩個效果需要同時使用。阻尼參數的范圍可以在 0 到無窮之間，0 的就是沒有阻尼，無窮就是滿阻尼。通常來說，阻尼的值應在 0 到 0.1 之間，我通常不使用線性阻尼，因為它會使物體看起來發飄。

             bodyDef.linearDamping =  
            0.0f; 
            
bodyDef.angularDamping =  
            0.01f; 
           

阻尼相似於穩定性與性能，阻尼值較小的時候阻尼效應幾乎不依賴於時間步，而阻尼值較大的時候阻尼效應將隨着時間步而變化。如果你使用固定的時間步(推薦)這就不是問題了。 

 休眠參數：

模擬物體的成本是高昂的，所以如果物體更少，那模擬的效果就能更好。當一個物體停止了運動時，我們要停止去模擬它。 當 Box2D 確定一個物體(或一組物體)已經停止移動時，物體就會進入休眠狀態，消耗很小的 CPU 開銷。如果一個醒着的物體接觸到了一個休眠中的物體，那么休眠中的物體就會醒來。當物體上的關節或

觸點被摧毀的時候，它們同樣會醒來。你也可以手動地喚醒物體。通過物體定義，你可以指定一個物體是否可以休眠，或者創建一個休眠的物體。

             bodyDef.allowSleep =  
            true; 
            
bodyDef.isSleeping =  
            false; 
           

 

 子彈：

高速移動的物體在 Box2D 被稱為子彈(bullet)，你需要按照游戲的設計來決定哪些物體是子彈。如果你決定一個物體應該按照子彈去處理，使用下面的設置。

bodyDef.isBullet =  true;

子彈開關只影響動態物體。

有的時候，在一個時間步內可能會有大量的剛體同時運動。如果一個物理引擎沒有處理好大幅度運動的問題，你就可能會看見一些物體錯誤地穿過了彼此。這種效果被稱為 隧道效應(tunneling)。默認情況下，Box2D 會通過 連續碰撞檢測(CCD)來防止動態物體穿越靜態物體，這是通過從形狀的舊位置到新位置的掃描來完成的。引擎會查找掃描中的新碰撞，並為這些碰撞計算碰撞時間(TOI)。物體會先被移動到它們的第一個 TOI，然后一直模擬到原時間步的結束。如果有必要這個步驟會重復執行。一般 CCD 不會應用於動態物體之間，這是為了保持性能。在一些游戲環境中你需要在動態物體上也使用 CCD，譬如，你可能想用一顆高速的子彈去射擊薄壁。沒有 CCD，子彈就可能會隧穿薄壁。 CCD 的成本是昂貴的，所以你可能不希望所有運動物體都成為子彈。所以 Box2D 默認只在動態物體和靜態物體之間使用 CCD，這是防止物體逃脫游戲世界的一個有效方法。然而，可能你有一些高速移動的物體需要一直使用 CCD。 

 

 狀態信息：

物體的狀態含有多個方面，通過這些函數你可以訪問這些狀態數據：

 
            bool IsBullet()  
            const; 
            
 
            void SetBullet( 
            bool flag); 
            
 
            bool IsStatic()  
            const; 
            
 
            bool IsDynamic()  
            const; 
            
 
            bool IsFrozen()  
            const; 
            
 
            bool IsSleeping()  
            const; 
            
 
            void AllowSleeping( 
            bool flag); 
            
 
            void WakeUp();  
           

 

 

 力和沖量：

你可以對一個物體應用力，扭矩，以及沖量。當應用一個力或沖量時，你需要提供一個世界位置。這常常會導致對質心的一個扭矩。

 
            void ApplyForce( 
            const b2Vec2& force,  
            const b2Vec2& point); 
            
 
            void ApplyTorque(float32 torque); 
            
 
            void ApplyImpulse( 
            const b2Vec2& impulse,  
            const b2Vec2& point); 
           

應用力，扭矩或沖量會喚醒物體，有時這是不合需求的。例如，你可能想要應用一個穩定的力，並允許物體休眠來提升性能。這時，你可以使用這樣的代碼：

 
            if (myBody->IsSleeping() ==  
            false) 
            
{ 
            
    myBody->ApplyForce(myForce, myPoint); 
            
}  
           

 

  坐標轉換：

物體類包含一些工具函數，它們可以幫助你在局部和世界坐標系之間轉換點和向量。如果你不了解這些概念，請看 Jim Van Verth 和 Lars Bishop 的“Essential Mathematics for Games and Interactive Applications”。這些函數都很高效，所以可放心使用。

             b2Vec2 GetWorldPoint( 
            const b2Vec2& localPoint); 
            
b2Vec2 GetWorldVector( 
            const b2Vec2& localVector); 
            
b2Vec2 GetLocalPoint( 
            const b2Vec2& worldPoint); 
            
b2Vec2 GetLocalVector( 
            const b2Vec2& worldVector);  
           

 

 列表

你可以遍歷一個物體的形狀，其主要用途是幫助你訪問形狀的用戶數據。

 
            for (b2Shape* s = body->GetShapeList(); s; s = s->GetNext()) 
            
{ 
            
    MyShapeData* data = (MyShapeData*)s->GetUserData(); 
            
    ...  
            do something with data ... 
            
} 
           

你也可以用類似的方法遍歷物體的關節列表。 

 

 

 10、 形狀

 形狀就是物體上的碰撞幾何結構。另外形狀也用於定義物體的質量。也就是說，你來指定密度，Box2D 可以幫你計算出質量。形狀具有摩擦和恢復的性質。形狀還可以攜帶篩選信息，使你可以防止某些游戲對象之間的碰撞。形狀永遠屬於某物體，單個物體可以擁有多個形狀。形狀是抽象類，所以在 Box2D 中可以實現許多

類型的形狀。如果你有勇氣，那便可以實現出自己的形狀類型(和碰撞算法)。

形狀定義 :

形狀定義用於創建形狀。通用的形狀數據會保存在 b2ShapeDef 中，特殊的形狀數據會保存在其派生類中。 

1)摩擦和恢復 

 摩擦可以使對象逼真地沿其它對象滑動。Box2D 支持靜摩擦和動摩擦，但使用相同的參數。摩擦參數經常會設置在 0 到 1 之間，0 意味着沒有摩擦，1 會產生強摩擦。當計算兩個形狀之間的摩擦時，Box2D 必須聯合兩個形狀的摩擦參數，這是通過以下公式完成的：

             float32 friction; 
            
friction = sqrtf(shape1->friction * shape2->friction); 
           

 恢復可以使對象彈起，想象一下，在桌面上方丟下一個小球。恢復的值通常設置在 0 到 1 之間，0 的意思是小球不會彈起，這稱為非彈性碰撞；1 的意思是小球的速度會得到精確的反射，這稱為完全彈性碰撞。恢復是通過這樣的公式計算的：

             float32 restitution; 
            
restitution = b2Max(shape1->restitution, shape2->restitution); 
           

 當一個形狀發生多碰撞時，恢復會被近似地模擬。這是因為 Box2D 使用了迭代求解器.

2) 密度

Box2D 可以根據附加形狀的質量分配來計算物體的質量以及轉動慣量。直接指定物體質量常常會導致不協調的模擬。因此，推薦的方法是使用b2Body::SetMassFromShape 來根據形狀設置質量。 

 3) 篩選

碰撞篩選是一個防止某些形狀發生碰撞的系統。 

Box2D 支持 16 個 種群，對於任何一個形狀你都可以指定它屬於哪個種群。你還可以指定這個形狀可以和其它哪些種群發生碰撞。例如，你可以在一個多人游戲中指定玩家之間不會碰撞，怪物之間也不會碰撞，但是玩家和怪物會發生碰撞。這是通過掩碼來完成的，例如：

             playerShapeDef.filter.categoryBits =  
            0x0002; 
            
monsterShapeDef.filter.categoryBits =  
            0x0004; 
            
playerShape.filter.maskBits =  
            0x0004; 
            
monsterShapeDef.filter.maskBits =  
            0x0002; 
           

 

 碰撞組可以讓你指定一個整數的組索引。你可以讓同一個組的所有形狀總是相互碰撞(正索引)或永遠不碰撞(負索引)。組索引通常用於一些以某種方式關聯的事物，就像自行車的那些部件。在下面的例子中，shape1 和 shape2 總是碰撞，而 shape3 和 shape4 永遠不會碰撞。

             shape1Def.filter.groupIndex =  
            2; 
            
shape2Def.filter.groupIndex =  
            2; 
            
shape3Def.filter.groupIndex = - 
            8; 
            
shape4Def.filter.groupIndex = - 
            8; 
           

 不同組索引之間形狀的碰撞會按照種群和掩碼來篩選。換句話說，組篩選比種群篩選有更高的優選權。

注意在 Box2D 中的其它碰撞篩選，這里是一個列表： 

• 靜態物體上的形狀永遠不會與另一個靜態物體上的形狀發生碰撞

• 同一個物體上的形狀之間永遠不會發生碰撞

• 你可以有選擇地啟用或禁止由關節連接的物體上的形狀之間是否碰撞

有時你可能希望在形狀創建之后去改變其碰撞篩選，你可以使用 b2Shape::GetFilterData 以及 b2Shape::SetFilterData 來存取已存在形狀之 b2FilterData 結構。Box2D 會緩存篩選結果，所以你需要使用 b2World::Refilter 手動地進行重篩選。

 4）傳感器

 有時候游戲邏輯需要判斷兩個形狀是否相交，但卻不應該有碰撞反應。這可以通過傳感器(sensor)來完成。傳感器會偵測碰撞而不產生碰撞反應。你可以將任一形狀標記為傳感器，傳感器可以是靜態或動態的。記得，每個物體上可以有多個形狀，並且傳感器和實體形狀是可以混合的。

 myShapeDef.isSensor = true;

 5） 圓形定義

b2CircleDef 擴充了 b2ShapeDef 並增加一個半徑和一個局部位置。

             b2CircleDef def; 
            
def.radius =  
            1.5f; 
            
def.localPosition.Set( 
            1.0f,  
            0.0f);  
           

 6）多邊形定義

b2PolyDef 用於定義凸多邊形。要正確地使用需要一點點技巧，所以請仔細閱讀。最大頂點數由 b2_maxPolyVertices 定義，當前是 8。如果你需要更多頂點，你必須修改 b2Settings.h 中的 b2_maxPolyVertices。當創建多邊形定義時，你需要給出所用的頂點數目。這些頂點必須按照相對於右手坐標系之 z 軸逆時

針(CCW)的順序定義。在你的屏幕上可能是順時針的，這取決於你的坐標系統規則。多邊形必須是凸多邊形，也就是，每個頂點都必須指向外面。最后，你也不應該重疊任何頂點。Box2D 會自動地封閉環路。 

 這里是一個三角形的多邊形定義的例子：

             b2PolygonDef triangleDef; 
            
triangleDef.vertexCount =  
            3; 
            
triangleDef.vertices[ 
            0].Set(- 
            1.0f,  
            0.0f); 
            
triangleDef.vertices[ 
            1].Set( 
            1.0f,  
            0.0f); 
            
triangleDef.vertices[ 
            2].Set( 
            0.0f,  
            2.0f); 
           

 

 7）形狀工廠

 初始化一個形狀定義，而后將其傳遞給父物體；形狀就是這樣創建的。

             b2CircleDef circleDef; 
            
circleDef.radius =  
            3.0f; 
            
circleDef.density =  
            2.5f; 
            
b2Shape* myShape = myBody->CreateShape(&circleDef); 
           

 

 

 11、關節

 關節的作用是把物體約束到世界，或約束到其它物體上。在游戲中的典型例子是木偶，蹺蹺板和滑輪。關節可以用許多種不同的方法結合起來，創造出有趣的運動。

有些關節提供了限制(limit)，以便你控制運動范圍。有些關節還提供了馬達(motor)，它可以以指定的速度驅動關節，直到你指定了更大的力或扭矩。

1）關節定義

各種關節類型都派生自 b2JointDef。所有關節都連接兩個不同的物體，可能其中一個是靜態物體。如果你想浪費內存的話，那就創建一個連接兩個靜態物體的關節 你可以為任何一種關節指定用戶數據。你還可以提供一個標記，用於預防相連的物體發生碰撞。實際上，這是默認行為，你可以設置 collideConnected 布爾值來允許相連的物體碰撞。很多關節定義需要你提供一些幾何數據。一個關節常常需要一個錨點(anchor point)來定義，這是固定於相接物體中的點。在 Box2D 中這點需要在局部坐標系中指定，這樣，即便當前物體的變化違反了關節約束，關節還是可以被指定 —— 在游戲存取進度時這經常會發生。另外，有些關節定義需要默認的

物體之間的相對角度。這樣才能通過關節限制或固定的相對角來正確地約束旋轉。初始化幾何數據可能有些乏味。所以很多關節提供了初始化函數，消除了大部分工作。然而，這些初始化函數通常只應用於原型，在產品代碼中應該直接地定義幾何數據。這能使關節行為更加穩固。其余的關節定義數據依賴於關節的類型。下面我們來介紹它們。 

 2)距離關節

 距離關節是最簡單的關節之一，它描述了兩個物體上的兩個點之間的距離應該是常量。當你指定一個距離關節時，兩個物體必須已在應有的位置上。隨后，你指定兩個世界坐標中的錨點。第一個錨點連接到物體 1，第二個錨點連接到物體 2。這些點隱含了距離約束的長度。

 

 

 

 這是一個距離關節定義的例子。在此我們允許了碰撞。

             b2DistanceJointDef jointDef; 
            
jointDef.Initialize(myBody1, myBody2, worldAnchorOnBody1,  
            
worldAnchorOnBody2); 
            
jointDef.collideConnected =  
            true; 
           

 3)旋轉關節

 一個旋轉關節會強制兩個物體共享一個錨點，即所謂鉸接點。旋轉關節只有一個自由度：兩個物體的相對旋轉。這稱之為關節角。

 

 要指定一個旋轉關節，你需要提供兩個物體以及一個世界坐標的錨點。初始化函數會假定物體已經在應有位置了。在此例中，兩個物體被旋轉關節連接於第一個物體的質心。

             b2RevoluteJointDef jointDef; 
            
jointDef.Initialize(myBody1, myBody2, myBody1->GetWorldCenter()); 
           

 

 這里是對上面旋轉關節定義的修訂；這次，關節擁有一個限制以及一個馬達，后者用於模擬摩擦。

             b2RevoluteJointDef jointDef; 
            
jointDef.Initialize(body1, body2, myBody1->GetWorldCenter());//使用 Initialize() 創建關節時，旋轉關節角為 0，無論兩個物體當前的角度怎樣。 
            
jointDef.lowerAngle = - 
            0.5f * b2_pi;  
            // 
             -90 degrees最小角度 
            
jointDef.upperAngle =  
            0.25f * b2_pi;  
            // 
             45 degrees最大角度 
            
jointDef.enableLimit =  
            true; 
            
jointDef.maxMotorTorque =  
            10.0f;//馬達 
            
jointDef.motorSpeed =  
            0.0f; 
            
jointDef.enableMotor =  
            true; 
           

你可以訪問旋轉關節的角度，速度，以及扭矩。 

float32 GetJointAngle()  const ;  

float32 GetJointSpeed() const;
float32 GetMotorTorque() const;

你也可以在每步中更新馬達參數。 

void SetMotorSpeed(float32 speed);

void SetMaxMotorTorque(float32 torque);  

 關節馬達有一些有趣的能力。你可以在每個時間步中更新關節速度，這可以使關節像正弦波一樣來回

移動，或者按其它什么函數運動。

 
            // 
             ... Game Loop Begin ... 
            
myJoint->SetMotorSpeed(cosf( 
            0.5f * time)); 
            
 
            // 
             ... Game Loop End ... 
           

你還可以使用關節馬達來追蹤某個關節角度。例如：

 
            // 
             ... Game Loop Begin ... 
            
float32 angleError = myJoint->GetJointAngle() - angleTarget; 
            
float32 gain =  
            0.1f; 
            
myJoint->SetMotorSpeed(-gain * angleError); 
            
 
            // 
             ... Game Loop End ... 
           

通常來講你的增益參數不應過大，否則你的關節可能會變得不穩定。

 

4）移動關節

 移動關節(prismatic joint)允許兩個物體沿指定軸相對移動，它會阻止相對旋轉。因此，移動關節只有一個自由度。

 

移動關節的定義有些類似於旋轉關節；只是轉動角度換成了平移，扭矩換成了力。以這樣的類比，我們來看一個帶有關節限制以及馬達摩擦的移動關節定義： 

b2PrismaticJointDef jointDef;

b2Vec2 worldAxis(1.0f, 0.0f);
jointDef.Initialize(myBody1, myBody2, myBody1->GetWorldCenter(), 
worldAxis);
jointDef.lowerTranslation = -5.0f;
jointDef.upperTranslation = 2.5f;
jointDef.enableLimit = true;
jointDef.motorForce = 1.0f;
jointDef.motorSpeed = 0.0f;
jointDef.enableMotor = true;

 旋轉關節隱含着一個從屏幕射出的軸，而移動關節明確地需要一個平行於屏幕的軸。這個軸會固定於兩個物體之上，沿着它們的運動方向。就像旋轉關節一樣，當使用 Initialize() 創建移動關節時，移動為 0。所以一定要確保移動限制范圍內包含了 0。移動關節的用法類似於旋轉關節，這是它的相關成員函數： 

float32 GetJointTranslation()  const;
float32 GetJointSpeed()  const;
float32 GetMotorForce()  const;
void SetMotorSpeed(float32 speed);

void SetMotorForce(float32 force); 

 

 5）滑輪關節

 滑輪關節用於創建理想的滑輪，它將兩個物體接地(ground)並連接到彼此。這樣，當一個物體升起時，另一個物體就會下降。滑輪的繩子長度取決於初始時的狀態。

length1 + length2 == constant

 

 

 你還可以提供一個系數(ratio)來模擬滑輪組，這會使滑輪一側的運動比另一側要快。同時，一側的約束力也比另一側要小。你也可以用這個來模擬機械杠桿(mechanical leverage)。length1 + ratio * length2 == constant 舉個例子，如果系數是 2，那么 length1 的變化會是 length2 的兩倍。另外連接 body1 的繩子的約束力將會是連接 body2 繩子的一半。當滑輪的一側完全展開時，另一側的繩子長度為零，這可能會出問題。此時，約束方程將變得奇異。因此，滑輪關節約束了每一側的最大長度。另外出於游戲原因你可能也希望控制這個最大長度。最大長度能提高穩定性，以及提供更多的控制。

這是一個滑輪定義的例子：

             b2Vec2 anchor1 = myBody1->GetWorldCenter(); 
            
b2Vec2 anchor2 = myBody2->GetWorldCenter(); 
            
b2Vec2 groundAnchor1(p1.x, p1.y +  
            10.0f); 
            
 b2Vec2 groundAnchor2(p2.x, p2.y +  
            12.0f); 
            
float32 ratio =  
            1.0f; 
            
b2PulleyJointDef jointDef; 
            
jointDef.Initialize(myBody1, myBody2, groundAnchor1, groundAnchor2,  
            
anchor1, anchor2, ratio); 
            
jointDef.maxLength1 =  
            18.0f; 
            
jointDef.maxLength2 =  
            20.0f; 
           

 滑輪關節提供了當前長度：

float32 GetLength1()  const;

float32 GetLength2()  const;  

 

 6） 齒輪關節

 如果你想要創建復雜的機械裝置，你可能需要齒輪。原則上，在 Box2D 中你可以用復雜的形狀來模擬輪齒，但這並不十分高效，而且這樣的工作可能有些乏味。另外，你還得小心地排列齒輪，保證輪齒能平穩地嚙合。Box2D 提供了一個創建齒輪的更簡單的方法：齒輪關節。

 

 

 齒輪關節需要兩個被旋轉關節或移動關節接地(ground)的物體，你可以任意組合這些關節類型。另外，創建旋轉或移動關節時，Box2D 需要地(ground)作為 body1。類似於滑輪的系數，你可以指定一個齒輪系數(ratio)，齒輪系數可以為負。另外值得注意的是，當一個是旋轉關節(有角度的)而另一個是移動關節(平移)時，齒輪系數是長度或長度分之一。coordinate1 + ratio * coordinate2 == constant這是一個齒輪關節的例子：

             b2GearJointDef jointDef; 
            
jointDef.body1 = myBody1; 
            
jointDef.body2 = myBody2; 
            
jointDef.joint1 = myRevoluteJoint; 
            
jointDef.joint2 = myPrismaticJoint; 
            
jointDef.ratio =  
            2.0f * b2_pi / myLength;  
           

• 注意：齒輪關節總應該先於旋轉或移動關節被刪除，否則你的代碼將會由於齒輪關節中的無效關節

指針而導致崩潰。另外齒輪關節也應該在任何相關物體被刪除之前刪除。

7）關節工廠

 關節是通過世界的工廠方法來創建和摧毀的，這引出了一個舊問題： 

• 注意：不要試圖在棧上創建物體或關節，也不要使用 new 或 malloc 在堆上創建。物體以及關節必須要通過 b2World 類的方法來創建或摧毀。

這是一個關於旋轉關節生命期的例子：

             b2RevoluteJointDef jointDef; 
            
jointDef.body1 = myBody1; 
            
jointDef.body2 = myBody2; 
            
jointDef.anchorPoint = myBody1->GetCenterPosition(); 
            
b2RevoluteJoint* joint = myWorld->CreateJoint(&jointDef); 
            
 
            // 
             ... do stuff ... 
            
myWorld->DestroyJoint(joint); 
            
joint = NULL; 
           

 8）使用關節

 在許多模擬中，關節被創建之后便不再被訪問了。然而，關節中包含着很多有用的數據，使你可以創建出豐富的模擬。首先，你可以在關節上得到物體，錨點，以及用戶數據。

             b2Body* GetBody1(); 
            
b2Body* GetBody2(); 
            
b2Vec2 GetAnchor1(); 
            
b2Vec2 GetAnchor2(); 
            
 
            void* GetUserData(); 
           

 

 11、接觸

 接觸(contact)是由 Box2D 創建的用於管理形狀間碰撞的對象。接觸有不同的種類，它們都派生自 b2Contact，用於管理不同類型形狀之間的接觸。例如，有管理多邊形之間碰撞的類，有管理圓形之間碰撞的類。

這里是 Box2D 中的一些與碰撞有關的術語：

 觸點(contact point)

兩個形狀相互接觸的點。實際上當物體的表面相接觸時可能會有一定接觸區域，在 Box2D 則近似地

以少數點來接觸。

接觸向量(contact normal)

從 shape1 指向 shape2 的單位向量。

接觸分隔(contact separation)

分隔相反於穿透，當形狀相重疊時，分隔為負。可能以后的 Box2D 版本中會以正隔離來創建觸點，所以當有觸點的報告時你可能會檢查符號。

法向力(normal force)

Box2D 使用了一個迭代接觸求解器，並會以觸點保存結果。你可以安全地使用法向力來判斷碰撞強度。例如，你可以使用這個力來引發破碎，或者播放碰撞的聲音。

 切向力(tangent force)

它是接觸求解器關於摩擦力的估計量。

接觸標識(contact ids)

Box2D 會試圖利用一個時間步中的觸點壓力(contact force)結果來推測下一個時間步中的情況。接觸標識用於匹配跨越時間步的觸點，它包含了幾何特征索引以便區分觸點。 

 

 當兩個形狀的 AABB 重疊時，接觸就被創建了。有時碰撞篩選會阻止接觸的創建，有時盡管碰撞已篩選了 Box2D 還是須要創建一個接觸，這種情況下它會使用 b2NullContact 來防止碰撞的發生。當 AABB 不再重疊之后接觸會被摧毀。也許你會皺起眉頭，為了沒有發生實際碰撞的形狀(只是它們的 AABB)卻創建了接觸。好吧，的確是這樣的，這是一個“雞或蛋”的問題。我們並不知道是否需要一個接觸，除非我們創建一個接觸去分析碰撞。如果形狀之間沒有發生碰撞，我們需要正確地刪除接觸，或者，我們可以一直等到 AABB 不再重疊。Box2D 選擇了后面這個方法。

 1）接觸監聽器

 通過實現 b2ContactListener 你就可以接受接觸數據。當一個觸點被創建時，當它持續超過一個時間步時，以及當它被摧毀時，這個監聽器(listener)就會發出報告。請留意兩個形狀之間可能會有多個觸點。

 class MyContactListener : public b2ContactListener

{

public:

 void Add(const b2ContactPoint* point)

 {

 // handle add point

 }

 void Persist(const b2ContactPoint* point)

 {

 // handle persist point

 }

 void Remove(const b2ContactPoint* point)

 {

 // handle remove point

 }

 void Result(const b2ContactResult* point)

 {

 // handle results

 }

};

 

 2)接觸篩選

 通常，你不希望游戲中的所有物體都發生碰撞。例如，你可能會創建一個只有某些角色才能通過的門。這稱之為接觸篩選，因為一些交互被篩選出了。

通過實現 b2ContactFilter 類，Box2D 允許定制接觸篩選。這個類需要一個 ShouldCollide 函數，用於接收兩個 b2Shape 的指針，如果應該碰撞那么就返回 true。默認的 ShouldCollide 實現使用了 6 形狀 中的 b2FilterData。

 
            bool b2ContactFilter::ShouldCollide(b2Shape* shape1, b2Shape* shape2) 
            
{ 
            
  
            const b2FilterData& filter1 = shape1->GetFilterData(); 
            
  
            const b2FilterData& filter2 = shape2->GetFilterData(); 
            
  
            if (filter1.groupIndex == filter2.groupIndex && filter1.groupIndex !=  
            0) 
            
 { 
            
  
            return filter1.groupIndex >  
            0; 
            
 } 
            
  
            bool collide = (filter1.maskBits & filter2.categoryBits) !=  
            0 &&  
            
(filter1.categoryBits & filter2.maskBits) !=  
            0; 
            
  
            return collide; 
            
}  
           

 

 12、雜項

 1)

你可以實現一個 b2BoundaryListener，這樣當有物體超出世界的 AABB 時 b2World 就能通知你。當你得到回調時，你不應該試圖刪除物體；取而代之的是，你可以為角色做個刪除或錯誤處理標記，在物理時間步之后再進行這個事件的處理。

class MyBoundaryListener : public b2BoundaryListener

{

 void Violation(b2Body* body)

 {

 MyActor* myActor = (MyActor*)body->GetUserData();

 myActor->MarkForErrorHandling();

 }

};

隨后你可以在世界對象中注冊你的邊界監聽器實例，這應該安排在世界初始化過程中。

myWorld->SetListener(myBoundaryListener);

 2)隱式摧毀

如果你摧毀一個 Box2D 實體，你應該保證所有到它的引用都刪除了。如果你只有實體的單個引用的話，那就簡單了。但如果你有很多個引用，你可能要考慮實現一個處理類來封裝原始指針。通常使用 Box2D 時你需要創建並摧毀許多物體，形狀還有關節。管理這些實體有些自動化，如果你摧毀一個物體，所有它的形狀，關節，以及接觸都會摧毀，這稱為隱式摧毀。任何連接於這些關節或接觸之一的物體將被喚醒，通常這是便利的。然而，你應該意識到了一個關鍵問題： 

 

 

Box2D 提供了一個名為 b2WorldListener 的監聽器類，你可以實現它並提供給世界對象，隨后當關節將被隱式摧毀時世界對象就會提醒你。

你可以實現一個 b2DestructionListener，這樣當一個形狀或關節隱式摧毀時 b2World 就能通知你，這可以幫助你預防訪問無效指針。

class MyDestructionListener : public b2DestructionListener

{

 void SayGoodbye(b2Joint* joint)

 {

 // remove all references to joint.

 }

};

隨后你可以注冊它，這應該在世界初始化過程中。

myWorld->SetListener(myDestructionListener);