程序博客网 > 汽车模型设计软件

Box2d源码学习<四>数学库API的实现

来源：互联网 发布：汽车模型设计软件 编辑：程序博客网 时间：2024/05/07 18:38

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

为了满足Box2d中所要用到的数学知识，在Box2d的公共模块中，包含了一个小巧而简便的向量矩阵的数学库。这部分所有的定义实现均有结构体实现的，所以其内部的成员均对外部公开，所以你可以任意使用和访问。该部分主要由以下内容：

a)、向量，包括二维列向量和三维列向量

b)、矩阵，包括2X2矩阵和3X3矩阵

c)、旋度、扫描、和变换的实现

d)、其他部分的实现

 

一、向量部分

1、 二维列向量的实现

[cpp] view plaincopy
  1.  //2d列向量  
  2. struct b2Vec2  
  3. {  
  4.     /************************************************************************** 
  5.     * 功能描述：构造函数，不做任何事，仅仅为了性能 
  6.     * 参数说明： (void) 
  7.     * 返 回 值： (void) 
  8.     **************************************************************************/  
  9.     b2Vec2() {}  
  10.     /************************************************************************** 
  11.     * 功能描述：构造函数，构建使用的坐标 
  12.     * 参数说明： x:x坐标 
  13.                  y:y坐标 
  14.     * 返 回 值： (void) 
  15.     **************************************************************************/  
  16.     b2Vec2(float32 x, float32 y) : x(x), y(y) {}  
  17.     /************************************************************************** 
  18.     * 功能描述：将向量置0 
  19.     * 参数说明： (void) 
  20.     * 返 回 值： (void) 
  21.     **************************************************************************/  
  22.     void SetZero() { x = 0.0f; y = 0.0f; }  
  23.   
  24.     /************************************************************************** 
  25.     * 功能描述：将向量设置成指定的坐标 
  26.     * 参数说明： x_:x坐标 
  27.                  y_:y坐标 
  28.     * 返 回 值： (void) 
  29.     **************************************************************************/  
  30.     void Set(float32 x_, float32 y_) { x = x_; y = y_; }  
  31.   
  32.     /************************************************************************** 
  33.     * 功能描述：将向量取反，重载 - 运算符 
  34.     * 参数说明： (void) 
  35.     * 返 回 值： 一个新的二维向量 
  36.     **************************************************************************/  
  37.     b2Vec2 operator -() const { b2Vec2 v; v.Set(-x, -y); return v; }  
  38.   
  39.     /************************************************************************** 
  40.     * 功能描述：读取指定索引的元素，重载 () 运算符 
  41.     * 参数说明： i ：索引值 
  42.     * 返 回 值： 列中对应索引元素值 
  43.     **************************************************************************/  
  44.     float32 operator () (int32 i) const  
  45.     {  
  46.         return (&x)[i];  
  47.     }  
  48.   
  49.     /************************************************************************** 
  50.     * 功能描述：改写指定索引的元素，重载 () 运算符 
  51.     * 参数说明： i ：索引值 
  52.     * 返 回 值： 列中对应索引元素的引用 
  53.     **************************************************************************/  
  54.     float32& operator () (int32 i)  
  55.     {  
  56.         return (&x)[i];  
  57.     }  
  58.   
  59.     /************************************************************************** 
  60.     * 功能描述：与另一个向量相加 
  61.     * 参数说明： v ：向量的引用 
  62.     * 返 回 值： (void) 
  63.     **************************************************************************/  
  64.     void operator += (const b2Vec2& v)  
  65.     {  
  66.         x += v.x; y += v.y;  
  67.     }  
  68.     /************************************************************************** 
  69.     * 功能描述：与另一个向量相减 
  70.     * 参数说明： v ：向量的引用 
  71.     * 返 回 值： (void) 
  72.     **************************************************************************/  
  73.     void operator -= (const b2Vec2& v)  
  74.     {  
  75.         x -= v.x; y -= v.y;  
  76.     }  
  77.     /************************************************************************** 
  78.     * 功能描述：与标量相乘 
  79.     * 参数说明： a ：标量 
  80.     * 返 回 值： (void) 
  81.     **************************************************************************/  
  82.     void operator *= (float32 a)  
  83.     {  
  84.         x *= a; y *= a;  
  85.     }  
  86.     /************************************************************************** 
  87.     * 功能描述：获取向量的长度 
  88.     * 参数说明： (void) 
  89.     * 返 回 值： 向量长度 
  90.     **************************************************************************/  
  91.     float32 Length() const  
  92.     {  
  93.         return b2Sqrt(x * x + y * y);  
  94.     }  
  95.     /************************************************************************** 
  96.     * 功能描述：获取向量的长度的平方。出于性能要求， 
  97.                 使用此函数代替b2Vec2::Legth函数（如果可能的话） 
  98.     * 参数说明： (void) 
  99.     * 返 回 值： 向量长度的平方 
  100.     **************************************************************************/  
  101.     float32 LengthSquared() const  
  102.     {  
  103.         return x * x + y * y;  
  104.     }  
  105.   
  106.     /************************************************************************** 
  107.     * 功能描述：将该向量转变成单位向量 
  108.     * 参数说明： (void) 
  109.     * 返 回 值： 向量长度[注意是未转变之前的长度] 
  110.     **************************************************************************/  
  111.     float32 Normalize()  
  112.     {  
  113.         //获取该向量的长度并验证其有效性  
  114.         float32 length = Length();  
  115.         if (length < b2_epsilon)  
  116.         {  
  117.             return 0.0f;  
  118.         }  
  119.         //获取要转换单位向量的因子,并与x、y轴相乘  
  120.         float32 invLength = 1.0f / length;  
  121.         x *= invLength;  
  122.         y *= invLength;  
  123.   
  124.         return length;  
  125.     }  
  126.     /************************************************************************** 
  127.     * 功能描述：该向量包含的坐标值是否有效 
  128.     * 参数说明： (void) 
  129.     * 返 回 值： 是否有效 
  130.     **************************************************************************/  
  131.     bool IsValid() const  
  132.     {  
  133.         return b2IsValid(x) && b2IsValid(y);  
  134.     }  
  135.     /************************************************************************** 
  136.     * 功能描述：获取斜对称向量(反对称向量),dot(skew_vec, other) == cross(vec, other) 
  137.     * 参数说明： (void) 
  138.     * 返 回 值： 斜对称向量(反对称向量) 
  139.     **************************************************************************/  
  140.     b2Vec2 Skew() const  
  141.     {  
  142.         return b2Vec2(-y, x);  
  143.     }  
  144.     //向量元素的x，y值  
  145.     float32 x, y;  
  146. };  


2、三维列向量的实现
[cpp] view plaincopy
  1. //2d三维列向量  
  2. struct b2Vec3  
  3. {  
  4.     /************************************************************************** 
  5.     * 功能描述：默认构造函数，不做任何事，仅仅为了性能 
  6.     * 参数说明： (void) 
  7.     * 返 回 值： (void) 
  8.     **************************************************************************/  
  9.     b2Vec3() {}  
  10.   
  11.     /************************************************************************** 
  12.     * 功能描述：构造函数，构建使用的坐标 
  13.     * 参数说明： x:x坐标 
  14.                  y:y坐标 
  15.     * 返 回 值： (void) 
  16.     **************************************************************************/  
  17.     b2Vec3(float32 x, float32 y, float32 z) : x(x), y(y), z(z) {}  
  18.   
  19.     /************************************************************************** 
  20.     * 功能描述：将向量置0 
  21.     * 参数说明： (void) 
  22.     * 返 回 值： (void) 
  23.     **************************************************************************/  
  24.     void SetZero() { x = 0.0f; y = 0.0f; z = 0.0f; }  
  25.     /************************************************************************** 
  26.     * 功能描述：将向量设置成指定的坐标 
  27.     * 参数说明： x_:x坐标 
  28.                  y_:y坐标 
  29.                  x_:z坐标 
  30.     * 返 回 值： (void) 
  31.     **************************************************************************/  
  32.     void Set(float32 x_, float32 y_, float32 z_) { x = x_; y = y_; z = z_; }  
  33.   
  34.     /************************************************************************** 
  35.     * 功能描述：将向量取反，重载 - 运算符 
  36.     * 参数说明： (void) 
  37.     * 返 回 值： 一个新的三维向量 
  38.     **************************************************************************/  
  39.     b2Vec3 operator -() const { b2Vec3 v; v.Set(-x, -y, -z); return v; }  
  40.   
  41.     /************************************************************************** 
  42.     * 功能描述：与另一个向量相加 
  43.     * 参数说明： v ：向量的引用 
  44.     * 返 回 值： (void) 
  45.     **************************************************************************/  
  46.     void operator += (const b2Vec3& v)  
  47.     {  
  48.         x += v.x; y += v.y; z += v.z;  
  49.     }  
  50.     /************************************************************************** 
  51.     * 功能描述：与另一个向量相减 
  52.     * 参数说明： v ：向量的引用 
  53.     * 返 回 值： (void) 
  54.     **************************************************************************/  
  55.     void operator -= (const b2Vec3& v)  
  56.     {  
  57.         x -= v.x; y -= v.y; z -= v.z;  
  58.     }  
  59.   
  60.     /************************************************************************** 
  61.     * 功能描述：与一个标量相乘 
  62.     * 参数说明： s  :标量  
  63.     * 返 回 值： (void) 
  64.     **************************************************************************/  
  65.     void operator *= (float32 s)  
  66.     {  
  67.         x *= s; y *= s; z *= s;  
  68.     }  
  69.     //向量的元素值  
  70.     float32 x, y, z;  
  71. };  


二、 矩阵
1、2X2矩阵的实现

[cpp] view plaincopy
  1. //2X2矩阵，存储方式以列为主的顺序  
  2. struct b2Mat22  
  3. {  
  4.     /************************************************************************** 
  5.     * 功能描述：默认构造函数不做任何事情(仅仅为了性能) 
  6.     * 参数说明： (void) 
  7.     * 返 回 值： (void) 
  8.     **************************************************************************/  
  9.     b2Mat22() {}  
  10.     /************************************************************************** 
  11.     * 功能描述：使用列向量构造这个矩阵 
  12.     * 参数说明： c1  ：第一列向量 
  13.                  c2  ：第二列向量 
  14.     * 返 回 值： (void) 
  15.     **************************************************************************/  
  16.     b2Mat22(const b2Vec2& c1, const b2Vec2& c2)  
  17.     {  
  18.         ex = c1;  
  19.         ey = c2;  
  20.     }  
  21.   
  22.     /************************************************************************** 
  23.     * 功能描述：使用标量构造这个矩阵 
  24.     * 参数说明： a11-a22:四个元素值 
  25.     * 返 回 值： (void) 
  26.     **************************************************************************/  
  27.     b2Mat22(float32 a11, float32 a12, float32 a21, float32 a22)  
  28.     {  
  29.         ex.x = a11; ex.y = a21;  
  30.         ey.x = a12; ey.y = a22;  
  31.     }  
  32.   
  33.     /************************************************************************** 
  34.     * 功能描述：使用列实例话这个矩阵 
  35.     * 参数说明： c1:列向量 
  36.                  c2:列向量 
  37.     * 返 回 值： (void) 
  38.     **************************************************************************/  
  39.     void Set(const b2Vec2& c1, const b2Vec2& c2)  
  40.     {  
  41.         ex = c1;  
  42.         ey = c2;  
  43.     }  
  44.     /************************************************************************** 
  45.     * 功能描述：设置成单位矩阵 
  46.     * 参数说明： (void) 
  47.     * 返 回 值： (void) 
  48.     **************************************************************************/  
  49.     void SetIdentity()  
  50.     {  
  51.         ex.x = 1.0f; ey.x = 0.0f;  
  52.         ex.y = 0.0f; ey.y = 1.0f;  
  53.     }  
  54.   
  55.     /************************************************************************** 
  56.     * 功能描述：将该矩阵置0 
  57.     * 参数说明： (void) 
  58.     * 返 回 值： (void) 
  59.     **************************************************************************/  
  60.     void SetZero()  
  61.     {  
  62.         ex.x = 0.0f; ey.x = 0.0f;  
  63.         ex.y = 0.0f; ey.y = 0.0f;  
  64.     }  
  65.     /************************************************************************** 
  66.     * 功能描述：获取逆矩阵, 
  67.                 逆矩阵B = A的伴随矩阵/A的行列式 
  68.                 参照 http://zh.wikipedia.org/wiki/逆矩阵 
  69.     * 参数说明： (void) 
  70.     * 返 回 值： 逆矩阵 
  71.     **************************************************************************/  
  72.     b2Mat22 GetInverse() const  
  73.     {  
  74.         float32 a = ex.x, b = ey.x, c = ex.y, d = ey.y;  
  75.         b2Mat22 B;  
  76.         float32 det = a * d - b * c;                   //获取行列式的值                        
  77.         if (det != 0.0f)  
  78.         {  
  79.             det = 1.0f / det;  
  80.         }  
  81.         B.ex.x =  det * d;  B.ey.x = -det * b;  
  82.         B.ex.y = -det * c;  B.ey.y =  det * a;  
  83.         return B;  
  84.     }  
  85.     /************************************************************************** 
  86.     * 功能描述：解决A*x = b,其中b是一个列向量 
  87.                 这比一次性求反计算更有效率 
  88.     * 参数说明： b : 列向量 
  89.     * 返 回 值： 列向量 
  90.     **************************************************************************/  
  91.     b2Vec2 Solve(const b2Vec2& b) const  
  92.     {  
  93.         float32 a11 = ex.x, a12 = ey.x, a21 = ex.y, a22 = ey.y;  
  94.         //获取行列式的值  
  95.         float32 det = a11 * a22 - a12 * a21;         
  96.         if (det != 0.0f)  
  97.         {  
  98.             det = 1.0f / det;  
  99.         }  
  100.         b2Vec2 x;  
  101.         //[ a22 -a12] * [b.x] = [a22 * b.x - a12*b.y]   
  102.         //[-a21  a11]   [b.y]   [a11 * b.y - a21*b.x]  
  103.         x.x = det * (a22 * b.x - a12 * b.y);  
  104.         x.y = det * (a11 * b.y - a21 * b.x);  
  105.         return x;  
  106.     }  
  107.     //两个列向量  
  108.     b2Vec2 ex, ey;  
  109. };  

2、3X3矩阵的实现

[cpp] view plaincopy
  1. //3X3矩阵，存储方式以列为主的顺序  
  2. struct b2Mat33  
  3. {  
  4.     /************************************************************************** 
  5.     * 功能描述：默认构造函数不做任何事情(仅仅为了性能) 
  6.     * 参数说明： (void) 
  7.     * 返 回 值： (void) 
  8.     **************************************************************************/  
  9.     b2Mat33() {}  
  10.   
  11.     /************************************************************************** 
  12.     * 功能描述：使用列向量构造这个矩阵 
  13.     * 参数说明： c1  ：第一列向量 
  14.                  c2  ：第二列向量 
  15.     * 返 回 值： (void) 
  16.     **************************************************************************/  
  17.     b2Mat33(const b2Vec3& c1, const b2Vec3& c2, const b2Vec3& c3)  
  18.     {  
  19.         ex = c1;  
  20.         ey = c2;  
  21.         ez = c3;  
  22.     }  
  23.   
  24.     /************************************************************************** 
  25.     * 功能描述：将该矩阵置0 
  26.     * 参数说明： (void) 
  27.     * 返 回 值： (void) 
  28.     **************************************************************************/  
  29.     void SetZero()  
  30.     {  
  31.         ex.SetZero();  
  32.         ey.SetZero();  
  33.         ez.SetZero();  
  34.     }  
  35.   
  36.     /************************************************************************** 
  37.     * 功能描述：解决A*x = b,其中b是一个三维列向量 
  38.                 这比一次性求反计算更有效率 
  39.     * 参数说明： b : 三维列向量 
  40.     * 返 回 值： 三维列向量 
  41.     **************************************************************************/  
  42.     b2Vec3 Solve33(const b2Vec3& b) const;  
  43.     /************************************************************************** 
  44.     * 功能描述：解决A*x = b,其中b是一个二维列向量 
  45.                 这比一次性求反计算更有效率 
  46.                 仅仅解决2X2的矩阵等式 
  47.     * 参数说明： b : 三维列向量 
  48.     * 返 回 值： 三维列向量 
  49.     **************************************************************************/  
  50.     b2Vec2 Solve22(const b2Vec2& b) const;  
  51.     /************************************************************************** 
  52.     * 功能描述：获取2X2的逆矩阵, 
  53.                 如果出现异常则置为0矩阵 
  54.                 逆矩阵B = A的伴随矩阵/A的行列式 
  55.     * 参数说明： (void) 
  56.     * 返 回 值： (void) 
  57.     **************************************************************************/  
  58.     void GetInverse22(b2Mat33* M) const;  
  59.     /************************************************************************** 
  60.     * 功能描述：获取3X3的对称逆矩阵 
  61.                 如果出现异常则置为0矩阵 
  62.     * 参数说明： (void) 
  63.     * 返 回 值： (void) 
  64.     **************************************************************************/  
  65.     void GetSymInverse33(b2Mat33* M) const;  
  66.     //矩阵的3个列向量  
  67.     b2Vec3 ex, ey, ez;  
  68. };  

在ccp文件中Mat33结构部分函数的实现：

[cpp] view plaincopy
  1. //解决 A * x =b,其中b是列向量  
  2. b2Vec3 b2Mat33::Solve33(const b2Vec3& b) const  
  3. {  
  4.     float32 det = b2Dot(ex, b2Cross(ey, ez));  
  5.     if (det != 0.0f)  
  6.     {  
  7.         det = 1.0f / det;  
  8.     }  
  9.     b2Vec3 x;  
  10.     x.x = det * b2Dot(b, b2Cross(ey, ez));  
  11.     x.y = det * b2Dot(ex, b2Cross(b, ez));  
  12.     x.z = det * b2Dot(ex, b2Cross(ey, b));  
  13.     return x;  
  14. }  
  15. //解决 A * x =b,其中b是列向量  
  16. b2Vec2 b2Mat33::Solve22(const b2Vec2& b) const  
  17. {  
  18.     float32 a11 = ex.x, a12 = ey.x, a21 = ex.y, a22 = ey.y;  
  19.     float32 det = a11 * a22 - a12 * a21;  
  20.     if (det != 0.0f)  
  21.     {  
  22.         det = 1.0f / det;  
  23.     }  
  24.     b2Vec2 x;  
  25.     x.x = det * (a22 * b.x - a12 * b.y);  
  26.     x.y = det * (a11 * b.y - a21 * b.x);  
  27.     return x;  
  28. }  
  29.   
  30. //获取2X2的逆矩阵  
  31. //如果出现异常则置为0矩阵  
  32. void b2Mat33::GetInverse22(b2Mat33* M) const  
  33. {  
  34.     float32 a = ex.x, b = ey.x, c = ex.y, d = ey.y;  
  35.     float32 det = a * d - b * c;  
  36.     if (det != 0.0f)  
  37.     {  
  38.         det = 1.0f / det;  
  39.     }  
  40.   
  41.     M->ex.x =  det * d;  M->ey.x = -det * b; M->ex.z = 0.0f;  
  42.     M->ex.y = -det * c;  M->ey.y =  det * a; M->ey.z = 0.0f;  
  43.     M->ez.x = 0.0f; M->ez.y = 0.0f; M->ez.z = 0.0f;  
  44. }  
  45. //获取3X3的对称矩阵的逆矩阵，如果出现异常则置为0矩阵  
  46. void b2Mat33::GetSymInverse33(b2Mat33* M) const  
  47. {  
  48.     float32 det = b2Dot(ex, b2Cross(ey, ez));  
  49.     if (det != 0.0f)  
  50.     {  
  51.         det = 1.0f / det;  
  52.     }  
  53.   
  54.     float32 a11 = ex.x, a12 = ey.x, a13 = ez.x;  
  55.     float32 a22 = ey.y, a23 = ez.y;  
  56.     float32 a33 = ez.z;  
  57.   
  58.     M->ex.x = det * (a22 * a33 - a23 * a23);  
  59.     M->ex.y = det * (a13 * a23 - a12 * a33);  
  60.     M->ex.z = det * (a12 * a23 - a13 * a22);  
  61.   
  62.     M->ey.x = M->ex.y;  
  63.     M->ey.y = det * (a11 * a33 - a13 * a13);  
  64.     M->ey.z = det * (a13 * a12 - a11 * a23);  
  65.   
  66.     M->ez.x = M->ex.z;  
  67.     M->ez.y = M->ey.z;  
  68.     M->ez.z = det * (a11 * a22 - a12 * a12);  
  69. }  


三、旋度、转换、扫描部分
1、旋度的实现

[cpp] view plaincopy
  1. //旋度 http://zh.wikipedia.org/wiki/旋度  
  2. struct b2Rot  
  3. {  
  4.     /************************************************************************** 
  5.     * 功能描述：默认构造函数不做任何事情(仅仅为了性能) 
  6.     * 参数说明： (void) 
  7.     * 返 回 值： (void) 
  8.     **************************************************************************/  
  9.     b2Rot() {}  
  10.     /************************************************************************** 
  11.     * 功能描述：用角的弧度初始化 
  12.     * 参数说明： anlge:弧度值 
  13.     * 返 回 值： (void) 
  14.     **************************************************************************/  
  15.     explicit b2Rot(float32 angle)  
  16.     {  
  17.         /// TODO_ERIN optimize  
  18.         s = sinf(angle);  
  19.         c = cosf(angle);  
  20.     }  
  21.     /************************************************************************** 
  22.     * 功能描述：用角的弧度设置 
  23.     * 参数说明： anlge:弧度值 
  24.     * 返 回 值： (void) 
  25.     **************************************************************************/  
  26.     void Set(float32 angle)  
  27.     {  
  28.         /// TODO_ERIN optimize  
  29.         s = sinf(angle);  
  30.         c = cosf(angle);  
  31.     }  
  32.     /************************************************************************** 
  33.     * 功能描述：设置成单位旋度 
  34.     * 参数说明： (void) 
  35.     * 返 回 值： (void) 
  36.     **************************************************************************/  
  37.     void SetIdentity()  
  38.     {  
  39.         s = 0.0f;  
  40.         c = 1.0f;  
  41.     }  
  42.     /************************************************************************** 
  43.     * 功能描述：用弧度得到角度 
  44.     * 参数说明： (void) 
  45.     * 返 回 值： 角度值 
  46.     **************************************************************************/  
  47.     float32 GetAngle() const  
  48.     {  
  49.         return b2Atan2(s, c);  
  50.     }  
  51.     /************************************************************************** 
  52.     * 功能描述：获取x-axis 
  53.     * 参数说明： (void) 
  54.     * 返 回 值： 列向量 
  55.     **************************************************************************/  
  56.     b2Vec2 GetXAxis() const  
  57.     {  
  58.         return b2Vec2(c, s);  
  59.     }  
  60.     /************************************************************************** 
  61.     * 功能描述：获取u-axis 
  62.     * 参数说明： (void) 
  63.     * 返 回 值： 列向量 
  64.     **************************************************************************/  
  65.     b2Vec2 GetYAxis() const  
  66.     {  
  67.         return b2Vec2(-s, c);  
  68.     }  
  69.   
  70.     //定义sin和cos  
  71.     float32 s, c;  
  72. };  

2、变换的实现

[cpp] view plaincopy
  1. ///变换包括平移和旋度，它是用来表示位置和精确方向的框架  
  2. struct b2Transform  
  3. {  
  4.     /************************************************************************** 
  5.     * 功能描述：默认构造函数，什么都不做 
  6.     * 参数说明： (void) 
  7.     * 返 回 值： (void) 
  8.     **************************************************************************/  
  9.     b2Transform() {}  
  10.     /************************************************************************** 
  11.     * 功能描述：用一个位置向量和一个旋度进行初始化 
  12.     * 参数说明： position ：位置向量 
  13.                  rotation ：旋度 
  14.     * 返 回 值： (void) 
  15.     **************************************************************************/  
  16.     b2Transform(const b2Vec2& position, const b2Rot& rotation) : p(position), q(rotation) {}  
  17.   
  18.     /************************************************************************** 
  19.     * 功能描述：设置单位变换 
  20.     * 参数说明： (void) 
  21.     * 返 回 值： (void) 
  22.     **************************************************************************/  
  23.     void SetIdentity()  
  24.     {  
  25.         p.SetZero();  
  26.         q.SetIdentity();  
  27.     }  
  28.     /************************************************************************** 
  29.     * 功能描述：基于角的弧度和位置设置 
  30.     * 参数说明： position：位置向量 
  31.                  angle   ：角的弧度 
  32.     * 返 回 值： (void) 
  33.     **************************************************************************/  
  34.     void Set(const b2Vec2& position, float32 angle)  
  35.     {  
  36.         p = position;  
  37.         q.Set(angle);  
  38.     }  
  39.     //成员变量，一个向量和一个旋度  
  40.     b2Vec2 p;  
  41.     b2Rot q;  
  42. };  

3、扫描的实现

[cpp] view plaincopy
  1. //描述运动的body/shape的TOI(Time of Impact)的计算。  
  2. //形状相对于主体原点定义的，这可能没有一致的原点。  
  3. //但是，为了支持动态我们必须篡改质心位置  
  4. struct b2Sweep  
  5. {  
  6.     /************************************************************************** 
  7.     * 功能描述：在特定时间里获得窜改变换 
  8.     * 参数说明： xfb   :变换的指针 
  9.                  beta  :一个因子，在[0,1]之间，0表示alpha0 
  10.     * 返 回 值： (void) 
  11.     **************************************************************************/  
  12.     void GetTransform(b2Transform* xfb, float32 beta) const;  
  13.     /************************************************************************** 
  14.     * 功能描述：推进缓慢向前移动，产生一个新的初始状态 
  15.     * 参数说明：alpha:新的初始时间 
  16.     * 返 回 值： (void) 
  17.     **************************************************************************/  
  18.     void Advance(float32 alpha);  
  19.     /************************************************************************** 
  20.     * 功能描述：标准化角度 
  21.     * 参数说明： (void) 
  22.     * 返 回 值： (void) 
  23.     **************************************************************************/  
  24.     void Normalize();  
  25.   
  26.     b2Vec2 localCenter; ///质心位置  
  27.     b2Vec2 c0, c;       ///世界的中心位置  
  28.     float32 a0, a;      ///世界角度  
  29.     //分数，当前时间步长，范围[0,1]之间  
  30.     float32 alpha0;  
  31. };  


四、 其它
在b2Math.h的开始部分

[cpp] view plaincopy
  1. /************************************************************************** 
  2. * 功能描述：用来确保一个浮点数不是一个NaN或无穷大 
  3. * 参数说明： x :数值 
  4. * 返 回 值： true ：有效 
  5.              false: 无效 
  6. **************************************************************************/  
  7. inline bool b2IsValid(float32 x)  
  8. {  
  9.     if (x != x)  
  10.     {  
  11.         // NaN.  
  12.         return false;  
  13.     }  
  14.   
  15.     float32 infinity = std::numeric_limits<float32>::infinity();  
  16.     return -infinity < x && x < infinity;  
  17. }  
  18.   
  19. /************************************************************************** 
  20. * 功能描述：一个近似且快速的平方根倒数算法[x^ (-1/2) ] 
  21.             可以参照 http://zh.wikipedia.org/wiki/平方根倒数速算法 
  22.             或 http://en.wikipedia.org/wiki/Fast_inverse_square_root 
  23. * 参数说明： x :数值 
  24. * 返 回 值： 平方根倒数 
  25. **************************************************************************/  
  26. inline float32 b2InvSqrt(float32 x)  
  27. {  
  28.     union  
  29.     {  
  30.         float32 x;  
  31.         int32 i;  
  32.     } convert;  
  33.   
  34.     convert.x = x;  
  35.     float32 xhalf = 0.5f * x;  
  36.     convert.i = 0x5f3759df - (convert.i >> 1);  
  37.     x = convert.x;  
  38.     x = x * (1.5f - xhalf * x * x);                  //第一次牛顿迭代  
  39.     return x;  
  40. }  
  41. //平方根宏  
  42. #define b2Sqrt(x)   std::sqrt(x)  
  43. //对于任意不同时等于0的实参数x和y，  
  44. //atan2(y,x)所表达的意思是坐标原点为起点，  
  45. //指向(y,x)的射线在坐标平面上与x轴正方向之间的角的角度度  
  46. //参照 http://zh.wikipedia.org/wiki/Atan2  
  47. #define b2Atan2(y, x)   std::atan2(y, x)  
  48. /************************************************************************** 
  49. * 功能描述：计算两个向量的点积,注：a = b时，表示向量长度的平方 
  50. * 参数说明： a :二维列向量 
  51.              b :二维列向量 
  52. * 返 回 值： 点积值 
  53. **************************************************************************/  
  54. inline float32 b2Dot(const b2Vec2& a, const b2Vec2& b)  
  55. {  
  56.     return a.x * b.x + a.y * b.y;  
  57. }  
  58.   
  59. /************************************************************************** 
  60. * 功能描述：计算两个向量的叉积，在2d中这是一个标量 
  61. * 参数说明： a :二维列向量 
  62.              b :二维列向量 
  63. * 返 回 值： 叉积值 
  64. **************************************************************************/  
  65. inline float32 b2Cross(const b2Vec2& a, const b2Vec2& b)  
  66. {  
  67.     return a.x * b.y - a.y * b.x;  
  68. }  

结尾部分：

[cpp] view plaincopy
  1. /************************************************************************** 
  2. * 功能描述：计算向量和标量的叉积 
  3. * 参数说明： a :二维列向量 
  4.              s :标量 
  5. * 返 回 值： 二维列向量 
  6. **************************************************************************/  
  7. inline b2Vec2 b2Cross(const b2Vec2& a, float32 s)  
  8. {  
  9.     return b2Vec2(s * a.y, -s * a.x);  
  10. }  
  11.   
  12. /************************************************************************** 
  13. * 功能描述：计算标量和向量的叉积 
  14. * 参数说明： s :标量 
  15.              a :二维列向量 
  16. * 返 回 值： 二维列向量 
  17. **************************************************************************/  
  18. inline b2Vec2 b2Cross(float32 s, const b2Vec2& a)  
  19. {  
  20.     return b2Vec2(-s * a.y, s * a.x);  
  21. }  
  22.   
  23. /************************************************************************** 
  24. * 功能描述：一个矩阵乘以一个向量 
  25. * 参数说明： a :2X2矩阵 
  26.              v :二维列向量 
  27. * 返 回 值： 二维列向量 
  28. **************************************************************************/  
  29. inline b2Vec2 b2Mul(const b2Mat22& A, const b2Vec2& v)  
  30. {  
  31.     return b2Vec2(A.ex.x * v.x + A.ey.x * v.y, A.ex.y * v.x + A.ey.y * v.y);  
  32. }  
  33.   
  34. /************************************************************************** 
  35. * 功能描述：一个转置矩阵乘以一个向量 
  36. * 参数说明： a :2X2矩阵 
  37.              v :二维列向量 
  38. * 返 回 值： 二维列向量 
  39. **************************************************************************/  
  40. inline b2Vec2 b2MulT(const b2Mat22& A, const b2Vec2& v)  
  41. {  
  42.     return b2Vec2(b2Dot(v, A.ex), b2Dot(v, A.ey));  
  43. }  
  44.   
  45. /************************************************************************** 
  46. * 功能描述：计算两个向量按分量逐个相加 
  47. * 参数说明： a :二维列向量 
  48.              b :二维列向量 
  49. * 返 回 值： 二维列向量 
  50. **************************************************************************/  
  51. inline b2Vec2 operator + (const b2Vec2& a, const b2Vec2& b)  
  52. {  
  53.     return b2Vec2(a.x + b.x, a.y + b.y);  
  54. }  
  55.   
  56. /************************************************************************** 
  57. * 功能描述：计算两个向量按分量逐个相减 
  58. * 参数说明： a :二维列向量 
  59.              b :二维列向量 
  60. * 返 回 值： 二维列向量 
  61. **************************************************************************/  
  62. inline b2Vec2 operator - (const b2Vec2& a, const b2Vec2& b)  
  63. {  
  64.     return b2Vec2(a.x - b.x, a.y - b.y);  
  65. }  
  66. /************************************************************************** 
  67. * 功能描述： 计算标量和向量相乘 
  68. * 参数说明： s :标量 
  69.              a :二维列向量 
  70. * 返 回 值： 二维列向量 
  71. **************************************************************************/  
  72. inline b2Vec2 operator * (float32 s, const b2Vec2& a)  
  73. {  
  74.     return b2Vec2(s * a.x, s * a.y);  
  75. }  
  76. /************************************************************************** 
  77. * 功能描述： 判断两个向量是否相等 
  78. * 参数说明： a :二维列向量 
  79.              b :二维列向量 
  80. * 返 回 值： true ：相等 
  81.              flase：不相等 
  82. **************************************************************************/  
  83. inline bool operator == (const b2Vec2& a, const b2Vec2& b)  
  84. {  
  85.     return a.x == b.x && a.y == b.y;  
  86. }  
  87. /************************************************************************** 
  88. * 功能描述： 计算两向量之间的距离 
  89. * 参数说明： a :二维列向量 
  90.              b :二维列向量 
  91. * 返 回 值： 距离 
  92. **************************************************************************/  
  93. inline float32 b2Distance(const b2Vec2& a, const b2Vec2& b)  
  94. {  
  95.     b2Vec2 c = a - b;  
  96.     return c.Length();  
  97. }  
  98. /************************************************************************** 
  99. * 功能描述： 获取两向量之间距离的平方 
  100. * 参数说明： a :二维列向量 
  101.              b :二维列向量 
  102. * 返 回 值： 距离的平方 
  103. **************************************************************************/  
  104. inline float32 b2DistanceSquared(const b2Vec2& a, const b2Vec2& b)  
  105. {  
  106.     b2Vec2 c = a - b;  
  107.     return b2Dot(c, c);     
  108. }  
  109. /************************************************************************** 
  110. * 功能描述： 一个标量和一个3维列向量相乘 
  111. * 参数说明： s :标量 
  112.              a :三维列向量 
  113. * 返 回 值： 三维列向量 
  114. **************************************************************************/  
  115. inline b2Vec3 operator * (float32 s, const b2Vec3& a)  
  116. {  
  117.     return b2Vec3(s * a.x, s * a.y, s * a.z);  
  118. }  
  119.   
  120. /************************************************************************** 
  121. * 功能描述： 计算两个向量按分量逐个相加 
  122. * 参数说明： a :三维列向量 
  123.              b :三维列向量 
  124. * 返 回 值： 三维列向量 
  125. **************************************************************************/  
  126. inline b2Vec3 operator + (const b2Vec3& a, const b2Vec3& b)  
  127. {  
  128.     return b2Vec3(a.x + b.x, a.y + b.y, a.z + b.z);  
  129. }  
  130. /************************************************************************** 
  131. * 功能描述： 计算两个向量按分量逐个相减 
  132. * 参数说明： a :三维列向量 
  133.              b :三维列向量 
  134. * 返 回 值： 三维列向量 
  135. **************************************************************************/  
  136. inline b2Vec3 operator - (const b2Vec3& a, const b2Vec3& b)  
  137. {  
  138.     return b2Vec3(a.x - b.x, a.y - b.y, a.z - b.z);  
  139. }  
  140. /************************************************************************** 
  141. * 功能描述： 计算两个向量的点积 
  142. * 参数说明： a :三维列向量 
  143.              b :三维列向量 
  144. * 返 回 值： 点积值 
  145. **************************************************************************/  
  146. inline float32 b2Dot(const b2Vec3& a, const b2Vec3& b)  
  147. {  
  148.     return a.x * b.x + a.y * b.y + a.z * b.z;  
  149. }  
  150. /************************************************************************** 
  151. * 功能描述： 计算两个相邻的叉积 
  152. * 参数说明： a :三维列向量 
  153.              b :三维列向量 
  154. * 返 回 值： 三维列向量 
  155. **************************************************************************/  
  156. inline b2Vec3 b2Cross(const b2Vec3& a, const b2Vec3& b)  
  157. {  
  158.     return b2Vec3(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);  
  159. }  
  160. /************************************************************************** 
  161. * 功能描述： 计算两个2X2矩阵相加 
  162. * 参数说明： a :2X2矩阵 
  163.              b :2X2矩阵 
  164. * 返 回 值： 2X2矩阵 
  165. **************************************************************************/  
  166. inline b2Mat22 operator + (const b2Mat22& A, const b2Mat22& B)  
  167. {  
  168.     return b2Mat22(A.ex + B.ex, A.ey + B.ey);  
  169. }  
  170. /************************************************************************** 
  171. * 功能描述： 计算两个2X2矩阵相乘 
  172. * 参数说明： a :2X2矩阵 
  173.              b :2X2矩阵 
  174. * 返 回 值： 2X2矩阵 
  175. **************************************************************************/  
  176. inline b2Mat22 b2Mul(const b2Mat22& A, const b2Mat22& B)  
  177. {  
  178.     return b2Mat22(b2Mul(A, B.ex), b2Mul(A, B.ey));  
  179. }  
  180.   
  181. /************************************************************************** 
  182. * 功能描述： 计算一个转置矩阵和矩阵相乘 
  183. * 参数说明： a :2X2矩阵 
  184.              b :2X2矩阵 
  185. * 返 回 值： 2X2矩阵 
  186. **************************************************************************/  
  187. inline b2Mat22 b2MulT(const b2Mat22& A, const b2Mat22& B)  
  188. {  
  189.     b2Vec2 c1(b2Dot(A.ex, B.ex), b2Dot(A.ey, B.ex));  
  190.     b2Vec2 c2(b2Dot(A.ex, B.ey), b2Dot(A.ey, B.ey));  
  191.     return b2Mat22(c1, c2);  
  192. }  
  193.   
  194. /************************************************************************** 
  195. * 功能描述： 计算一个矩阵和向量相乘 
  196. * 参数说明： a :3X3矩阵 
  197.              v :三维列向量 
  198. * 返 回 值： 三维列向量 
  199. **************************************************************************/  
  200. inline b2Vec3 b2Mul(const b2Mat33& A, const b2Vec3& v)  
  201. {  
  202.     return v.x * A.ex + v.y * A.ey + v.z * A.ez;  
  203. }  
  204.   
  205. /************************************************************************** 
  206. * 功能描述： 计算一个矩阵和二维列向量相乘 
  207. * 参数说明： a :3X3矩阵 
  208.              v :二维列向量 
  209. * 返 回 值： 二维列向量 
  210. **************************************************************************/  
  211. inline b2Vec2 b2Mul22(const b2Mat33& A, const b2Vec2& v)  
  212. {  
  213.     return b2Vec2(A.ex.x * v.x + A.ey.x * v.y, A.ex.y * v.x + A.ey.y * v.y);  
  214. }  
  215. /************************************************************************** 
  216. * 功能描述： 计算两个旋度的乘积 
  217. * 参数说明： q :旋度 
  218.              r :旋度 
  219. * 返 回 值： 旋度 
  220. **************************************************************************/  
  221. inline b2Rot b2Mul(const b2Rot& q, const b2Rot& r)  
  222. {  
  223.     // [qc -qs] * [rc -rs] = [qc*rc-qs*rs -qc*rs-qs*rc]  
  224.     // [qs  qc]   [rs  rc]   [qs*rc+qc*rs -qs*rs+qc*rc]  
  225.     // s = qs * rc + qc * rs  
  226.     // c = qc * rc - qs * rs  
  227.     b2Rot qr;  
  228.     qr.s = q.s * r.c + q.c * r.s;  
  229.     qr.c = q.c * r.c - q.s * r.s;  
  230.     return qr;  
  231. }  
  232.   
  233. /************************************************************************** 
  234. * 功能描述： 计算一个转置旋度和一个旋度的乘积 
  235. * 参数说明： q :旋度 
  236.              r :旋度 
  237. * 返 回 值： 旋度 
  238. **************************************************************************/  
  239. inline b2Rot b2MulT(const b2Rot& q, const b2Rot& r)  
  240. {  
  241.     // [ qc qs] * [rc -rs] = [qc*rc+qs*rs -qc*rs+qs*rc]  
  242.     // [-qs qc]   [rs  rc]   [-qs*rc+qc*rs qs*rs+qc*rc]  
  243.     // s = qc * rs - qs * rc  
  244.     // c = qc * rc + qs * rs  
  245.     b2Rot qr;  
  246.     qr.s = q.c * r.s - q.s * r.c;  
  247.     qr.c = q.c * r.c + q.s * r.s;  
  248.     return qr;  
  249. }  
  250.   
  251. /************************************************************************** 
  252. * 功能描述： 旋转一个向量 
  253. * 参数说明： q :旋度 
  254.              v :向量 
  255. * 返 回 值： 二维列向量 
  256. **************************************************************************/  
  257. inline b2Vec2 b2Mul(const b2Rot& q, const b2Vec2& v)  
  258. {  
  259.     // [qc -qs] * [vx] = [qc*vx-qs*vy qs*vx+qc*vy]  
  260.     // [qs  qc]   [vy]     
  261.     return b2Vec2(q.c * v.x - q.s * v.y, q.s * v.x + q.c * v.y);  
  262. }  
  263.   
  264. /************************************************************************** 
  265. * 功能描述： 反旋转一个向量 
  266. * 参数说明： q :旋度 
  267.              v :向量 
  268. * 返 回 值： 二维列向量 
  269. **************************************************************************/  
  270. inline b2Vec2 b2MulT(const b2Rot& q, const b2Vec2& v)  
  271. {  
  272.     // [ qc  qs] * [vx] = [qc*vx+qs*vy -qs*vx+qc*vy]  
  273.     // [-qs  qc]   [vy]     
  274.     return b2Vec2(q.c * v.x + q.s * v.y, -q.s * v.x + q.c * v.y);  
  275. }  
  276. /************************************************************************** 
  277. * 功能描述： 变换一个向量 
  278. * 参数说明： T :变换 
  279.              v :向量 
  280. * 返 回 值： 二维列向量 
  281. **************************************************************************/  
  282. inline b2Vec2 b2Mul(const b2Transform& T, const b2Vec2& v)  
  283. {  
  284.     // [qc -qs] * [vx]  = [qc*vx-qs*vy qs*vx+qc*vy]  
  285.     // [qs  qc]   [vy]    
  286.     float32 x = (T.q.c * v.x - T.q.s * v.y) + T.p.x;  
  287.     float32 y = (T.q.s * v.x + T.q.c * v.y) + T.p.y;  
  288.   
  289.     return b2Vec2(x, y);  
  290. }  
  291. /************************************************************************** 
  292. * 功能描述： 反变换一个向量 
  293. * 参数说明： T :变换 
  294.              v :向量 
  295. * 返 回 值： 二维列向量 
  296. **************************************************************************/  
  297. inline b2Vec2 b2MulT(const b2Transform& T, const b2Vec2& v)  
  298. {  
  299.     //( [vx] - [tpx] ) *[ qc qs] = [vx - tpx] *[ qc qs]  
  300.     //( [vy]   [tpy] )  [-qs qc]   [vy - tpy]  [-qs qc]  
  301.     float32 px = v.x - T.p.x;  
  302.     float32 py = v.y - T.p.y;  
  303.     float32 x = (T.q.c * px + T.q.s * py);  
  304.     float32 y = (-T.q.s * px + T.q.c * py);  
  305.   
  306.     return b2Vec2(x, y);  
  307. }  
  308.   
  309. /************************************************************************** 
  310. * 功能描述： 变换一个变换 
  311.              v2 = A.q.Rot(B.q.Rot(v1) + B.p) + A.p     
  312.              = (A.q * B.q).Rot(v1) + A.q.Rot(B.p) + A.p 
  313. * 参数说明： a :变换 
  314.              b :变换 
  315. * 返 回 值： 变换 
  316. **************************************************************************/  
  317. inline b2Transform b2Mul(const b2Transform& A, const b2Transform& B)  
  318. {  
  319.     b2Transform C;  
  320.     C.q = b2Mul(A.q, B.q);  
  321.     C.p = b2Mul(A.q, B.p) + A.p;  
  322.     return C;  
  323. }  
  324.   
  325. /************************************************************************** 
  326. * 功能描述：反变换一个变换 
  327.             v2 = A.q' * (B.q * v1 + B.p - A.p) 
  328.             = A.q' * B.q * v1 + A.q' * (B.p - A.p) 
  329. * 参数说明： a：变换 
  330.              b:变换 
  331. * 返 回 值： 变换 
  332. ***************************************************************************/  
  333. inline b2Transform b2MulT(const b2Transform& A, const b2Transform& B)  
  334. {  
  335.     b2Transform C;  
  336.     C.q = b2MulT(A.q, B.q);  
  337.     C.p = b2MulT(A.q, B.p - A.p);  
  338.     return C;  
  339. }  
  340.   
  341. /************************************************************************** 
  342. * 功能描述：取绝对值函数 
  343. * 参数说明： a：标量  
  344. * 返 回 值： 标量 
  345. ***************************************************************************/  
  346. template <typename T>  
  347. inline T b2Abs(T a)  
  348. {  
  349.     return a > T(0) ? a : -a;  
  350. }  
  351. /************************************************************************** 
  352. * 功能描述：取向量的绝对值 
  353. * 参数说明： A：二维列向量 
  354. * 返 回 值： 二维列向量 
  355. ***************************************************************************/  
  356. inline b2Vec2 b2Abs(const b2Vec2& a)  
  357. {  
  358.     return b2Vec2(b2Abs(a.x), b2Abs(a.y));  
  359. }  
  360. /************************************************************************** 
  361. * 功能描述：取2X2矩阵的绝对值 
  362. * 参数说明： A：2X2矩阵 
  363. * 返 回 值： 2X2矩阵 
  364. ***************************************************************************/  
  365. inline b2Mat22 b2Abs(const b2Mat22& A)  
  366. {  
  367.     return b2Mat22(b2Abs(A.ex), b2Abs(A.ey));  
  368. }  
  369. /************************************************************************** 
  370. * 功能描述：获得最小值函数 
  371. * 参数说明： a : 标量 
  372.              b : 标量 
  373. * 返 回 值： 标量 
  374. ***************************************************************************/  
  375. template <typename T>  
  376. inline T b2Min(T a, T b)  
  377. {  
  378.     return a < b ? a : b;  
  379. }  
  380. /************************************************************************** 
  381. * 功能描述：获得最小向量值 
  382. * 参数说明： a : 二维向量 
  383.              b : 二维向量 
  384. * 返 回 值： 二维向量 
  385. ***************************************************************************/  
  386. inline b2Vec2 b2Min(const b2Vec2& a, const b2Vec2& b)  
  387. {  
  388.     return b2Vec2(b2Min(a.x, b.x), b2Min(a.y, b.y));  
  389. }  
  390.   
  391. /************************************************************************** 
  392. * 功能描述：获得最大值函数 
  393. * 参数说明： a : 标量 
  394.              b : 标量 
  395. * 返 回 值： 标量 
  396. ***************************************************************************/  
  397. template <typename T>  
  398. inline T b2Max(T a, T b)  
  399. {  
  400.     return a > b ? a : b;  
  401. }  
  402.   
  403. /************************************************************************** 
  404. * 功能描述：获得最大向量值 
  405. * 参数说明： a : 二维向量 
  406.              b : 二维向量 
  407. * 返 回 值： 二维向量 
  408. ***************************************************************************/  
  409. inline b2Vec2 b2Max(const b2Vec2& a, const b2Vec2& b)  
  410. {  
  411.     return b2Vec2(b2Max(a.x, b.x), b2Max(a.y, b.y));  
  412. }  
  413. /************************************************************************** 
  414. * 功能描述：获得low到high之间的值 
  415. * 参数说明： a ，low,high:都是标量 
  416. * 返 回 值： 标量 
  417. ***************************************************************************/  
  418. template <typename T>  
  419. inline T b2Clamp(T a, T low, T high)  
  420. {  
  421.     return b2Max(low, b2Min(a, high));  
  422. }  
  423. /************************************************************************** 
  424. * 功能描述：获得两向量之间的向量 
  425. * 参数说明： a ，low,high:都是二维向量 
  426. * 返 回 值： 二维向量 
  427. ***************************************************************************/  
  428. inline b2Vec2 b2Clamp(const b2Vec2& a, const b2Vec2& low, const b2Vec2& high)  
  429. {  
  430.     return b2Max(low, b2Min(a, high));  
  431. }  
  432. /************************************************************************** 
  433. * 功能描述：交换两个标量 
  434. * 参数说明： (void) 
  435. * 返 回 值： (void) 
  436. **************************************************************************/  
  437. template<typename T>   
  438. inline void b2Swap(T& a, T& b)  
  439. {  
  440.     T tmp = a;  
  441.     a = b;  
  442.     b = tmp;  
  443. }  
  444.   
  445. /************************************************************************** 
  446. * 功能描述：下一个最大2的幂 
  447.             给你一个二进制整数x。 
  448.             通过swar算法计算出下一个最大2的幂 
  449.             递归的折叠高位bit到低位中去。 
  450. * 参数说明： x:需要判断的值 
  451. * 返 回 值： (void) 
  452. **************************************************************************/  
  453. inline uint32 b2NextPowerOfTwo(uint32 x)  
  454. {  
  455.     x |= (x >> 1);  
  456.     x |= (x >> 2);  
  457.     x |= (x >> 4);  
  458.     x |= (x >> 8);  
  459.     x |= (x >> 16);  
  460.     return x + 1;  
  461. }  
  462.   
  463. /************************************************************************** 
  464. * 功能描述：判断是否是2的幂 
  465. * 参数说明： x:需要判断的值 
  466. * 返 回 值： (void) 
  467. **************************************************************************/  
  468. inline bool b2IsPowerOfTwo(uint32 x)  
  469. {  
  470.     bool result = x > 0 && (x & (x - 1)) == 0;  
  471.     return result;  
  472. }  
  473. /************************************************************************** 
  474. * 功能描述：在特定时间里获得窜改变换 
  475. * 参数说明： xfb   :变换的指针 
  476.              beta  :一个因子，在[0,1]之间，0表示alpha0 
  477. * 返 回 值： (void) 
  478. **************************************************************************/  
  479. inline void b2Sweep::GetTransform(b2Transform* xf, float32 beta) const  
  480. {  
  481.     xf->p = (1.0f - beta) * c0 + beta * c;  
  482.     float32 angle = (1.0f - beta) * a0 + beta * a;  
  483.     xf->q.Set(angle);  
  484.   
  485.     // Shift to origin  
  486.     xf->p -= b2Mul(xf->q, localCenter);  
  487. }  
  488. /************************************************************************** 
  489. * 功能描述：推进缓慢向前移动，产生一个新的初始状态 
  490. * 参数说明：alpha:新的初始时间 
  491. * 返 回 值： (void) 
  492. **************************************************************************/  
  493. inline void b2Sweep::Advance(float32 alpha)  
  494. {  
  495.     b2Assert(alpha0 < 1.0f);  
  496.     float32 beta = (alpha - alpha0) / (1.0f - alpha0);  
  497.     c0 = (1.0f - beta) * c0 + beta * c;  
  498.     a0 = (1.0f - beta) * a0 + beta * a;  
  499.     alpha0 = alpha;  
  500. }  
  501.   
  502. /************************************************************************** 
  503. * 功能描述：标准化角（以弧度为单位）在-pi和pi之间 
  504. * 参数说明：alpha:新的初始时间 
  505. * 返 回 值： (void) 
  506. **************************************************************************/  
  507. inline void b2Sweep::Normalize()  
  508. {  
  509.     float32 twoPi = 2.0f * b2_pi;  
  510.     float32 d =  twoPi * floorf(a0 / twoPi);  
  511.     a0 -= d;  
  512.     a -= d;  
  513. }  

还有就是b2Vec2_zero的声明和定义：

声明：

[cpp] view plaincopy
  1. //有用的常量  
  2. extern const b2Vec2 b2Vec2_zero;  

定义：

[cpp] view plaincopy
  1. //声明一个二维零向量  
  2. const b2Vec2 b2Vec2_zero(0.0f, 0.0f);  

以上就是box2d中所使用的数学库和相关的API接口，上面的注释已详细说明其作用，这里就不在阐述了。如遇到相关数学方面的知识，个人建议维基百科，那里比较全，而且很详细。另外，如有什么不妥、错误之处望高手指出。

汽车模型设计软件 汽车模型设计软件
原创粉丝点击
热门IT博客
第四产业是什么知乎第四产业是什么知乎
单片机新颖毕业设计单片机新颖毕业设计
知乎 鬼吹灯
奇兔刷机软件有毒
淘宝自动好评是加分吗
交通事故数据
旋转矩阵的逆矩阵
大屏幕控制软件 bx
米5登不了淘宝手机助手
淘宝数据分析软件
淘宝客服哪里培训课程
寻找牛股共性 编程
vivo状态栏美化软件
java怎么把平均值输出
淘宝店动态评分
declaration在c语言中
游戏编程精粹1 pdf
java求100的阶乘循环
工业数据采集 解决方案
泰迪狗鞋子淘宝网
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 宝宝不学说话怎么办 腻子打磨后露底怎么办 孩子不会写数字怎么办 宝宝不会认数字怎么办 宝宝长牙顺序乱怎么办 宝宝便秘怎么办快速治疗 宝宝不爱吃水果怎么办 小孩不爱吃水果怎么办 小孩发烧39.5度怎么办 小孩发烧39.2度怎么办 孩子发烧39.5度怎么办 小孩进屋就哭怎么办 孩子母乳不够吃怎么办 孩子不吃辅食怎么办 宝宝大便有拉丝怎么办 4岁小儿拉肚子怎么办 初生婴儿呕奶怎么办 抱小孩腰痛厉害怎么办 宝宝拉血丝粘液怎么办 婴儿大便粘液状怎么办 孩子太淘气了怎么办 多动症的小孩该怎么办 宝宝太调皮好动怎么办 幼儿上课爱说话怎么办 幼儿坐不住老师怎么办 孩子坐不住好动怎么办 八个月孩子发烧怎么办 八个月孩子腹泻怎么办 孩子上课多动怎么办 孩子兴奋不睡觉怎么办 孩子做事不专心怎么办 孩子上课不听讲怎么办 孩子听课不专心怎么办 小孩上学不专心怎么办 孩子上课不专注怎么办 上课不专心听讲怎么办 宝宝突然呕吐怎么办啊 一岁宝宝太粘人怎么办 3岁宝宝太粘人怎么办 淘宝客服不说话怎么办 两岁宝宝便秘怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里