Matrix33.h

Go to the documentation of this file.

// BC  10/14/2004  \BobL115\Include\Matrix33.h

#define __MATRIX33_H

#ifndef __VECTOR2_H
#include "Vector2.h"
#endif
#ifndef __EXPORTS_H
#include "Exports.h"
#endif
#ifndef __FILECONS_H
#include "FileCons.h"
#endif

#ifdef _SIMD
#include "smlmath.h"
#endif

class Quaternion;
class Matrix44;

class MATRIXEXPORT Matrix33 
{
protected:
#ifdef _SIMD
   union {
      struct { SMLMatrix3f m_smlmatrix3f; };
      struct { Vector v[3]; };
   };
#else
   Vector v[3];
#endif

public:
   Matrix33() {}
   Matrix33( const Matrix33 &other );
   Matrix33( const Quaternion &q );
   Matrix33( const Vector &v0, const Vector &v1, const Vector &v2 )
   {
      v[0] = v0;
      v[1] = v1;
      v[2] = v2;
   }
   Matrix33( float fill )
   {
      Set( fill );
   }

   Matrix33 &operator = ( const Matrix33 &other );
   Matrix33 &operator *= ( const Matrix33 &other ) { return (*this = *this * other); }
   const Vector &operator[]( int row ) const { return v[row]; }
   Vector &operator[]( int row ) { return v[row]; }
   void SetIdentity();
   Matrix33 Transpose() const;
   void TransposeSelf();
   Matrix33 Inverse() const;
   Vector GetXAxis() const { return Vector( v[0][0], v[1][0], v[2][0] ); }
   Vector GetYAxis() const { return Vector( v[0][1], v[1][1], v[2][1] ); }
   Vector GetZAxis() const { return Vector( v[0][2], v[1][2], v[2][2] ); }
#ifdef _SIMD
   SMLMatrix3f &GetSMLMatrix3f() { return m_smlmatrix3f; }
#endif

   Matrix33 operator * ( const Matrix33 &b ) const;
   Vector operator * ( const Vector &v ) const;
   friend MATRIXEXPORT Vector2 operator * ( const Matrix33 &m, const Vector2 &v );
   friend MATRIXEXPORT Matrix33 Identity33( void );
   void Set( float fill )
   {
      v[0].Set( fill );
      v[1].Set( fill );
      v[2].Set( fill );
   }
   void SetTranslate( const Vector2 &t )
   {
      v[0][3] = t.x;
      v[1][3] = t.y;
      v[2][3] = 1.0f;
   }
   void MakeOrthogonal()
   {
      Matrix33 a = Transpose();  // move the column vectors to the rows
      Matrix33 b;
      
      b[0] = a[0];
      b[0].Normalize();
      b[1] = a[2] ^ a[0];
      b[1].Normalize();
      b[2] = b[0] ^ b[1];

      b[0] = a[0];
      b[1] *= a[1].Norm();
      b[2] *= a[2].Norm();
      
      *this = b.Transpose();
   }

   friend MATRIXEXPORT Matrix33 RotateVRadians33( float angle, const Vector &axis );
   friend MATRIXEXPORT Matrix33 XYRotateRadians33( float xangle, float yangle );
   friend MATRIXEXPORT Matrix33 YXRotateRadians33( float yangle, float xangle );
   friend MATRIXEXPORT Matrix33 ZXRotateRadians33( float zangle, float xangle );
   friend MATRIXEXPORT Matrix33 YXZRotateRadians33( float yangle, float xangle, float zangle );
   friend MATRIXEXPORT Matrix33 ZXZRotateRadians33( float zangl1, float xangle, float zangl2 );
   friend /* inline */ Matrix33 XRotate33( float angle );
   friend /* inline */ Matrix33 YRotate33( float angle );
   friend /* inline */ Matrix33 ZRotate33( float angle );
   friend /* inline */ Matrix33 YXRotate33( float yangle, float xangle );
   friend /* inline */ Matrix33 ZXRotate33( float zangle, float xangle );
   friend /* inline */ Matrix33 YXZRotate33( float yangle, float xangle, float zangle );
   friend /* inline */ Matrix33 ZXZRotate33( float zangl1, float xangle, float zangl2 );
   friend /* inline */ Matrix33 RotateV33( float angle, const Vector &axis );
   friend MATRIXEXPORT Matrix33 Rotate2V33( const Vector &from, const Vector &to );
   friend /* inline */ Matrix33 XRotateRadians33( float anglerad );
   friend /* inline */ Matrix33 YRotateRadians33( float anglerad );
   friend /* inline */ Matrix33 ZRotateRadians33( float anglerad );
   friend /* inline */ Matrix33 VectorsToStandard33( const Vector &becomezdir, const Vector &becomeydir );
   
};

inline Matrix33 XRotate33( float angle )                                { return XRotateRadians33( angle / RADIANS ); }
inline Matrix33 YRotate33( float angle )                                { return YRotateRadians33( angle / RADIANS ); }
inline Matrix33 ZRotate33( float angle )                                { return ZRotateRadians33( angle / RADIANS ); }
inline Matrix33 YXRotate33( float yangle, float xangle )                { return YXRotateRadians33( yangle/RADIANS, xangle/RADIANS ); }
inline Matrix33 ZXRotate33( float zangle, float xangle )                { return ZXRotateRadians33( zangle/RADIANS, xangle/RADIANS ); }
inline Matrix33 YXZRotate33( float yangle, float xangle, float zangle ) { return YXZRotateRadians33( yangle/RADIANS, xangle/RADIANS, zangle/RADIANS ); }
inline Matrix33 ZXZRotate33( float zangl1, float xangle, float zangl2 ) { return ZXZRotateRadians33( zangl1/RADIANS, xangle/RADIANS, zangl2/RADIANS ); }
inline Matrix33 RotateV33( float angle, const Vector &axis )            { return RotateVRadians33( angle / RADIANS, axis ); }

inline Matrix33 XRotateRadians33( float anglerad )
{
    float ca = (float)cos( anglerad ),
        sa = (float)sin( anglerad );
    return Matrix33( Vector( 1.f, 0.f, 0.f ),
                    Vector( 0.f,  ca, -sa ),
                    Vector( 0.f,  sa,  ca ));
}

inline Matrix33 YRotateRadians33( float anglerad )
{
    float ca = (float)cos( anglerad ),
        sa = (float)sin( anglerad );
    return Matrix33( Vector(  ca, 0.f,  sa ),
                    Vector( 0.f, 1.f, 0.f ),
                    Vector( -sa, 0.f,  ca ));
}

inline Matrix33 ZRotateRadians33( float anglerad )
{
    float ca = (float)cos( anglerad ),
        sa = (float)sin( anglerad );
    return Matrix33( Vector(  ca, -sa, 0.f ),
                    Vector(  sa,  ca, 0.f ),
                    Vector( 0.f, 0.f, 1.f ));
}
inline Matrix33 VectorsToStandard33( const Vector &becomezdir, const Vector &becomeydir )
{
    Matrix33 vectostandard = Rotate2V33( becomezdir, Vector( 0.0f, 0.0f, 1.0f ));
    Vector   rollvec = vectostandard * becomeydir;
    float    roll = (float)atan2( -rollvec.x, rollvec.y );
    if ( roll )
        vectostandard = ZRotateRadians33( -roll ) * vectostandard;
    return vectostandard;
}

inline Vector &Vector::operator *= ( const Matrix33 &m )
{
   *this =  m * (*this);
   return *this;
}

#ifdef _SIMD

inline Matrix33::Matrix33( const Matrix33 &other )
{
   m_smlmatrix3f = other.m_smlmatrix3f;
}

inline Matrix33 &Matrix33::operator = ( const Matrix33 &other )
{
   m_smlmatrix3f = other.m_smlmatrix3f;
   return *this;
}

inline void Matrix33::SetIdentity()
{
   m_smlmatrix3f.Identity();
}

inline Matrix33 Matrix33::Transpose() const
{
   Matrix33 temp( *this );
   temp.m_smlmatrix3f.Transpose();
   return temp;
}

inline void Matrix33::TransposeSelf()
{
   m_smlmatrix3f.Transpose();
}

inline Matrix33 Matrix33::operator * ( const Matrix33 &b ) const
{
   Matrix33 result;
   result.m_smlmatrix3f.Multiply(m_smlmatrix3f, b.m_smlmatrix3f);
   return result;
}

inline Vector Matrix33::operator * ( const Vector &v ) const
{
   Vector result;
   m_smlmatrix3f.TransformPoint( v.m_smlvec3f, result.m_smlvec3f );
   return result;
}

inline MATRIXEXPORT Matrix33 Identity33( void )
{
   Matrix33 result;
   result.m_smlmatrix3f.Identity();
   return result;
}

#else  // not SIMD

inline Matrix33::Matrix33( const Matrix33 &m )
{
   *this = m;
}

inline Matrix33 &Matrix33::operator = ( const Matrix33 &m )
{
   v[0] = m.v[0];
   v[1] = m.v[1];
   v[2] = m.v[2];
   return *this;
}

inline void Matrix33::SetIdentity()
{
   v[0].Set(1.0f, 0.0f, 0.0f);
   v[1].Set(0.0f, 1.0f, 0.0f);
   v[2].Set(0.0f, 0.0f, 1.0f);
}

inline Matrix33 Matrix33::Transpose() const
{
   return Matrix33( Vector( v[0][0], v[1][0], v[2][0] ),
                    Vector( v[0][1], v[1][1], v[2][1] ),
                    Vector( v[0][2], v[1][2], v[2][2] ));
}

inline void Matrix33::TransposeSelf()
{
   *this = Transpose();
}

inline Vector Matrix33::operator * ( const Vector &vec ) const
{
   return Vector( v[0]|vec, v[1]|vec, v[2]|vec );
}

inline MATRIXEXPORT Matrix33 Identity33( void )
{
   return Matrix33( Vector( 1.f, 0.f, 0.f ),
                    Vector( 0.f, 1.f, 0.f ),
                    Vector( 0.f, 0.f, 1.f ));
}

#endif // not SIMD

---