00001 #include <math.h>
00002 #include "Matrix.h"
00003 #include "vuVector.h"
00004
00005 #define PI_OVER_180 0.01745329251994
00006
00007
00008 Matrix::Matrix()
00009 {
00010 for(int i=0;i<16;++i)
00011 val[i] = 0.0f;
00012 }
00013
00014
00015 Matrix::Matrix(const Matrix& m)
00016 {
00017 for(int i=0;i<16;++i)
00018 val[i] = m.val[i];
00019 }
00020
00021
00022 Matrix::Matrix(const float v)
00023 {
00024 for(int i=0;i<16;++i)
00025 val[i] = v;
00026 }
00027
00028
00029 Matrix::Matrix(const float* v)
00030 {
00031 for(int i=0;i<16;++i)
00032 val[i] = v[i];
00033 }
00034
00035
00036 Matrix::~Matrix()
00037 {
00038 }
00039
00040
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
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
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
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
00230 float* Matrix::operator[](unsigned int index)
00231 {
00232
00233
00234 return &val[index*4];
00235 }
00236
00237
00238 float* Matrix::GetData(void)
00239 {
00240 return val;
00241 }
00242
00243
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
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
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
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
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
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
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
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
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
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
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
00349 bool Matrix::operator!=(const Matrix& m) const
00350 {
00351 return !(operator==(m));
00352 }