Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

Matrix.cpp

Go to the documentation of this file.
00001 #include <math.h>
00002 #include "Matrix.h"
00003 #include "vuVector.h"
00004 
00005 #define PI_OVER_180 0.01745329251994
00006 
00007 // Default constructor - set initial values
00008 Matrix::Matrix()
00009 {
00010     for(int i=0;i<16;++i)
00011         val[i] = 0.0f;
00012 }
00013 
00014 // Copy constructor
00015 Matrix::Matrix(const Matrix& m)
00016 {
00017     for(int i=0;i<16;++i)
00018         val[i] = m.val[i];
00019 }
00020 
00021 // Constructor - set all values to v
00022 Matrix::Matrix(const float v)
00023 {
00024     for(int i=0;i<16;++i)
00025         val[i] = v;
00026 }
00027 
00028 // Constructor - get values from an array
00029 Matrix::Matrix(const float* v)
00030 {
00031     for(int i=0;i<16;++i)
00032         val[i] = v[i];
00033 }
00034 
00035 // Destructor
00036 Matrix::~Matrix()
00037 {
00038 }
00039 
00040 // Make the current matrix the identity matrix
00041 Matrix& Matrix::MakeIdentity(void)
00042 {
00043     for(int i=1;i<15;++i)
00044         val[i] = 0.0f;
00045     val[0] = val[5] = val[10] = val[15] = 1.0f;
00046     return *this;
00047 }
00048 
00049 Matrix& Matrix::MakeRotate(vuVector& axis, float a)
00050 {
00051         vuVector axis2;
00052         float s;
00053         float c;
00054 
00055         s = (float)sin(a*PI_OVER_180);
00056         c = (float)cos(a*PI_OVER_180);
00057         axis2 = axis.Mul(axis);
00058 
00059         val[0] = axis2[0]+(1.0f-axis2[0])*c;
00060         val[1] = axis[0]*axis[1]*(1.0f-c)+axis[2]*s;
00061         val[2] = axis[0]*axis[2]*(1.0f-c)-axis[1]*s;
00062     val[3] = 0.0f;
00063 
00064         val[4] = axis[0]*axis[1]*(1.0f-c)-axis[2]*s;
00065         val[5] = axis2[1]+(1.0f-axis2[1])*c;
00066         val[6] = axis[1]*axis[2]*(1.0f-c)+axis[0]*s;
00067     val[7] = 0.0f;
00068 
00069         val[8]  = axis[0]*axis[2]*(1.0f-c)+axis[1]*s;
00070         val[9]  = axis[1]*axis[2]*(1.0f-c)-axis[0]*s;
00071         val[10] = axis2[2]+(1.0f-axis2[2])*c;
00072     val[11] = 0.0f;
00073 
00074     val[12] = 0.0f;
00075     val[13] = 0.0f;
00076     val[14] = 0.0f;
00077         val[15] = 1.0f;
00078 
00079     return *this;
00080 }
00081 
00082 Matrix& Matrix::MakeRotateX(float a)
00083 {
00084     MakeIdentity();
00085     val[5] = val[10] = (float)cos((double)a*PI_OVER_180);
00086     val[9] = -(val[6] = (float)sin((double)a*PI_OVER_180));
00087     return *this;
00088 }
00089 
00090 Matrix& Matrix::MakeRotateY(float a)
00091 {
00092     MakeIdentity();
00093     val[0] = val[10] = (float)cos((double)a*PI_OVER_180);
00094     val[2] = -(val[8] = (float)sin((double)a*PI_OVER_180));
00095     return *this;
00096 }
00097 
00098 Matrix& Matrix::MakeRotateZ(float a)
00099 {
00100     MakeIdentity();
00101     val[0] = val[5] = (float)cos((double)a*PI_OVER_180);
00102     val[4] = -(val[1] = (float)sin((double)a*PI_OVER_180));
00103     return *this;
00104 }
00105 
00106 Matrix& Matrix::MakeTranslate(float x, float y, float z)
00107 {
00108     MakeIdentity();
00109     val[12] = x;
00110     val[13] = y;
00111     val[14] = z;
00112     return *this;
00113 }
00114 
00115 Matrix& Matrix::MakeScale(float x, float y, float z)
00116 {
00117     MakeIdentity();
00118     val[0] = x;
00119     val[5] = y;
00120     val[10] = z;
00121     return *this;
00122 }
00123 
00124 Matrix& Matrix::MakeShearXY(float s)
00125 {
00126     MakeIdentity();
00127     val[1] = s;
00128     return *this;
00129 }
00130 
00131 Matrix& Matrix::MakeShearXZ(float s)
00132 {
00133     MakeIdentity();
00134     val[2] = s;
00135     return *this;
00136 }
00137 
00138 Matrix& Matrix::MakeShearYX(float s)
00139 {
00140     MakeIdentity();
00141     val[4] = s;
00142     return *this;
00143 }
00144 
00145 Matrix& Matrix::MakeShearYZ(float s)
00146 {
00147     MakeIdentity();
00148     val[6] = s;
00149     return *this;
00150 }
00151 
00152 Matrix& Matrix::MakeShearZX(float s)
00153 {
00154     MakeIdentity();
00155     val[8] = s;
00156     return *this;
00157 }
00158 
00159 Matrix& Matrix::MakeShearZY(float s)
00160 {
00161     MakeIdentity();
00162     val[9] = s;
00163     return *this;
00164 }
00165 
00166 Matrix& Matrix::MakeReflectX(void)
00167 {
00168     MakeIdentity();
00169     val[0] = -1.0f;
00170     return *this;
00171 }
00172 
00173 Matrix& Matrix::MakeReflectY(void)
00174 {
00175     MakeIdentity();
00176     val[5] = -1.0f;
00177     return *this;
00178 }
00179 
00180 Matrix& Matrix::MakeReflectZ(void)
00181 {
00182     MakeIdentity();
00183     val[10] = -1.0f;
00184     return *this;
00185 }
00186 
00187 Matrix& Matrix::MakePerspective(float d)
00188 {
00189     MakeIdentity();
00190     val[10] = 0.0f;
00191     val[11] = 1.0f/d;
00192     return *this;
00193 }
00194 
00195 Matrix& Matrix::MakePerspectiveKeepZ(float d)
00196 {
00197     MakeIdentity();
00198     val[11] = 1.0f/d;
00199     return *this;
00200 }
00201 
00202 // Assignment operator
00203 Matrix& Matrix::operator=(const Matrix& m)
00204 {
00205     if (this != &m)
00206     {
00207         for(int i=0;i<16;++i)
00208             val[i] = m.val[i];
00209     }
00210     return *this;
00211 }
00212 
00213 // Assignment operator - set all values to v
00214 Matrix& Matrix::operator=(const float& v)
00215 {
00216     for(int i=0;i<16;++i)
00217         val[i] = v;
00218     return *this;
00219 }
00220 
00221 // Assignment operator - get values from an array
00222 Matrix& Matrix::operator=(const float* v)
00223 {
00224     for(int i=0;i<16;++i)
00225         val[i] = v[i];
00226     return *this;
00227 }
00228 
00229 // Access operator - get col at the given index
00230 float* Matrix::operator[](unsigned int index)
00231 {
00232 //    if (index > 3)
00233 //        throw "Matrix: Index out of range.";
00234     return &val[index*4];
00235 }
00236 
00237 // Return the internal data pointer.
00238 float* Matrix::GetData(void)
00239 {
00240     return val;
00241 }
00242 
00243 // Addition operator
00244 Matrix Matrix::operator+(Matrix& m)
00245 {
00246     Matrix r;
00247     for(int i=0;i<16;++i)
00248         r.val[i] = val[i] + m.val[i];
00249     return r;
00250 }
00251 
00252 // Subtraction operator
00253 Matrix Matrix::operator-(Matrix& m)
00254 {
00255     Matrix r;
00256     for(int i=0;i<16;++i)
00257         r.val[i] = val[i] - m.val[i];
00258     return r;
00259 }
00260 
00261 // Multiplication operator - matrix*matrix
00262 Matrix Matrix::operator*(Matrix& m)
00263 {
00264     Matrix r;
00265     int i, j, k;
00266     for(i=0;i<4;++i)
00267         for(j=0;j<4;++j)
00268             for(k=0;k<4;++k)
00269                 r.val[(j<<2)+i] += val[(k<<2)+i] * m.val[(j<<2)+k];
00270     return r;
00271 }
00272 
00273 // Multiplication operator - matrix*vector -> vector
00274 vuVector Matrix::operator*(vuVector& v)
00275 {
00276     vuVector r;
00277     int i, j;
00278     r[3] = (float)(0.0);
00279     for(i=0;i<4;++i)
00280         for(j=0;j<4;++j)
00281             r.val[i] += val[(j<<2)+i]*v.val[j];
00282     return r;
00283 }
00284 
00285 // Multiplication operator - matrix*scalar
00286 Matrix Matrix::operator*(float s)
00287 {
00288     Matrix r;
00289     for(int i=0;i<16;++i)
00290         r.val[i] = val[i] * s;
00291     return r;
00292 }
00293 
00294 // Multiplication operator - scalar*matrix
00295 Matrix operator*(float s, Matrix& m)
00296 {
00297     Matrix r;
00298     for(int i=0;i<16;++i)
00299         r.val[i] = m.val[i] * s;
00300     return r;
00301 }
00302 
00303 // Add then assign operator
00304 Matrix& Matrix::operator+=(Matrix& m)
00305 {
00306     for(int i=0;i<16;++i)
00307         val[i] += m.val[i];
00308     return *this;
00309 }
00310 
00311 // Subtract the assign operator
00312 Matrix& Matrix::operator-=(Matrix& m)
00313 {
00314     for(int i=0;i<16;++i)
00315         val[i] -= m.val[i];
00316     return *this;
00317 }
00318 
00319 // Multiply then assign operator - matrix*matrix
00320 Matrix& Matrix::operator*=(const Matrix& m)
00321 {
00322     Matrix r;
00323     int i, j, k;
00324     for(i=0;i<4;++i)
00325         for(j=0;j<4;++j)
00326             for(k=0;k<4;++k)
00327                  r.val[(j<<2)+i] += val[(k<<2)+i] * m.val[(j<<2)+k];
00328     return (*this=r);
00329 }
00330 
00331 // Multiply then assign operator - matrix*scalar
00332 Matrix& Matrix::operator*=(float s)
00333 {
00334     for(int i=0;i<16;++i)
00335         val[i] *= s;
00336     return *this;
00337 }
00338 
00339 // Equality operator
00340 bool Matrix::operator==(const Matrix& m) const
00341 {
00342     for(int i=0;i<16;++i)
00343         if (val[i] != m.val[i])
00344             return false;
00345     return true;
00346 }
00347 
00348 // Inequality operator
00349 bool Matrix::operator!=(const Matrix& m) const
00350 {
00351     return !(operator==(m));
00352 }

Generated on Wed Dec 15 21:20:29 2004 for vuVolume by  doxygen 1.3.9.1