xmatrixfunc.inl

XMathLib是一个通用的3D图形数学库。 其中包含两个部分： XMathLib和XGeomLib。分别处理数学和几何运算。 数学部分包含向量、矩阵、四元数的运算。以及其它的运算。 几何部分

#ifndef __XMATRIX_FUNC_INLINE_H__
#define __XMATRIX_FUNC_INLINE_H__

#ifndef IN_MATHLIB_NAMESPACE
#error   You cann't include this file out the XMathLib  namespace
#endif



    //---------------------------------------------------------------------------------
    //矩阵相加相减
    //---------------------------------------------------------------------------------
    __FORCE_INLINE__ void _MATH_LIB_EXPORT_  XMatrix_Sub(XMatrix3x3& m1,XMatrix3x3& m2,XMatrix3x3& mOut)
    {
        mOut.m00 = m1.m00 - m2.m00 ;   mOut.m01 = m1.m01 - m2.m01;    mOut.m02 = m1.m02 - m2.m02;
        mOut.m10 = m1.m10 - m2.m10 ;   mOut.m11 = m1.m11 - m2.m11;    mOut.m12 = m1.m12 - m2.m12;
        mOut.m20 = m1.m20 - m2.m20 ;   mOut.m21 = m1.m21 - m2.m21;    mOut.m22 = m1.m22 - m2.m22;
    }
    __FORCE_INLINE__ void _MATH_LIB_EXPORT_  XMatrix_Add(XMatrix3x3& m1,XMatrix3x3& m2,XMatrix3x3& mOut)
    {
        mOut.m00 = m1.m00 + m2.m00;    mOut.m01 = m1.m01 + m2.m01;    mOut.m02 = m1.m02 + m2.m02;
        mOut.m10 = m1.m10 + m2.m10;    mOut.m11 = m1.m11 + m2.m11;    mOut.m12 = m1.m12 + m2.m12;
        mOut.m20 = m1.m20 + m2.m20;    mOut.m21 = m1.m21 + m2.m21;    mOut.m22 = m1.m22 + m2.m22;
    }
    __FORCE_INLINE__ void _MATH_LIB_EXPORT_  XMatrix_Sub(XMatrix& m1,XMatrix& m2,XMatrix& mOut)
    {
        mOut.m00 = m1.m00 - m2.m00;    mOut.m01 = m1.m01 - m2.m01;    mOut.m02 = m1.m02 - m2.m02;   mOut.m03 = m1.m03 - m2.m03;
        mOut.m10 = m1.m10 - m2.m10;    mOut.m11 = m1.m11 - m2.m11;    mOut.m12 = m1.m12 - m2.m12;   mOut.m13 = m1.m13 - m2.m13;
        mOut.m20 = m1.m20 - m2.m20;    mOut.m21 = m1.m21 - m2.m21;    mOut.m22 = m1.m22 - m2.m22;   mOut.m23 = m1.m23 - m2.m23;
        mOut.m30 = m1.m30 - m2.m30;    mOut.m31 = m1.m31 - m2.m31;    mOut.m32 = m1.m32 - m2.m32;   mOut.m33 = m1.m33 - m2.m33;
    }
    __FORCE_INLINE__ void _MATH_LIB_EXPORT_  XMatrix_Add(XMatrix& m1,XMatrix& m2,XMatrix& mOut)
    {
        mOut.m00 = m1.m00 + m2.m00;    mOut.m01 = m1.m01 + m2.m01;    mOut.m02 = m1.m02 + m2.m02;   mOut.m03 = m1.m03 + m2.m03;
        mOut.m10 = m1.m10 + m2.m10;    mOut.m11 = m1.m11 + m2.m11;    mOut.m12 = m1.m12 + m2.m12;   mOut.m13 = m1.m13 + m2.m13;
        mOut.m20 = m1.m20 + m2.m20;    mOut.m21 = m1.m21 + m2.m21;    mOut.m22 = m1.m22 + m2.m22;   mOut.m23 = m1.m23 + m2.m23;
        mOut.m30 = m1.m30 + m2.m30;    mOut.m31 = m1.m31 + m2.m31;    mOut.m32 = m1.m32 + m2.m32;   mOut.m33 = m1.m33 + m2.m33;
    }

    //---------------------------------------------------------------------------------
    //矩阵和常数相乘
    //---------------------------------------------------------------------------------
    __FORCE_INLINE__ void _MATH_LIB_EXPORT_  XMatrix_Mul(XMatrix& m1,float s,XMatrix& mOut)
    {
        
        mOut.m00 = m1.m00 * s; mOut.m01 = m1.m01 * s; mOut.m02 = m1.m02 * s;mOut.m03 = m1.m03 * s;
        mOut.m10 = m1.m10 * s; mOut.m11 = m1.m11 * s; mOut.m12 = m1.m12 * s;mOut.m13 = m1.m13 * s;
        mOut.m20 = m1.m20 * s; mOut.m21 = m1.m21 * s; mOut.m22 = m1.m22 * s;mOut.m23 = m1.m23 * s;
        mOut.m30 = m1.m30 * s; mOut.m31 = m1.m31 * s; mOut.m32 = m1.m32 * s;mOut.m33 = m1.m33 * s;
    }

    __FORCE_INLINE__ void _MATH_LIB_EXPORT_  XMatrix_Mul(XMatrix3x3& m1,float s,XMatrix3x3& mOut)
    {
        mOut.m00 = m1.m00 * s; mOut.m01 = m1.m01 * s; mOut.m02 = m1.m02 * s;
        mOut.m10 = m1.m10 * s; mOut.m11 = m1.m11 * s; mOut.m12 = m1.m12 * s;
        mOut.m20 = m1.m20 * s; mOut.m21 = m1.m21 * s; mOut.m22 = m1.m22 * s;
    }

    /*
    *	两个矩阵相乘
    */
    __FORCE_INLINE__ void	_MATH_LIB_EXPORT_ XMatrix_Mul(XMatrix3x3& m1,XMatrix3x3& m2,XMatrix3x3& mOut)
    {
        for(int r =0 ; r < 4 ; r++)
        {
            mOut.m[r][0] = m1.m[r][0] * m2.m[0][0] + 
                m1.m[r][1] * m2.m[1][0] +
                m1.m[r][2] * m2.m[2][0] ;

            mOut.m[r][1] = m1.m[r][0] * m2.m[0][1] + 
                m1.m[r][1] * m2.m[1][1] +
                m1.m[r][2] * m2.m[2][1];

            mOut.m[r][2] = m1.m[r][0] * m2.m[0][2] + 
                m1.m[r][1] * m2.m[1][2] +
                m1.m[r][2] * m2.m[2][2];
        }
    }

    __FORCE_INLINE__ void	_MATH_LIB_EXPORT_ XMatrix_Mul(XVector3D& v,XMatrix3x3& m,XVector3D& vOut)
    {
        vOut.x = v.x * m.m[0][0] + v.y * m.m[1][0] + v.z * m.m[2][0];
        vOut.y = v.x * m.m[0][1] + v.y * m.m[1][1] + v.z * m.m[2][1];
        vOut.z = v.x * m.m[0][2] + v.y * m.m[1][2] + v.z * m.m[2][2];
    }

    __FORCE_INLINE__ void	_MATH_LIB_EXPORT_ XMatrix_Mul(XMatrix3x3& m,XVector3D& v,XVector3D& vOut)
    {
        vOut.x = m.m[0][0] * v.x + m.m[0][1] * v.y + m.m[0][2] * v.z ;
        vOut.y = m.m[1][0] * v.x + m.m[1][1] * v.y + m.m[1][2] * v.z ;
        vOut.z = m.m[2][0] * v.x + m.m[2][1] * v.y + m.m[2][2] * v.z ;
    }


    __FORCE_INLINE__ void	_MATH_LIB_EXPORT_ XMatrix_Transpos(XMatrix3x3&m , XMatrix3x3& mOut)
    {
        for(int r = 0 ;  r < 3 ; r ++)
        {
            mOut.m[0][r] = m.m[r][0];
            mOut.m[1][r] = m.m[r][1];
            mOut.m[2][r] = m.m[r][2];
        }

    }



    //---------------------------------------------------------------------------------
    //	两个矩阵相乘
    //  This function is tested by Stanly Lee at 2003-11
    //---------------------------------------------------------------------------------
    __FORCE_INLINE__ void _MATH_LIB_EXPORT_ XMatrix_Mul(XMatrix& m1,XMatrix& m2,XMatrix& mOut)
    {
        for(int r =0 ; r < 4 ; r++)
        {
            //展开了4个循环
            mOut.m[r][0] = m1.m[r][0] * m2.m[0][0] + 
                m1.m[r][1] * m2.m[1][0] +
                m1.m[r][2] * m2.m[2][0] +
                m1.m[r][3] * m2.m[3][0] ;

            mOut.m[r][1] = m1.m[r][0] * m2.m[0][1] + 
                m1.m[r][1] * m2.m[1][1] +
                m1.m[r][2] * m2.m[2][1] +
                m1.m[r][3] * m2.m[3][1] ;

            mOut.m[r][2] = m1.m[r][0] * m2.m[0][2] + 
                m1.m[r][1] * m2.m[1][2] +
                m1.m[r][2] * m2.m[2][2] +
                m1.m[r][3] * m2.m[3][2] ;


            mOut.m[r][3] = m1.m[r][0] * m2.m[0][3] + 
                m1.m[r][1] * m2.m[1][3] +
                m1.m[r][2] * m2.m[2][3] +
                m1.m[r][3] * m2.m[3][3] ;

        }

        return ;
    }

    //---------------------------------------------------------------------------------
    //	一个向量乘矩阵
    //---------------------------------------------------------------------------------
    __FORCE_INLINE__ void _MATH_LIB_EXPORT_ XMatrix_Mul(XVector& v,XMatrix& m,XVector& vOut)
    {
        vOut.x =  v.x * m.m[0][0] +
            v.y * m.m[1][0] +
            v.z * m.m[2][0] +
            v.w * m.m[3][0] ; 

        vOut.y =  v.x * m.m[0][1] +
            v.y * m.m[1][1] +
            v.z * m.m[2][1] +
            v.w * m.m[3][1] ; 

        vOut.z =  v.x * m.m[0][2] +
            v.y * m.m[1][2] +
            v.z * m.m[2][2] +
            v.w * m.m[3][2] ; 

        vOut.w =  v.x * m.m[0][3] +
            v.y * m.m[1][3] +
            v.z * m.m[2][3] +
            v.w * m.m[3][3] ; 
    }

    //---------------------------------------------------------------------------------
    //	一个向量乘矩阵
    //---------------------------------------------------------------------------------
    __FORCE_INLINE__ void _MATH_LIB_EXPORT_ XMatrix_Mul(XVector3D& v,XMatrix& m,XVector3D& vOut)
    {
        vOut.x =  v.x * m.m[0][0] +
                  v.y * m.m[1][0] +
                  v.z * m.m[2][0];


        vOut.y =  v.x * m.m[0][1] +
                  v.y * m.m[1][1] +
                  v.z * m.m[2][1];
    

        vOut.z =  v.x * m.m[0][2] +
                  v.y * m.m[1][2] +
                  v.z * m.m[2][2];

    }

    //---------------------------------------------------------------------------------
    //一个矩阵乘向量
    //This function is tested by Stanly Lee at 2003-11
    //---------------------------------------------------------------------------------
    __FORCE_INLINE__ void _MATH_LIB_EXPORT_ XMatrix_Mul(XMatrix& m,XVector& v,XVector& vOut)
    {
        vOut.x =  v.x * m.m[0][0] +
            v.y * m.m[0][1] +