OGRE中的数学

Mage小组 著

Email: [e-mail] 

[e-mail]

QQ: 18725262

http://www.173d8.com

http://blog.csdn.net/pizi0475

 

 

OGRE是一个三维图形渲染引擎，在很多处理过程中都需要使用到数学这一基本手段，除了简单数学计算以外还需要用到大量的矩阵运算。在OGRE中提供了数学支撑环境，它们分别封装在math、Vector3、Vector4、Matrix3、Matrix4和Quaternion类里，对于特殊的需要极高效率的数学函数用汇编方式实现在asm_math.h文件中。

asm_math.h
在本头文件中针对不同的开发平台（MSVC和GNUC，但GUNC不支持嵌入汇编程序，所以对于GNUC其实还是调用其运行库函数）用汇编程序的方式实现了非常需要高效率的数学函数。其中包括asm_arccos、asm_arcsin、asm_arctan、asm_sin、asm_cos、asm_tan、asm_sqrt、asm_rsq、apx_rsq、apx_rsq、InvSqrt、asm_rand、asm_rand_max、asm_ln等函数。一般不需要由应用开发者直接调用这里定义的函数，这些函数常由Math类调用。

暂时不讲

 

Math类
本类封装了基本的数学函数，大部分函数都是C运行库中相应函数的别名，使用这种方式的原因在于可以在这里提供额外的特性。 Math类中的成员函数除构造和析构函数以外都是采用静态函数的方式提供的，其数据成员也都是静态成员。又由于Math类的实例化是由Root自动进行的，所以在使用的时候只需要以这样的格式调用数学函数就可以了：Math::函数名( )或Math:: getSingleton( ).函数名（）

Math类中的数学常量
在Math类中提供了部分使用频繁的常量。

POS_INFINITY：

定义如下：

const Real Math::POS_INFINITY = std::numeric_limits<Real>::infinity();

NEG_INFINITY：

定义如下：

const Real Math::NEG_INFINITY = -std::numeric_limits<Real>::infinity();

PI：

通过用汇编实现的tan函数（atan）计算出来的圆周率。

定义如下：

const Real Math::PI = Real( 4.0 * atan( 1.0 ) );

TWO_PI：

定义如下：

const Real Math::TWO_PI = Real( 2.0 * PI );

HALF_PI：

PI的二分之一：

const Real Math::HALF_PI = Real( 0.5 * PI );

 

数学函数速查表
取整数绝对值。

int Math::IAbs (int iValue)   

取大于参数的最小整数。

int Math::ICeil (float fValue)

取小于参数的最大整数。

int Math::IFloor (float fValue)

取整数的符号，如果为正数取1，为负数取-1，为0取0。

int Math::ISign (int iValue)

取实数绝对值

Real Math::Abs (Real fValue)

求反余弦函数，结果在0到PI之间。实际上通过调用asm_arccos函数实现。

    Real Math::ACos (Real fValue)   

求反正弦函数，结果在-PI/2到PI/2之间。实际上通过asm_arcsin函数实现。

    Real Math::ASin (Real fValue)   

求反正切函数，结果在-PI/2到PI/2之间

    Real Math::ATan (Real fValue)   

求2个数之比的反正切值，实际通过C运行库函数实现

    Real Math::ATan2 (Real fY, Real fX)   

求大于参数的最小整数值，返回值为实数

    Real Math::Ceil (Real fValue)   

求根据弧度计算余弦值，第二个参数指定是否使用查表法。在实现上，如果使用查表法，将被转换为求加90度后的正弦。查表法的缺省精度为将圆分为4096份，忽略更小的差别。如果需要更改精度，给Math类的构造函数传参。如果不使用查表法，将转换为通过汇编实现的asm_cos函数求结果。

    Real Math::Cos (Real fValue, bool useTables)   

计算指数函数值，结果为e的fValue次方。e为自然对数2.7182818。通过C运行库的exp函数实现。

    Real Math::Exp (Real fValue)   

取小于参数的最大整数，结果为实数。

    Real Math::Floor (Real fValue)  

计算参数的自然对数值，实际通过汇编实现的asm_ln函数完成。

    Real Math::Log (Real fValue)   

计算某数的某次方，实际通过C运行库的pow函数实现。

    Real Math::Pow (Real fBase, Real fExponent)   

取实数的符号，大于0返回1.0，小于0返回-1.0，等于0返回0。

    Real Math::Sign (Real fValue)   

求正弦函数，第二个参数指定是否使用查表法，缺省值为false。如果不查表，就通过汇编实现的asm_sin函数完成计算。

    Real Math::Sin (Real fValue, bool useTables)   

计算实数的平方

    Real Math::Sqr (Real fValue)   

计算实数的开平方，实际通过汇编实现的asm_sqrt函数完成计算。

    Real Math::Sqrt (Real fValue)  

计算实数开平方后的倒数，例如：1 / Sqrt(x)，对于向量归一化很有好处。

    Real Math::InvSqrt (Real fValue)

返回0、1之间的随机数，包括0和1。通过汇编实现的asm_rand和asm_rand_max函数完成。

    Real Math::UnitRandom ()

返回两个指定参数之间的随机数。

    Real Math::RangeRandom (Real fLow, Real fHigh)

返回-1、1之间的随机数，包括-1和1。

    Real Math::SymmetricRandom ()

角度转换为弧度

    Real Math::DegreesToRadians(Real degrees)

弧度转变为角度

    Real Math::RadiansToDegrees(Real radians)

在二维空间里判断一个点是否在一个三角形里，如果是返回真，否则返回假。

    bool Math::pointInTri2D( Real px, Real py, Real ax, Real ay, Real bx, Real by, Real cx, Real cy )   

求正切函数，第二个参数指定是否使用查表法，缺省值为false。如果不查表，就通过汇编实现的asm_tan函数完成计算。

    Real Math::Tan(Real radians, bool useTables)

判断两个值是否相等，第三个参数是允许的误差度，例如：a=5、b=6、tolerance=2，则结果是a=b。但tolerance的缺省值为std::numeric_limits<Real>::epsilon()。

    bool Math::RealEqual( Real a, Real b, Real tolerance )   

 

 

Vector3类
表达三维向量V（x，y，z）的类，三维世界中的位置、方向和缩放因子都可以用Vector3来表达，关键看你如何解释与使用它。

为了提高效率，Vector3类的成员函数大部分都实现为内联函数。又为了将来操作方便，Vector3类的数据成员都实现为public类型。

常量
           static const Vector3 ZERO;

        static const Vector3 UNIT_X;

        static const Vector3 UNIT_Y;

        static const Vector3 UNIT_Z;

        static const Vector3 UNIT_SCALE;

分别代表零向量、X轴单位向量、Y轴单位向量、Z轴单位向量和单位缩放因子（其实是不缩放），这些向量使用频繁，所以实现为常量。

成员函数
重载[ ]操作符，通过下标1，2，3可以取x，y，z分量。

inline Real operator [ ] ( unsigned i ) const   

重载[ ]操作符，返回引用，可以做左值。

inline Real& operator [] ( unsigned i )

重载赋值操作符，返回引用，结果可以做左值。

inline Vector3& operator = ( const Vector3& rkVector )

重载等号操作符，判断两个向量是否相等。

inline bool operator == ( const Vector3& rkVector ) const

重载不等号操作符，判断两个向量是否不相等。

inline bool operator != ( const Vector3& rkVector ) const

重载加号操作符，完成向量相加。

inline Vector3 operator + ( const Vector3& rkVector ) const

重载乘法操作符，完成向量与一个数的乘法。

inline Vector3 operator * ( Real fScalar ) const

重载乘法操作符，完成两个向量的相乘。

inline Vector3 operator * ( const Vector3& rhs) const

重载除法操作符，完成向量除以一个数的运算。

inline Vector3 operator / ( Real fScalar ) const

重载负号操作符，将原向量的每个分量取负。

inline Vector3 operator - () const       

重载乘法操作符，用友员函数的方式实现，实现一个向量与一个数相乘。

inline friend Vector3 operator * ( Real fScalar, const Vector3& rkVector )

重载+=运算符，A+=B。

        inline Vector3& operator += ( const Vector3& rkVector )

重载-=运算符，A-=B。

        inline Vector3& operator -= ( const Vector3& rkVector )

重载*=运算符，A*=B。

        inline Vector3& operator *= ( Real fScalar )

重载/=运算符，A/=B。

        inline Vector3& operator /= ( Real fScalar )

求向量长度，因为求结果用到开方，会消耗CPU时间，所以如果有可能就使用后面的求向量长度平方的函数。

        inline Real length () const

求向量长度的平方，很多时候用它可以代替求向量长度的函数，因为没有开平方，所以可以提高效率。

        inline Real squaredLength () const

计算向量点积，向量点积有如下应用：

Cos(theta) = DotProduct(v1,v2) / (length(v1) * length(v2))

 

所以，当知道两个向量的点积和长度之后就可以获得向量之间的夹角的余弦。如果两个向量都是单位向量的化，则点积的结果就是夹角的余弦。

inline Real dotProduct(const Vector3& vec) const

向量归一化，转变为方向不变的单位向量。归一化的方法是每个分量都除以向量的长度。

        inline void normalise(void)

求向量叉积。

向量叉积的结果代表这两个向量所在平面的法向量。

向量叉积遵循右手法则，从第一向量握向第二向量，大拇指指向的向量就是叉积结果。例如：屏幕左边线为第一向量，屏幕下边线为第二向量，那么它们的叉积结果就指向屏幕里面。向量的叉积计算可以用来判断两个向量的拓扑关系（左右之分）。

        inline Vector3 crossProduct( const Vector3& rkVector ) const

向量可以表达点的坐标，本函数的功能是计算两个点之间的中点坐标。

        inline Vector3 midPoint( const Vector3& vec ) const

重载小于操作符，如果A向量的各分量都小于B向量，则A向量小于B向量。

        inline bool operator < ( const Vector3& rhs ) const

重载大于操作符，如果A向量的各分量都大于B向量，则A向量大于B向量。

        inline bool operator > ( const Vector3& rhs ) const

将A、B两向量中的各分量的小值组合成新的向量。

        inline void makeFloor( const Vector3& cmp )

将A、B两向量中的各分量的大值组合成新的向量。

        inline void makeCeil( const Vector3& cmp )

计算并返回一个向量的垂直向量，一个向量的垂直向量有无穷多个，这里只返回一个。用原向量与X正轴向量做叉乘得到的结果向量是原向量与X正轴向量构成的平面的法向量，肯定垂直于原向量，函数返回这个结果向量。如果发现得到的结果向量的长度为0，又因为Length(VectorC) = Length(Vector1) * Length(Vector2) * sin(theta)，证明原向量与X正轴重合（sin(theta)为0），那么就改为求原向量与Y正轴叉乘作为结果向量。

        inline Vector3 perpendicular(void)

得到偏离原向量一定角度的随机向量。

本函数要求随机数种子已设定好。当然Math类的构造函数设定了随机数种子。如果在调用本函数之前，初始化了Math类，就可以正常使用本函数。

第一个参数是允许偏移的最大角度。

第二个参数是向量，有缺省值。要求是原向量的一个垂直向量。

        inline Vector3 randomDeviant(

            Real angle,

            const Vector3& up = Vector3::ZERO )

得到能将当前向量用最小路径旋转到目的向量的四元组。

        Quaternion getRotationTo(const Vector3& dest) const

重载输出流操作符。

        inline _OgreExport friend std::ostream& operator <<

            ( std::ostream& o, const Vector3& v )

 

Vector4类
包含x, y, z, w四个分量的向量。

构造函数
缺省构造函数

inline Vector4()

接收四个实数的构造函数

inline Vector4( Real fX, Real fY, Real fZ, Real fW )

接收四个元素的实数数组的构造函数

inline Vector4( Real afCoordinate[4] )

接受四个int的数组的构造函数

inline Vector4( int afCoordinate[4] )

接受实数指针的构造函数

inline Vector4( const Real* const r )

拷贝构造函数

inline Vector4( const Vector4& rkVector )

操作符重载
inline Real operator [] ( unsigned i ) const

inline Real& operator [] ( unsigned i )

inline Vector4& operator = ( const Vector4& rkVector )

inline bool operator == ( const Vector4& rkVector ) const

inline bool operator != ( const Vector4& rkVector ) const

用Vector3对Vector4赋值，其中w为1。

inline Vector4& operator = (const Vector3& rhs)

Vector4乘以Matrix4

inline Vector4 operator * (const Matrix4& mat)

重载输出流操作符。

inline _OgreExport friend std::ostream& operator <<( std::ostream& o, const Vector4& v )

Matrix3类
3*3矩阵类。

常量
const Real Matrix3::EPSILON = 1e-06;

    const Matrix3 Matrix3::ZERO(0,0,0,0,0,0,0,0,0);

    const Matrix3 Matrix3::IDENTITY(1,0,0,0,1,0,0,0,1);

    const Real Matrix3::ms_fSvdEpsilon = 1e-04;

    const int Matrix3::ms_iSvdMaxIterations = 32;

构造函数
Matrix3 ();

        Matrix3 (const Real arr[3][3]);

        Matrix3 (const Matrix3& rkMatrix);

        Matrix3 (Real fEntry00, Real fEntry01, Real fEntry02,

                    Real fEntry10, Real fEntry11, Real fEntry12,

                    Real fEntry20, Real fEntry21, Real fEntry22);

操作符重载
           下标操作符

Real* operator[] (int iRow) const;

        指针操作符

operator Real* ();

        Matrix3& operator= (const Matrix3& rkMatrix);

        bool operator== (const Matrix3& rkMatrix) const;

        bool operator!= (const Matrix3& rkMatrix) const;

        Matrix3 operator+ (const Matrix3& rkMatrix) const;

        Matrix3 operator- (const Matrix3& rkMatrix) const;

        Matrix3 operator* (const Matrix3& rkMatrix) const;

        负号操作符

Matrix3 operator- () const;

        Matrix3乘Vector3，结果是3*1的Vector3。

Vector3 operator* (const Vector3& rkVector) const;

以友员方式重载的乘号操作符，Vector3乘Matrix3，结果是1*3的Vector3。

        friend Vector3 operator* (const Vector3& rkVector,const Matrix3& rkMatrix);

        Matrix3乘以一个标量。

Matrix3 operator* (Real fScalar) const;

        友员方式重载的标量乘Matrix3。

friend Matrix3 operator* (Real fScalar, const Matrix3& rkMatrix);

取得Matrix3中的指定列。

Vector3 GetColumn (int iCol) const;

设定Matrix3中的指定列。

void SetColumn(int iCol, const Vector3& vec);

指定三个轴向量，构成一个Matrix3,注意：每个轴在Matrix3表现为一列。

void Matrix3::FromAxes(const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis)

求当前矩阵的转置

Matrix3 Transpose () const;

求当前矩阵的逆矩阵，注意返回值是bool型的，得到的结果矩阵在第一个参数里。

bool Matrix3::Inverse (Matrix3& rkInverse, Real fTolerance) const

求当前矩阵的逆矩阵，返回值是结果矩阵。

Matrix3 Matrix3::Inverse (Real fTolerance) const

求本矩阵代表行列式的值

Real Matrix3::Determinant () const

 

还有一些成员函数功能不明，且未被使用过。

 

Matrix4类
4*4矩阵。

常量
Matrix4::ZERO 零矩阵

Matrix4::IDENTITY 单位矩阵

构造函数：
inline Matrix4()

inline Matrix4(Real m00, Real m01, Real m02, Real m03,

            Real m10, Real m11, Real m12, Real m13,

            Real m20, Real m21, Real m22, Real m23,

            Real m30, Real m31, Real m32, Real m33 )

成员函数：
重载下标操作符

inline Real* operator [] ( unsigned iRow )

重载下标操作符

inline const Real *const operator [] ( unsigned iRow ) const

矩阵乘法

inline Matrix4 concatenate(const Matrix4 &m2)

矩阵乘法

inline Matrix4 operator * ( const Matrix4 &m2 )

用当前矩阵完成Vector3的变换，返回值是结果Vector3。

inline Vector3 operator * ( const Vector3 &v ) const

矩阵加法

inline Matrix4 operator + ( const Matrix4 &m2 ) const

矩阵减法

inline Matrix4 operator - ( const Matrix4 &m2 )

重载等号

inline bool operator == ( const Matrix4& m2 ) const

重载不等号

inline bool operator != ( Matrix4& m2 ) const

将Matrix3转换为Matrix4

inline void operator = ( const Matrix3& mat3 )

矩阵转置

inline Matrix4 transpose(void)

设置变换矩阵中的平移部分。

 

结果是：

原值

原值

原值

v.x

原值

原值

原值

v.y

原值

原值

原值

v.z

原值

原值

原值

原值

 

inline void setTrans( const Vector3& v )

构建平移变换矩阵

得到的结果是：

0

0

0

v.x

0

0

0

v.y

0

0

0

v.z

0

0

0

0

 

inline void makeTrans( const Vector3& v )

构建平移变换矩阵

结果是：

0

0

0

tx

0

0

0

ty

0

0

0

tz

0

0

0

0

 inline void makeTrans( Real tx, Real ty, Real tz )

由Vector3获得一个平移变换矩阵。注意是静态成员函数。

结果是：

0

0

0

v.x

0

0

0

v.y

0

0

0

v.z

0

0

0

0

inline static Matrix4 getTrans( const Vector3& v )

由3个实数获得一个平移变换矩阵。注意是静态成员函数。

结果是：

0

0

0

t_x

0

0

0

t_y

0

0

0

t_z

0

0

0

0

inline static Matrix4 getTrans( Real t_x, Real t_y, Real t_z )

设置矩阵中的缩放部分

结果是：

v.x

原值

原值

原值

原值

v.y

原值

原值

原值

原值

v.z

原值

原值

原值

原值

原值

 

inline void setScale( const Vector3& v )

由Vector3获得缩放矩阵

结果是：

v.x

0

0

0

0

v.y

0

0

0

0

v.z

0

0

0

0

0

 

inline static Matrix4 getScale( const Vector3& v )

由三个实数值获得缩放矩阵

结果是：

s_x

0

0

0

0

s_y

0

0

0

0

s_z

0

0

0

0

0

 

inline static Matrix4 getTrans( Real t_x, Real t_y, Real t_z )

设置矩阵中的缩放部分

结果是：

v.x
 原值
 原值
 原值
 
原值
 v.y
 原值
 原值
 
原值
 原值
 v.z
 原值
 
原值
 原值
 原值
 原值
 

 

inline void setScale( const Vector3& v )

由Vector3获得缩放矩阵

结果是：

v.x
 0
 0
 0
 
0
 v.y
 0
 0
 
0
 0
 v.z
 0
 
0
 0
 0
 0
 

 

inline static Matrix4 getScale( const Vector3& v )

由三个实数值获得缩放矩阵

结果是：

s_x
 0
 0
 0
 
0
 s_y
 0
 0
 
0
 0
 s_z
 0
 
0
 0
 0
 0
 

inline static Matrix4 getScale( Real s_x, Real s_y, Real s_z )

从4*4矩阵中析出旋转和缩放矩阵，参数是引用方式传参，接收结果。

inline void extract3x3Matrix(Matrix3& m3x3)

重载输出流操作符

inline _OgreExport friend std::ostream& operator << ( std::ostream& o, const Matrix4& m )

Quaternion类
四元数最早是为了扩展复数应用而产生与发展起来的。然而，人们发现四元数也可以应用在计算机图形学上，作为表现旋转的可选择方法之一。

普通的复数形式可以写成xi+y，其中x是虚部，y是实部。不可思议的是i的平方等于-1，那个 -1的平方根就像你应该知道的那样，其并不存在。因此取名叫“虚数”。

假如xi + y是一个复数，那么我们可认为四元数是一组很特别的复数。四元数不只一个虚部，而是有三个。四元数的形式可写成xi + yj + zk + w，在这里i、j、k的平方都等于-1。从现在起，让我们忘记四元数中平方根的形式，其就可写成这样[w,(x y z)]。

四元数可用来表现所有形式的旋转。正如你所看到，四元数仅需要四个浮点数，所以它只是给对应的矩阵添加了第四个数而已。这个属性可有助于将你许多的旋转处理存储到文件中去（例如关键帧动画）。但你如何获取源于[w,(x y z)]的旋转呢？

答案在这，你首先需要计算你的四元数的模。四元数的模与矢量的有点相似。它可做sqrt(w2 + x2 + y2 + z2)的计算。假如平均值为1，你就得到所谓的单位四元数（正象单位矢量）。唯一的是四元数需要表现旋转，因此你必须对现有的四元数进行归一化。

四元数并不天生就具有旋转的特性，因此你还要做一些转换四元数或其它的一些必要工作。你可将存储空间的四元数转换为欧拉角或轴/角的表示法，及转换为可供OpenGL使用的矩阵。我们平常描述某个点饶某个轴旋转往往是用轴/角形式描述，例如：点P饶A轴旋转θ 度。那么描述这个旋转的四元数就定义为：Q = （c，s XA，s YA，s ZA）。其中s = sin(θ/2)，c = cos(θ/2)。

 

静态数据成员
零四元数

Quaternion Quaternion::ZERO(0.0,0.0,0.0,0.0);

单位四元数

Quaternion Quaternion::IDENTITY(1.0,0.0,0.0,0.0);

 

构造函数
带四个参数的构造函数，为w，x，y，z赋值。

Quaternion::Quaternion (Real fW, Real fX, Real fY, Real fZ)

拷贝构造函数

Quaternion::Quaternion (const Quaternion& rkQ)

 

成员函数
由3*3旋转矩阵生成四元数，参数是旋转矩阵。

    void Quaternion::FromRotationMatrix (const Matrix3& kRot)

将四元数转换为旋转矩阵，参数是回传参数，接收得到的旋转矩阵。

void Quaternion::ToRotationMatrix (Matrix3& kRot) const

从角、轴生成四元数，参数为角和轴，即饶什么轴旋转多少度。

void Quaternion::FromAngleAxis (const Real& rfAngle,

由四元数生成轴、角表示法的角和轴。参数是引用参数，回传用途。

void Quaternion::ToAngleAxis (Real& rfAngle, Vector3& rkAxis) const

由3个向量表达的旋转矩阵生成四元数，参数是指针指向的多个向量表达的旋转矩阵（一般为3个）

void Quaternion::FromAxes (const Vector3* akAxis)

由3个向量表达的旋转矩阵生成四元数

void FromAxes (const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis);

由四元数生成旋转矩阵，该矩阵由指针指向的多个（3个）向量表达。

void ToAxes (Vector3* akAxis) const;

由四元数生成旋转矩阵，该矩阵由3个向量表达。

void ToAxes (Vector3& xAxis, Vector3& yAxis, Vector3& zAxis);

重载=操作符

Quaternion& operator= (const Quaternion& rkQ);

重载+操作符

Quaternion operator+ (const Quaternion& rkQ) const;

重载-操作符

Quaternion operator- (const Quaternion& rkQ) const;

重载*操作符，四元数*四元数。

Quaternion operator* (const Quaternion& rkQ) const;

重载*操作符，四元数*标量。

Quaternion operator* (Real fScalar) const;

重载*操作符，四元数*四元数。重载为友员方式。

friend Quaternion operator* (Real fScalar, const Quaternion& rkQ);

重载负号操作符

Quaternion operator- () const;

重载==操作符

bool operator== (const Quaternion& rhs) const;

四元数点乘

Real Dot (const Quaternion& rkQ) const; 

       四元数求模

Real Norm () const; 

四元数求倒数，要求本四元数非0

Quaternion Inverse () const; 

单位四元数求倒数，要求本四元数为单位四元数。

Quaternion UnitInverse () const;  // apply to unit-length quaternion

求四元数的指数，即e的四元数次方

Quaternion Exp () const;

以e为底求四元数的对数

Quaternion Log () const;

用四元数旋转向量（似乎nVidia的SDK才支持）。

Vector3 operator* (const Vector3& rkVector) const;

静态成员函数，球面线性插值。参数fT为0-1的时间因子。

static Quaternion Slerp (Real fT, const Quaternion& rkP,  const Quaternion& rkQ);

静态成员函数，带干扰因子的球面线性插值。参数fT为0-1的时间因子。

static Quaternion SlerpExtraSpins (Real fT, const Quaternion& rkP, const Quaternion& rkQ,

            int iExtraSpins);

静态成员函数，目前不清楚用途。

static void Intermediate (const Quaternion& rkQ0,

            const Quaternion& rkQ1, const Quaternion& rkQ2,

            Quaternion& rka, Quaternion& rkB);

静态成员函数，样条插值（二次插值）。目的是在已知样条形状的情况下，通过插值得到平滑的目的线条。fT为0-1的时间因子。rkP和rkQ为样条的起点和终点，而rkA和为rkB插值过程中的某一线段的起点和终点（控制点连线）。

            对AB段插值                                                 对新的AB段插值

static Quaternion Squad (Real fT, const Quaternion& rkP,

            const Quaternion& rkA, const Quaternion& rkB,

            const Quaternion& rkQ);

重载输出流操作符。

inline _OgreExport friend std::ostream& operator <<

            ( std::ostream& o, const Quaternion& q )