本文来自http://blog.csdn.net/runaying ，引用必须注明出处！

cocos2d-x节点（b2Math.h)API

温馨提醒：为了大家能更好学习，强烈推荐大家看看本人的这篇博客 Cocos2d-X权威指南笔记

//Box2d的公共模块中，包含的一个小巧而简便的向量矩阵的数学库。

//主要由以下内容：

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

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

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

//d)、其他部分的实现

///cocos2d-x-3.0alpha0/external/Box2D/Common//Box2d的公共模块中，包含的一个小巧而简便的向量矩阵的数学库。//主要由以下内容：//a)、向量，包括二维列向量和三维列向量//b)、矩阵，包括2X2矩阵和3X3矩阵//c)、旋度、扫描、和变换的实现//d)、其他部分的实现#ifndef B2_MATH_H#define B2_MATH_H#include <Box2D/Common/b2Settings.h>#include <cmath>#ifndef SHP#include <cfloat>#else#include <float.h>#endif#include <cstddef>#include <limits>using namespace std;/// 用来确保一个浮点数不是一个NaN或无穷大//* 参数说明： x :数值//* 返 回 值： true ：有效//false: 无效inline bool b2IsValid(float32 x){    if (x != x)    {        // NaN.        return false;    }    float32 infinity = std::numeric_limits<float32>::infinity();    return -infinity < x && x < infinity;}//一个近似且快速的平方根倒数算法[x^ (-1/2) ]//可以参照 http://zh.wikipedia.org/wiki/平方根倒数速算法//或 http://en.wikipedia.org/wiki/Fast_inverse_square_root//* 参数说明： x :数值//* 返 回 值： 平方根倒数inline float32 b2InvSqrt(float32 x){    union    {        float32 x;        int32 i;    } convert;    convert.x = x;    float32 xhalf = 0.5f * x;    convert.i = 0x5f3759df - (convert.i >> 1);    x = convert.x;    x = x * (1.5f - xhalf * x * x); //第一次牛顿迭代      return x;}//平方根宏  #define    b2Sqrt(x)    std::sqrt(x)//对于任意不同时等于0的实参数x和y，//atan2(y,x)所表达的意思是坐标原点为起点，//指向(y,x)的射线在坐标平面上与x轴正方向之间的角的角度度//参照 http://zh.wikipedia.org/wiki/Atan2#define    b2Atan2(y, x)    std::atan2(y, x)///2d列向量  struct b2Vec2{    /// 构造函数，不做任何事，仅仅为了性能     b2Vec2() {}    ///构造函数，构建使用的坐标     b2Vec2(float32 x, float32 y) : x(x), y(y) {}    /// 将向量置0     void SetZero() { x = 0.0f; y = 0.0f; }    /// 将向量设置成指定的坐标    void Set(float32 x_, float32 y_) { x = x_; y = y_; }    /// 将向量取反，重载 - 运算符     b2Vec2 operator -() const { b2Vec2 v; v.Set(-x, -y); return v; }        /// 读取指定索引的元素，重载 () 运算符  返 回 值： 列中对应索引元素值     float32 operator () (int32 i) const    {        return (&x)[i];    }    /// 改写指定索引的元素，重载 () 运算符 返 回 值： 列中对应索引元素的引用    float32& operator () (int32 i)    {        return (&x)[i];    }    /// 与另一个向量相加     void operator += (const b2Vec2& v)    {        x += v.x; y += v.y;    }        /// 与另一个向量相减     void operator -= (const b2Vec2& v)    {        x -= v.x; y -= v.y;    }    /// 与标量相乘     void operator *= (float32 a)    {        x *= a; y *= a;    }    /// 获取向量的长度     float32 Length() const    {        return b2Sqrt(x * x + y * y);    }    /// 获取向量的长度的平方。出于性能要求，//    使用此函数代替b2Vec2::Legth函数（如果可能的话）    float32 LengthSquared() const    {        return x * x + y * y;    }    /// 将该向量转变成单位向量 . 返 回 值： 向量长度[注意是未转变之前的长度]     float32 Normalize()    {        //获取该向量的长度并验证其有效性          float32 length = Length();        if (length < b2_epsilon)        {            return 0.0f;        }        //获取要转换单位向量的因子,并与x、y轴相乘        float32 invLength = 1.0f / length;        x *= invLength;        y *= invLength;        return length;    }    /// 该向量包含的坐标值是否有效     bool IsValid() const    {        return b2IsValid(x) && b2IsValid(y);    }    /// 获取斜对称向量(反对称向量),dot(skew_vec, other) == cross(vec, other)     b2Vec2 Skew() const    {        return b2Vec2(-y, x);    }    float32 x, y;};///2d三维列向量  struct b2Vec3{    /// 默认构造函数，不做任何事，仅仅为了性能    b2Vec3() {}    /// 构造函数，构建使用的坐标     b2Vec3(float32 x, float32 y, float32 z) : x(x), y(y), z(z) {}    /// 将向量置0     void SetZero() { x = 0.0f; y = 0.0f; z = 0.0f; }    /// 将向量设置成指定的坐标     void Set(float32 x_, float32 y_, float32 z_) { x = x_; y = y_; z = z_; }    /// 将向量取反，重载 - 运算符     b2Vec3 operator -() const { b2Vec3 v; v.Set(-x, -y, -z); return v; }    /// 与另一个向量相加     void operator += (const b2Vec3& v)    {        x += v.x; y += v.y; z += v.z;    }    ///与另一个向量相减     void operator -= (const b2Vec3& v)    {        x -= v.x; y -= v.y; z -= v.z;    }    ///与一个标量相乘     void operator *= (float32 s)    {        x *= s; y *= s; z *= s;    }//向量的元素值      float32 x, y, z;};//2X2矩阵，存储方式以列为主的顺序  struct b2Mat22{    /// 默认构造函数不做任何事情(仅仅为了性能)     b2Mat22() {}    /// 使用列向量构造这个矩阵 参数说明： c1  ：第一列向量    //    c2  ：第二列向量    b2Mat22(const b2Vec2& c1, const b2Vec2& c2)    {        ex = c1;        ey = c2;    }    /// 使用标量构造这个矩阵 参数说明： a11-a22:四个元素值     b2Mat22(float32 a11, float32 a12, float32 a21, float32 a22)    {        ex.x = a11; ex.y = a21;        ey.x = a12; ey.y = a22;    }    ///使用列实例话这个矩阵 * 参数说明： c1:列向量//c2:列向量    void Set(const b2Vec2& c1, const b2Vec2& c2)    {        ex = c1;        ey = c2;    }    /// 设置成单位矩阵     void SetIdentity()    {        ex.x = 1.0f; ey.x = 0.0f;        ex.y = 0.0f; ey.y = 1.0f;    }    /// 将该矩阵置0     void SetZero()    {        ex.x = 0.0f; ey.x = 0.0f;        ex.y = 0.0f; ey.y = 0.0f;    }    //获取逆矩阵,  逆矩阵B = A的伴随矩阵/A的行列式//    参照 http://zh.wikipedia.org/wiki/逆矩阵    b2Mat22 GetInverse() const    {        float32 a = ex.x, b = ey.x, c = ex.y, d = ey.y;        b2Mat22 B;        float32 det = a * d - b * c;        if (det != 0.0f)        {            det = 1.0f / det;        }        B.ex.x =  det * d;    B.ey.x = -det * b;        B.ex.y = -det * c;    B.ey.y =  det * a;        return B;    }    /// 解决A*x = b,其中b是一个列向量//    这比一次性求反计算更有效率 .    b2Vec2 Solve(const b2Vec2& b) const    {        float32 a11 = ex.x, a12 = ey.x, a21 = ex.y, a22 = ey.y;         //获取行列式的值          float32 det = a11 * a22 - a12 * a21;        if (det != 0.0f)        {            det = 1.0f / det;        }        b2Vec2 x;        x.x = det * (a22 * b.x - a12 * b.y);        x.y = det * (a11 * b.y - a21 * b.x);        return x;    }    b2Vec2 ex, ey;};/// 3X3矩阵，存储方式以列为主的顺序 struct b2Mat33{    /// 默认构造函数不做任何事情(仅仅为了性能)     b2Mat33() {}    /// 使用列向量构造这个矩阵 参数说明： c1  ：第一列向量//    c2  ：第二列向量    b2Mat33(const b2Vec3& c1, const b2Vec3& c2, const b2Vec3& c3)    {        ex = c1;        ey = c2;        ez = c3;    }    ///将该矩阵置0     void SetZero()    {        ex.SetZero();        ey.SetZero();        ez.SetZero();    }    /// 解决A*x = b,其中b是一个三维列向量    //    这比一次性求反计算更有效率参数说明： b : 三维列向量//    * 返 回 值： 三维列向量    b2Vec3 Solve33(const b2Vec3& b) const;////    解决A*x = b,其中b是一个二维列向量//    这比一次性求反计算更有效率//    仅仅解决2X2的矩阵等式//    * 参数说明： b : 三维列向量//    * 返 回 值： 三维列向量    b2Vec2 Solve22(const b2Vec2& b) const;    ///获取2X2的逆矩阵,    //    如果出现异常则置为0矩阵    //    逆矩阵B = A的伴随矩阵/A的行列式    /// 如果是单例就返回零矩阵    void GetInverse22(b2Mat33* M) const;    ///获取2X2的逆矩阵,//    如果出现异常则置为0矩阵//    逆矩阵B = A的伴随矩阵/A的行列式       /// 如果是单例就返回零矩阵    void GetSymInverse33(b2Mat33* M) const;//矩阵的3个列向量      b2Vec3 ex, ey, ez;};/// //旋度 http://zh.wikipedia.org/wiki/旋度  struct b2Rot{//    默认构造函数不做任何事情(仅仅为了性能)     b2Rot() {}    /// 用角的弧度初始化    explicit b2Rot(float32 angle)    {        /// TODO_ERIN optimize        s = sinf(angle);        c = cosf(angle);    }    /// 设置使用的角度，以弧度为单位    void Set(float32 angle)    {        /// TODO_ERIN optimize        s = sinf(angle);        c = cosf(angle);    }    /// 设置旋转标记    void SetIdentity()    {        s = 0.0f;        c = 1.0f;    }    /// 用弧度得到角度     float32 GetAngle() const    {        return b2Atan2(s, c);    }    /// 获取x-axis     b2Vec2 GetXAxis() const    {        return b2Vec2(c, s);    }    /// Get the u-axis    b2Vec2 GetYAxis() const    {        return b2Vec2(-s, c);    }    /// 正弦和余弦    float32 s, c;};//变换包括平移和旋度，它是用来表示位置和精确方向的框架struct b2Transform{    /// ：默认构造函数，什么都不做     b2Transform() {}    /// 用一个位置向量和一个旋度进行初始化//    * 参数说明： position ：位置向量//    rotation ：旋度    b2Transform(const b2Vec2& position, const b2Rot& rotation) : p(position), q(rotation) {}    /// Set 变换标识.    void SetIdentity()    {        p.SetZero();        q.SetIdentity();    }    /// 基于角的弧度和位置设置//    * 参数说明： position：位置向量//    angle   ：角的弧度    void Set(const b2Vec2& position, float32 angle)    {        p = position;        q.Set(angle);    }    //成员变量，一个向量和一个旋度    b2Vec2 p;    b2Rot q;};//描述运动的body/shape的TOI(Time of Impact)的计算。//形状相对于主体原点定义的，这可能没有一致的原点。//但是，为了支持动态我们必须篡改质心位置struct b2Sweep{    ///在特定时间里获得窜改变换//    * 参数说明： xfb   :变换的指针//    beta  :一个因子，在[0,1]之间，0表示alpha0    void GetTransform(b2Transform* xfb, float32 beta) const;    /// 推进缓慢向前移动，产生一个新的初始状态//    * 参数说明：alpha:新的初始时间    void Advance(float32 alpha);    /// 标准化角度     void Normalize();    b2Vec2 localCenter; ///质心位置    b2Vec2 c0, c;       ///世界的中心位置    float32 a0, a;      ///世界角度    //分数，当前时间步长，范围[0,1]之间    float32 alpha0;};/// 有用的常量  extern const b2Vec2 b2Vec2_zero;///计算两个向量的点积,注：a = b时，表示向量长度的平方//* 参数说明： a :二维列向量//b :二维列向量//* 返 回 值： 点积值inline float32 b2Dot(const b2Vec2& a, const b2Vec2& b){    return a.x * b.x + a.y * b.y;}///计算两个向量的叉积，在2d中这是一个标量//* 参数说明： a :二维列向量//b :二维列向量inline float32 b2Cross(const b2Vec2& a, const b2Vec2& b){    return a.x * b.y - a.y * b.x;}/// 计算向量和标量的叉积//* 参数说明： a :二维列向量//s :标量//* 返 回 值： 二维列向量inline b2Vec2 b2Cross(const b2Vec2& a, float32 s){    return b2Vec2(s * a.y, -s * a.x);}/// 计算标量和向量的叉积//* 参数说明： s :标量//a :二维列向量//* 返 回 值： 二维列向量inline b2Vec2 b2Cross(float32 s, const b2Vec2& a){    return b2Vec2(-s * a.y, s * a.x);}/// 一个矩阵乘以一个向量//* 参数说明： a :2X2矩阵//v :二维列向量//* 返 回 值： 二维列向量inline b2Vec2 b2Mul(const b2Mat22& A, const b2Vec2& v){    return b2Vec2(A.ex.x * v.x + A.ey.x * v.y, A.ex.y * v.x + A.ey.y * v.y);}//一个转置矩阵乘以一个向量//* 参数说明： a :2X2矩阵//v :二维列向量//* 返 回 值： 二维列向量inline b2Vec2 b2MulT(const b2Mat22& A, const b2Vec2& v){    return b2Vec2(b2Dot(v, A.ex), b2Dot(v, A.ey));}/// 计算两个向量按分量逐个相加//* 参数说明： a :二维列向量//b :二维列向量//* 返 回 值： 二维列向量inline b2Vec2 operator + (const b2Vec2& a, const b2Vec2& b){    return b2Vec2(a.x + b.x, a.y + b.y);}/// 计算两个向量按分量逐个相减//* 参数说明： a :二维列向量//b :二维列向量//* 返 回 值： 二维列向量inline b2Vec2 operator - (const b2Vec2& a, const b2Vec2& b){    return b2Vec2(a.x - b.x, a.y - b.y);}//计算标量和向量相乘//* 参数说明： s :标量//a :二维列向量//* 返 回 值： 二维列向量inline b2Vec2 operator * (float32 s, const b2Vec2& a){    return b2Vec2(s * a.x, s * a.y);}//判断两个向量是否相等//* 参数说明： a :二维列向量//b :二维列向量//* 返 回 值： true ：相等//flase：不相等inline bool operator == (const b2Vec2& a, const b2Vec2& b){    return a.x == b.x && a.y == b.y;}//计算两向量之间的距离//* 参数说明： a :二维列向量//b :二维列向量//* 返 回 值： 距离inline float32 b2Distance(const b2Vec2& a, const b2Vec2& b){    b2Vec2 c = a - b;    return c.Length();}//获取两向量之间距离的平方//* 参数说明： a :二维列向量//b :二维列向量//* 返 回 值： 距离的平方inline float32 b2DistanceSquared(const b2Vec2& a, const b2Vec2& b){    b2Vec2 c = a - b;    return b2Dot(c, c);}//一个标量和一个3维列向量相乘//* 参数说明： s :标量//a :三维列向量//* 返 回 值： 三维列向量inline b2Vec3 operator * (float32 s, const b2Vec3& a){    return b2Vec3(s * a.x, s * a.y, s * a.z);}//计算两个向量按分量逐个相加//* 参数说明： a :三维列向量//b :三维列向量//* 返 回 值： 三维列向量inline b2Vec3 operator + (const b2Vec3& a, const b2Vec3& b){    return b2Vec3(a.x + b.x, a.y + b.y, a.z + b.z);}/// 计算两个向量按分量逐个相减//* 参数说明： a :三维列向量//b :三维列向量//* 返 回 值： 三维列向量inline b2Vec3 operator - (const b2Vec3& a, const b2Vec3& b){    return b2Vec3(a.x - b.x, a.y - b.y, a.z - b.z);}///  计算两个向量的点积//* 参数说明： a :三维列向量//b :三维列向量//* 返 回 值： 点积值inline float32 b2Dot(const b2Vec3& a, const b2Vec3& b){    return a.x * b.x + a.y * b.y + a.z * b.z;}///  计算两个相邻的叉积//* 参数说明： a :三维列向量//b :三维列向量//* 返 回 值： 三维列向量inline b2Vec3 b2Cross(const b2Vec3& a, const b2Vec3& b){    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);}//计算两个2X2矩阵相加//* 参数说明： a :2X2矩阵//b :2X2矩阵//* 返 回 值： 2X2矩阵inline b2Mat22 operator + (const b2Mat22& A, const b2Mat22& B){    return b2Mat22(A.ex + B.ex, A.ey + B.ey);}//计算两个2X2矩阵相乘//* 参数说明： a :2X2矩阵//b :2X2矩阵//* 返 回 值： 2X2矩阵// A * Binline b2Mat22 b2Mul(const b2Mat22& A, const b2Mat22& B){    return b2Mat22(b2Mul(A, B.ex), b2Mul(A, B.ey));}//计算一个转置矩阵和矩阵相乘//* 参数说明： a :2X2矩阵//b :2X2矩阵//* 返 回 值： 2X2矩阵// A^T * Binline b2Mat22 b2MulT(const b2Mat22& A, const b2Mat22& B){    b2Vec2 c1(b2Dot(A.ex, B.ex), b2Dot(A.ey, B.ex));    b2Vec2 c2(b2Dot(A.ex, B.ey), b2Dot(A.ey, B.ey));    return b2Mat22(c1, c2);}//计算一个矩阵和向量相乘//* 参数说明： a :3X3矩阵//v :三维列向量//* 返 回 值： 三维列向量inline b2Vec3 b2Mul(const b2Mat33& A, const b2Vec3& v){    return v.x * A.ex + v.y * A.ey + v.z * A.ez;}//计算一个矩阵和二维列向量相乘//* 参数说明： a :3X3矩阵//v :二维列向量//* 返 回 值： 二维列向量inline b2Vec2 b2Mul22(const b2Mat33& A, const b2Vec2& v){    return b2Vec2(A.ex.x * v.x + A.ey.x * v.y, A.ex.y * v.x + A.ey.y * v.y);}//计算两个旋度的乘积//* 参数说明： q :旋度//r :旋度//* 返 回 值： 旋度/// Multiply two rotations: q * rinline b2Rot b2Mul(const b2Rot& q, const b2Rot& r){    // [qc -qs] * [rc -rs] = [qc*rc-qs*rs -qc*rs-qs*rc]    // [qs  qc]   [rs  rc]   [qs*rc+qc*rs -qs*rs+qc*rc]    // s = qs * rc + qc * rs    // c = qc * rc - qs * rs    b2Rot qr;    qr.s = q.s * r.c + q.c * r.s;    qr.c = q.c * r.c - q.s * r.s;    return qr;}//计算一个转置旋度和一个旋度的乘积//* 参数说明： q :旋度//r :旋度//* 返 回 值： 旋度/// Transpose multiply two rotations: qT * rinline b2Rot b2MulT(const b2Rot& q, const b2Rot& r){    // [ qc qs] * [rc -rs] = [qc*rc+qs*rs -qc*rs+qs*rc]    // [-qs qc]   [rs  rc]   [-qs*rc+qc*rs qs*rs+qc*rc]    // s = qc * rs - qs * rc    // c = qc * rc + qs * rs    b2Rot qr;    qr.s = q.c * r.s - q.s * r.c;    qr.c = q.c * r.c + q.s * r.s;    return qr;}//旋转一个向量//* 参数说明： q :旋度//v :向量//* 返 回 值： 二维列向量/// Rotate a vectorinline b2Vec2 b2Mul(const b2Rot& q, const b2Vec2& v){    return b2Vec2(q.c * v.x - q.s * v.y, q.s * v.x + q.c * v.y);}//反旋转一个向量//* 参数说明： q :旋度//v :向量//* 返 回 值： 二维列向量/// Inverse rotate a vectorinline b2Vec2 b2MulT(const b2Rot& q, const b2Vec2& v){    return b2Vec2(q.c * v.x + q.s * v.y, -q.s * v.x + q.c * v.y);}//变换一个向量//* 参数说明： T :变换//v :向量//* 返 回 值： 二维列向量inline b2Vec2 b2Mul(const b2Transform& T, const b2Vec2& v){    float32 x = (T.q.c * v.x - T.q.s * v.y) + T.p.x;    float32 y = (T.q.s * v.x + T.q.c * v.y) + T.p.y;    return b2Vec2(x, y);}//反变换一个向量//* 参数说明： T :变换//v :向量//* 返 回 值： 二维列向量inline b2Vec2 b2MulT(const b2Transform& T, const b2Vec2& v){    float32 px = v.x - T.p.x;    float32 py = v.y - T.p.y;    float32 x = (T.q.c * px + T.q.s * py);    float32 y = (-T.q.s * px + T.q.c * py);    return b2Vec2(x, y);}//变换一个变换//v2 = A.q.Rot(B.q.Rot(v1) + B.p) + A.p//= (A.q * B.q).Rot(v1) + A.q.Rot(B.p) + A.p//* 参数说明： a :变换//b :变换//* 返 回 值： 变换// v2 = A.q.Rot(B.q.Rot(v1) + B.p) + A.p//    = (A.q * B.q).Rot(v1) + A.q.Rot(B.p) + A.pinline b2Transform b2Mul(const b2Transform& A, const b2Transform& B){    b2Transform C;    C.q = b2Mul(A.q, B.q);    C.p = b2Mul(A.q, B.p) + A.p;    return C;}//反变换一个变换//v2 = A.q' * (B.q * v1 + B.p - A.p)//= A.q' * B.q * v1 + A.q' * (B.p - A.p)//* 参数说明： a：变换//b:变换//* 返 回 值： 变换// v2 = A.q' * (B.q * v1 + B.p - A.p)//    = A.q' * B.q * v1 + A.q' * (B.p - A.p)inline b2Transform b2MulT(const b2Transform& A, const b2Transform& B){    b2Transform C;    C.q = b2MulT(A.q, B.q);    C.p = b2MulT(A.q, B.p - A.p);    return C;}//取绝对值函数//* 参数说明： a：标量//* 返 回 值： 标量template <typename T>inline T b2Abs(T a){    return a > T(0) ? a : -a;}//取向量的绝对值//* 参数说明： A：二维列向量//* 返 回 值： 二维列向量inline b2Vec2 b2Abs(const b2Vec2& a){    return b2Vec2(b2Abs(a.x), b2Abs(a.y));}//取2X2矩阵的绝对值//* 参数说明： A：2X2矩阵//* 返 回 值： 2X2矩阵inline b2Mat22 b2Abs(const b2Mat22& A){    return b2Mat22(b2Abs(A.ex), b2Abs(A.ey));}//获得最小值函数//* 参数说明： a : 标量//b : 标量//* 返 回 值： 标量template <typename T>inline T b2Min(T a, T b){    return a < b ? a : b;}//获得最小向量值//* 参数说明： a : 二维向量//b : 二维向量//* 返 回 值： 二维向量inline b2Vec2 b2Min(const b2Vec2& a, const b2Vec2& b){    return b2Vec2(b2Min(a.x, b.x), b2Min(a.y, b.y));}//获得最大值函数//* 参数说明： a : 标量//b : 标量//* 返 回 值： 标量template <typename T>inline T b2Max(T a, T b){    return a > b ? a : b;}//获得最大向量值//* 参数说明： a : 二维向量//b : 二维向量//* 返 回 值： 二维向量inline b2Vec2 b2Max(const b2Vec2& a, const b2Vec2& b){    return b2Vec2(b2Max(a.x, b.x), b2Max(a.y, b.y));}//获得low到high之间的值//* 参数说明： a ，low,high:都是标量//* 返 回 值： 标量template <typename T>inline T b2Clamp(T a, T low, T high){    return b2Max(low, b2Min(a, high));}//获得两向量之间的向量//* 参数说明： a ，low,high:都是二维向量//* 返 回 值： 二维向量inline b2Vec2 b2Clamp(const b2Vec2& a, const b2Vec2& low, const b2Vec2& high){    return b2Max(low, b2Min(a, high));}//交换两个标量 template<typename T> inline void b2Swap(T& a, T& b){    T tmp = a;    a = b;    b = tmp;}//下一个最大2的幂//给你一个二进制整数x。//通过swar算法计算出下一个最大2的幂//递归的折叠高位bit到低位中去。此过程产生一个二进制数据，它的所有围上的数据都是1。//该值加1来产生下一个最大2的幂，他是一个32-bit 的值//* 参数说明： x:需要判断的值inline uint32 b2NextPowerOfTwo(uint32 x){    x |= (x >> 1);    x |= (x >> 2);    x |= (x >> 4);    x |= (x >> 8);    x |= (x >> 16);    return x + 1;}//判断是否是2的幂//* 参数说明： x:需要判断的值inline bool b2IsPowerOfTwo(uint32 x){    bool result = x > 0 && (x & (x - 1)) == 0;    return result;}//在特定时间里获得窜改变换//* 参数说明： xfb   :变换的指针//beta  :一个因子，在[0,1]之间，0表示alpha0inline void b2Sweep::GetTransform(b2Transform* xf, float32 beta) const{    xf->p = (1.0f - beta) * c0 + beta * c;    float32 angle = (1.0f - beta) * a0 + beta * a;    xf->q.Set(angle);    // Shift to origin    xf->p -= b2Mul(xf->q, localCenter);}//推进缓慢向前移动，产生一个新的初始状态//* 参数说明：alpha:新的初始时间inline void b2Sweep::Advance(float32 alpha){    b2Assert(alpha0 < 1.0f);    float32 beta = (alpha - alpha0) / (1.0f - alpha0);    c0 = (1.0f - beta) * c0 + beta * c;    a0 = (1.0f - beta) * a0 + beta * a;    alpha0 = alpha;}//标准化角（以弧度为单位）在-pi和pi之间//* 参数说明：alpha:新的初始时间/// Normalize an angle in radians to be between -pi and piinline void b2Sweep::Normalize(){    float32 twoPi = 2.0f * b2_pi;    float32 d =  twoPi * floorf(a0 / twoPi);    a0 -= d;    a -= d;}#endif