cocos2d-x节点（b2Math.h)API

本文来自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 * B
inline 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 * B
inline 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 * r
inline 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 * r
inline 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 vector
inline 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 vector
inline 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.p
inline 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表示alpha0
inline 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 pi
inline void b2Sweep::Normalize()
{
    float32 twoPi = 2.0f * b2_pi;
    float32 d =  twoPi * floorf(a0 / twoPi);
    a0 -= d;
    a -= d;
}

#endif