_matrix33.h

奇迹世界公用文件源代码,研究网络游戏的朋友可以研究下

    _vector3 x(up * z);   // x = y cross z
    x.norm();
    _vector3 y = z * x;   // y = z cross x

    M11=x.x;  M12=x.y;  M13=x.z;
    M21=y.x;  M22=y.y;  M23=y.z;
    M31=z.x;  M32=z.y;  M33=z.z;
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::billboard(const _vector3& from, const _vector3& to, const _vector3& up)
{
    _vector3 z(from - to);
    z.norm();
    _vector3 y(up);
    y.norm();
    _vector3 x(y * z);
    z = x * y;

    M11=x.x;  M12=x.y;  M13=x.z;
    M21=y.x;  M22=y.y;  M23=y.z;
    M31=z.x;  M32=z.y;  M33=z.z;
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::set(float m11, float m12, float m13,
               float m21, float m22, float m23,
               float m31, float m32, float m33) 
{
    M11=m11; M12=m12; M13=m13;
    M21=m21; M22=m22; M23=m23;
    M31=m31; M32=m32; M33=m33;
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::set(const _vector3& v0, const _vector3& v1, const _vector3& v2) 
{
    M11=v0.x; M12=v0.y; M13=v0.z;
    M21=v1.x; M22=v1.y; M23=v1.z;
    M31=v2.x; M32=v2.y; M33=v2.z;
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::set(const _matrix33& m1) 
{
    memcpy(m, &(m1.m), 9*sizeof(float));
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::ident() 
{
    memcpy(&(m[0][0]), _matrix33_ident, sizeof(_matrix33_ident));
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::transpose() 
{
    #undef n_swap
    #define n_swap(x,y) { float t=x; x=y; y=t; }
    n_swap(m[0][1],m[1][0]);
    n_swap(m[0][2],m[2][0]);
    n_swap(m[1][2],m[2][1]);
}

//------------------------------------------------------------------------------
/**
*/
inline
bool 
_matrix33::orthonorm(float limit) 
{
    if (((M11*M21+M12*M22+M13*M23)<limit) &&
        ((M11*M31+M12*M32+M13*M33)<limit) &&
        ((M31*M21+M32*M22+M33*M23)<limit) &&
        ((M11*M11+M12*M12+M13*M13)>(1.0-limit)) &&
        ((M11*M11+M12*M12+M13*M13)<(1.0+limit)) &&
        ((M21*M21+M22*M22+M23*M23)>(1.0-limit)) &&
        ((M21*M21+M22*M22+M23*M23)<(1.0+limit)) &&
        ((M31*M31+M32*M32+M33*M33)>(1.0-limit)) &&
        ((M31*M31+M32*M32+M33*M33)<(1.0+limit)))
        return true;
    else
        return false;
}

//------------------------------------------------------------------------------
/**
*/
inline
void
_matrix33::scale(const _vector3& s)
{
    int i;
    for (i=0; i<3; i++) {
        m[i][0] *= s.x;
        m[i][1] *= s.y;
        m[i][2] *= s.z;
    }
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::rotate_x(const float a)
{
    float c = n_cos(a);
    float s = n_sin(a);
    int i;
    for (i=0; i<3; i++)
    {
        float mi1 = m[i][1];
        float mi2 = m[i][2];
        m[i][1] = mi1*c + mi2*-s;
        m[i][2] = mi1*s + mi2*c;
    }
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::rotate_y(const float a)
{
    float c = n_cos(a);
    float s = n_sin(a);
    int i;
    for (i=0; i<3; i++)
    {
        float mi0 = m[i][0];
        float mi2 = m[i][2];
        m[i][0] = mi0*c + mi2*s;
        m[i][2] = mi0*-s + mi2*c;
    }
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::rotate_z(const float a)
{
    float c = n_cos(a);
    float s = n_sin(a);
    int i;
    for (i=0; i<3; i++)
    {
        float mi0 = m[i][0];
        float mi1 = m[i][1];
        m[i][0] = mi0*c + mi1*-s;
        m[i][1] = mi0*s + mi1*c;
    }
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::rotate_local_x(const float a)
{
    _matrix33 rotM;  // initialized as identity matrix
	rotM.M22 = (float) cos(a); rotM.M23 = -(float) sin(a);
	rotM.M32 = (float) sin(a); rotM.M33 =  (float) cos(a);

	(*this) = rotM * (*this); 
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::rotate_local_y(const float a)
{
    _matrix33 rotM;  // initialized as identity matrix
	rotM.M11 = (float) cos(a);  rotM.M13 = (float) sin(a);
    rotM.M31 = -(float) sin(a); rotM.M33 = (float) cos(a);

	(*this) = rotM * (*this); 
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::rotate_local_z(const float a)
{
    _matrix33 rotM;  // initialized as identity matrix
    rotM.M11 = (float) cos(a); rotM.M12 = -(float) sin(a);
	rotM.M21 = (float) sin(a); rotM.M22 =  (float) cos(a);

	(*this) = rotM * (*this); 
}

//------------------------------------------------------------------------------
/**
*/
inline
void 
_matrix33::rotate(const _vector3& vec, float a)
{
    _vector3 v(vec);
    v.norm();
    float sa = (float) n_sin(a);
    float ca = (float) n_cos(a);

	_matrix33 rotM;
	rotM.M11 = ca + (1.0f - ca) * v.x * v.x;
	rotM.M12 = (1.0f - ca) * v.x * v.y - sa * v.z;
	rotM.M13 = (1.0f - ca) * v.z * v.x + sa * v.y;
	rotM.M21 = (1.0f - ca) * v.x * v.y + sa * v.z;
	rotM.M22 = ca + (1.0f - ca) * v.y * v.y;
	rotM.M23 = (1.0f - ca) * v.y * v.z - sa * v.x;
	rotM.M31 = (1.0f - ca) * v.z * v.x - sa * v.y;
	rotM.M32 = (1.0f - ca) * v.y * v.z + sa * v.x;
	rotM.M33 = ca + (1.0f - ca) * v.z * v.z;
	
	(*this) = (*this) * rotM;
}

//------------------------------------------------------------------------------
/**
*/
inline
_vector3 
_matrix33::x_component() const
{
    _vector3 v(M11,M12,M13);
    return v;
}

//------------------------------------------------------------------------------
/**
*/
inline
_vector3 
_matrix33::y_component(void) const
{
    _vector3 v(M21,M22,M23);
    return v;
}

//------------------------------------------------------------------------------
/**
*/
inline
_vector3 
_matrix33::z_component(void) const 
{
    _vector3 v(M31,M32,M33);
    return v;
};

//------------------------------------------------------------------------------
/**
*/
inline
void
_matrix33::operator *= (const _matrix33& m1) 
{
    int i;
    for (i=0; i<3; i++) {
        float mi0 = m[i][0];
        float mi1 = m[i][1];
        float mi2 = m[i][2];
        m[i][0] = mi0*m1.m[0][0] + mi1*m1.m[1][0] + mi2*m1.m[2][0];
        m[i][1] = mi0*m1.m[0][1] + mi1*m1.m[1][1] + mi2*m1.m[2][1];
        m[i][2] = mi0*m1.m[0][2] + mi1*m1.m[1][2] + mi2*m1.m[2][2];
    };
}

//------------------------------------------------------------------------------
/**
    multiply source vector with matrix and store in destination vector
    this eliminates the construction of a temp _vector3 object
*/
inline
void 
_matrix33::mult(const _vector3& src, _vector3& dst) const
{
    dst.x = M11*src.x + M21*src.y + M31*src.z;
    dst.y = M12*src.x + M22*src.y + M32*src.z;
    dst.z = M13*src.x + M23*src.y + M33*src.z;
}

//------------------------------------------------------------------------------
/**
*/
inline
void
_matrix33::translate(const _vector2& t)
{
    M31 += t.x;
    M32 += t.y;
}

//------------------------------------------------------------------------------
#endif