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

最新推荐文章于 2013-10-11 22:28:02 发布
最新推荐文章于 2013-10-11 22:28:02 发布
阅读量332 收藏
点赞数
分类专栏： Box2d

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

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

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

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

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

d)、其他部分的实现

 

一、向量部分

1、 二维列向量的实现

[cpp]  view plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  1. //有用的常量  
  2. extern const b2Vec2 b2Vec2_zero;  

定义：

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

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

zengkulou
关注
专栏目录
Pytorch深度强化学习1-1：Gym安装与环境搭建教程(附基本指令表)
FRIGIDWINTER的博客
04-20 2万+
强化学习是在潜在的不确定复杂环境中，训练一个最优决策指导一系列行动实现目标最优化的机器学习方法。自从AlphaGo的横空出世之后，确定了强化学习在人工智能领域的重要地位，越来越多的人加入到强化学习的研究和学习中。OpenAI Gym是一个研究和比较强化学习相关算法的开源工具包，包含了许多经典的仿真环境(各种游戏)，兼容常见的数值运算库，使用户无需过多了解游戏的内部实现，通过简单地调用就可以用来测试和仿真。OpenAI GymGym开源库：测试仿真环境，这些环境有一个公共的接口且允许用户设计通用的算法。
基于opencv3.1库的JAVA源码
09-29
范例5-4-4模糊处理-使用BoxFilter函数及GUI元件 119 范例5-5-1 Threshold-使用临界值函数及GUI元件 122 范例5-5-2 AdaptiveThreshold-使用自适临界值及GUI元件 128 范例5-6-1 Sharpness锐利化处理 130 范例5-6-2锐利...
box2d源代码游戏
04-07
一款2d物理引擎，很方便，大家自己下载试玩啦。
Box2d源码学习<一>之Box2d简介
cg0206的专栏
12-04 5169
本系列博客是由扭曲45原创，欢迎转载，转载时注明出处，http://blog.csdn.net/cg0206/article/details/8257607  随着智能手机的大量普及，手机的性能也越来越好，伴随而来出现大量的手机游戏 ，其中不乏很多优秀的游戏，如《愤怒的小鸟》、《鳄鱼小玩皮》、《翼飞冲天》等等。同时它们也大量的模拟了现实生活中的相关东西，比如小鸟飞行、碰撞的模拟，流体的模拟，都用
box2d 中文api world类
qq55008307的专栏
10-25 647
构造函数与析构函数 b2World::b2World ( const b2Vec2 & gravity,  bool doSleep  )  构造一个世界对象。 参数: gravity 世界重力向量。 doSleep 物体是否可休眠。通过不模拟休眠物体来提高引擎的效率。  b2World::~b2World ( )  摧毁世界。所有的物理学实体被摧毁，而且所有的
Box2d源码学习<二>内存管理之SOA的实现
cg0206的专栏
12-05 4995
本系列博客是由扭曲45原创，欢迎转载，转载时注明出处，http://blog.csdn.net/cg0206/article/details/8258166 SOA,全称small object allocator,中文意思是小对象分配器。box2d虽然是用c++写的，但是并没有使用c++自带的new/delete实现内存管理，而是使用在c的malloc/free做法的基础上封装了类b2Bl
Box2d源码学习<三> 内存管理之栈的实现
cg0206的专栏
12-07 2570
本系列博客是由扭曲45原创，欢迎转载，转载时注明出处，http://blog.csdn.net/cg0206/article/details/8271251 Box2d上有两个和栈有关的类，它们分别是b2StackAllocator和b2GrowableStack。 B2StackAllocator主要是为了运行一个步长时满足box2d需要的临时内存空间，作为栈分配器来防止单步堆分配。
精选_基于WIN32 API实现黄金矿工游戏单人版_源码打包
03-10
《基于WIN32 API实现黄金矿工游戏单人版源码解析》 在计算机编程领域，游戏开发是一项挑战性极高的工作，它涉及到图形、音频、逻辑等多个方面的技术融合。本篇文章将深入探讨如何利用WIN32 API来实现一款黄金矿工...
Box2D v2.1.0用户手册中文翻译
12-30
- 另外，Box2D的源码中包含了大量的注释，并遵循Doxygen格式规范，方便生成带超链接的API文档。 ##### 1.4 反馈与错误报告 - 如果在使用过程中遇到问题或有任何改进建议，可以在Box2D官方论坛上提出。此外，Box2D...
源码捕鱼模型参考
12-21
5. **物理模拟**：捕鱼游戏中，鱼的运动、子弹的轨迹等都需要遵循一定的物理规律，开发者可能利用Box2D或Chipmunk等物理引擎来实现真实感的物理模拟。 6. **游戏设计模式**：源码中可能会运用到诸如单例模式、观察...
Android Box2d物理世界源码.rar
07-04
Android Box2d物理世界源码.rar
Box2D:libgdx的Box2D系列博客源码-源码客
03-24
Box2D:libgdx的Box2D系列博客源码
box2d文档API
07-05
移动开发物理引擎的API文档说明，是html的格式，封装了下，更好使用
Box2D中文版API
12-05
box2d android java api 文档
Box2D 2.2.1 物理引擎最新版源码
09-23
Box2D 2.2.1 物理引擎最新版源码~~~~~~~！！！！！！！！！！！！！！！！！！！！！
Box2d源码学习<十三>b2Collision之碰撞(下) 具体形状间的碰撞的实现
cg0206的专栏
12-26 6931
本系列博客是由扭曲45原创，欢迎转载，转载时注明出处，http://blog.csdn.net/cg0206/article/details/8441463 Box2d中，要形状间实现碰撞，必须两个碰撞形状中至少有一个形状要有体积，而链形状每条边都被看作一个边缘形状，此时我们只要实现圆形、多边形、边缘三个具体形状间的碰撞，因为边缘形状没有体积，故不存在边缘与边缘之间的碰撞。剩下还有边缘和圆，
Box2D源码学习(1)-HelloWorld
chen52671的专栏
10-11 826
首先从HelloWorld.cpp的源码入手，看看Box2D大致如何使用的。 包含头文件： #include #include 其中 Box2D/Box2D.h 实际上是包含Common、Collision、Dynamics、Rope的头文件。 可以看出Box2D目录下就是其核心源码。而其他目录则是些文档，第三方库。和测试例程。 分析helloworld的main函数：
Box2D V2.1 源码及中文手册
思月行云
04-06 286
&gt;&gt; 下载见附件
<div class="box1"> <div class="box2">box2</div> <div class="box3"> <div>1</div> <div>1</div> <div>1</div> <div>1</div> </div> </div> 这样的结构中，我设置.box1为display：flex，设置box3为display：flex，为什么全部显示到了一行，应该怎么处理
最新发布
07-22
<div class="box2">box2</div> <div class="box3"> <div>1</div> <div>1</div> <div>1</div> <div>1</div> </div> </div> ``` ```css .box1 { display: flex; flex-direction: column; /* 垂直排列 */ } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值