Matrix44.h

Go to the documentation of this file.

// Dan  2/24/2004  \DanLP110\Include\Matrix44.h

#define __MATRIX44_H

#ifndef __VECTOR4_H
#include "Vector4.h"
#endif
#ifdef _SIMD
#include "smlmath.h"
#endif

class Quaternion;

// ************************** MATRIX44 ********************************

class MATRIXEXPORT Matrix44 {
protected:
#ifdef _SIMD
   union {
      struct { SMLMatrix4f m_smlmatrix4f; };
      struct { Vector4 v[4]; };
   };
#else
   Vector4 v[4];
#endif

public:
   Matrix44() {}
   Matrix44( const Matrix44 &m );
   Matrix44( float fill )
   {
      v[0].Set( fill );
      v[1].Set( fill );
      v[2].Set( fill );
      v[3].Set( fill );
   }
   Matrix44( const Vector4 &v0, const Vector4 &v1, const Vector4 &v2, const Vector4 &v3 )
   {
      v[0] = v0;
      v[1] = v1;
      v[2] = v2;
      v[3] = v3;
   }
   Matrix44(const Quaternion &quat);
   
   Matrix44 &operator *= ( const Matrix44 &other ) { return *this = *this * other; }
   const Vector4 &operator[]( int row ) const { return v[row]; }
   Vector4 &operator[]( int row ) { return v[row]; }

   void SetIdentity();
   Matrix44 Transpose() const;
   Matrix44 Inverse() const;
   
   Matrix44 operator * ( const Matrix44 &b ) const;
   Vector operator * ( const Vector &v ) const;
   Vector4 operator * ( const Vector4 &v ) const;
   friend MATRIXEXPORT Matrix44 Identity44();
};

#ifdef _SIMD

inline Matrix44::Matrix44( const Matrix44 &m )
{
   m_smlmatrix4f = m.m_smlmatrix4f;
}

inline void Matrix44::SetIdentity()
{
   m_smlmatrix4f.Identity();
}

inline Matrix44 Matrix44::Transpose() const
{
   Matrix44 temp( *this );
   temp.m_smlmatrix4f.Transpose();
   return temp;
}

inline Matrix44 Matrix44::Inverse() const
{
   Matrix44 result, source=*this;
   result.m_smlmatrix4f.Invert(source.m_smlmatrix4f);  // BUG IN SML, SOURCE SHOULD BE DECLARED CONST
   return result;
}

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

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

inline Vector4 Matrix44::operator * ( const Vector4 &v ) const
{
   Vector4 result;
   m_smlmatrix4f.Transform( v.m_smlvec4f, result.m_smlvec4f );
   return result;
}

inline MATRIXEXPORT Matrix44 Identity44()
{
   Matrix44 result;
   result.m_smlmatrix4f.Identity();
   return result;
}

#else  // not SIMD

inline Matrix44::Matrix44( const Matrix44 &m )
{
   v[0] = m.v[0];
   v[1] = m.v[1];
   v[2] = m.v[2];
   v[3] = m.v[3];
}

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

inline Matrix44 Matrix44::Transpose() const
{
   return Matrix44( Vector4( v[0][0], v[1][0], v[2][0], v[3][0] ),
                    Vector4( v[0][1], v[1][1], v[2][1], v[3][1] ),
                    Vector4( v[0][2], v[1][2], v[2][2], v[3][2] ),
                    Vector4( v[0][3], v[1][3], v[2][3], v[3][3] ));
}

inline Vector Matrix44::operator * ( const Vector &vec ) const
{
   Vector4 vec4( vec.x, vec.y, vec.z, 1.0f );
   return Vector( v[0]|vec4, v[1]|vec4, v[2]|vec4 );
}

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

inline MATRIXEXPORT Matrix44 Identity44()
{
   return Matrix44( Vector4( 1.f, 0.f, 0.f, 0.f ),
                    Vector4( 0.f, 1.f, 0.f, 0.f ),
                    Vector4( 0.f, 0.f, 1.f, 0.f ),
                    Vector4( 0.f, 0.f, 0.f, 1.f ));
}

#endif  // not SIMD

---