scenegraph/matrix.h

   1 #ifndef AWFUL_SCENEGRAPH_MATRIX_H_
   2 #define AWFUL_SCENEGRAPH_MATRIX_H_
   3
   4 #include "vector3.h"
   5
   6 namespace sluggish
   7 {
   8         class Matrix
   9         {
  10                 public:
  11                         Vec3    right;
  12                         Vec3    up;
  13                         Vec3    back;
  14                         Vec3    pos;
  15
  16                         Matrix()
  17                         {
  18                                 identity();
  19                         }
  20
  21                         Matrix( const Vec3& _Right, const Vec3& _Up, const Vec3& _Back, const Vec3& _Pos )
  22                         {
  23                                 right = _Right;
  24                                 up = _Up;
  25                                 back =_Back;
  26                                 pos = _Pos;
  27                         }
  28
  29                         void identity()
  30                         {
  31                                 right = Vec3( 1.f, 0.f, 0.f);
  32                                 up      = Vec3( 0.f, 1.f, 0.f);
  33                                 back    = Vec3( 0.f, 0.f, 1.f);
  34                                 pos     = Vec3();
  35                         }
  36
  37                         // Matrix addition
  38                         friend Matrix operator+( const Matrix& a, const Matrix& b )
  39                         {
  40                                 return Matrix(  a.right + b.right,
  41                                                                         a.up + b.up,
  42                                                                         a.back + b.back,
  43                                                                         a.pos + b.pos );
  44                         }
  45
  46                         // Matrix substraction
  47                         friend Matrix operator-( const Matrix& a, const Matrix& b )
  48                         {
  49                                 return Matrix(  a.right - b.right,
  50                                                                         a.up - b.up,
  51                                                                         a.back - b.back,
  52                                                                         a.pos - b.pos );
  53                         }
  54
  55                         // Matrix multiplication
  56                         friend Matrix operator*( const Matrix& a, const Matrix& b );
  57
  58                         friend Matrix& operator*=( Matrix& a, const Matrix& b )
  59                         {
  60                                 a = a * b;
  61                                 return a;
  62                         }
  63
  64                         // Matrix multiplication by a scalar
  65                         friend Matrix operator*( const Matrix& m, float s )
  66                         {
  67                                 return Matrix(  m.right * s,
  68                                                                         m.up * s,
  69                                                                         m.back * s,
  70                                                                         m.pos * s );
  71                         }
  72
  73                         // Matrix multiplication by a scalar
  74                         friend Matrix operator*( float s, const Matrix& m )
  75                         {
  76                                 return Matrix(  m.right * s,
  77                                                                         m.up * s,
  78                                                                         m.back * s,
  79                                                                         m.pos * s );
  80                         }
  81
  82                         // Vector multiplication
  83                         friend Vec3 operator*( const Matrix& a, const Vec3& b )
  84                         {
  85                                 return b.x * a.right + b.y * a.up + b.z * a.back;
  86                         }
  87
  88                         // Vector multiplication
  89                         friend Vec3 operator*( const Vec3& b, const Matrix& a )
  90                         {
  91                                 return b.x * a.right + b.y * a.up + b.z * a.back;
  92                         }
  93
  94
  95                         // Vertex transformation
  96                         Vec3 transform( const Vec3& a ) const
  97                         {
  98                                 return ( *this * a ) + pos;
  99                         }
 100
 101                         bool inverse( Matrix* _pResult ) const;
 102
 103                         // Setup the rotation part of the matrix as a lookat matrix
 104                         void lookAt( const Vec3& _Back, const Vec3& _Up );
 105
 106                         // Setup the translation part of the matrix
 107                         void translation( const Vec3& _Trans )
 108                         {
 109                                 pos = _Trans;
 110                         }
 111
 112                         // Setup the matrix as a rotation of a given angle around a given direction
 113                         void rotation( float _Angle, const Vec3& _Dir );
 114
 115                         // Load the matrix to opengl
 116                         void load() const;
 117
 118                         // Multiply the  matrix with the current opengl matrix
 119                         void mult() const;
 120         };
 121 }
 122
 123 #endif