← Back to branch summary

~hikiko/nux/arb-srgba-shader

« back to all changes in this revision

Viewing changes to NuxCore/Math/Matrix3.h

  • Committer: Neil Jagdish Patel
  • Date: 2010-09-01 19:25:37 UTC
  • Revision ID: neil.patel@canonical.com-20100901192537-mfz7rm6q262pewg6
Import and build NuxCore

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxCore/Math/Matrix3.h
 
1
#ifndef MATRIX3_H
 
2
#define MATRIX3_H
 
3
 
 
4
 
 
5
#include "Vector3.h"
 
6
 
 
7
NAMESPACE_BEGIN
 
8
 
 
9
template<typename T>
 
10
class Matrix3x3
 
11
{
 
12
public:
 
13
    Matrix3x3<T>();
 
14
    ~Matrix3x3();
 
15
 
 
16
    Matrix3x3(const Matrix3x3<T>&);
 
17
    Matrix3x3<T>(
 
18
        T a00, T a01, T a02, 
 
19
        T a10, T a11, T a12,
 
20
        T a20, T a21, T a22);
 
21
 
 
22
    Matrix3x3<T>&   operator = (const Matrix3x3<T>&);
 
23
    t_bool          operator == (const Matrix3x3<T>&);
 
24
    Matrix3x3<T>    operator * (const Matrix3x3<T>&) const;
 
25
    Matrix3x3<T>    operator + (const Matrix3x3<T>&) const;
 
26
    Matrix3x3<T>    operator - (const Matrix3x3<T>&) const;
 
27
    Matrix3x3<T>&   operator *= (const Matrix3x3<T>&) const;
 
28
    Matrix3x3<T>&   operator += (const Matrix3x3<T>&) const;
 
29
    Matrix3x3<T>&   operator -= (const Matrix3x3<T>&) const;
 
30
 
 
31
    Matrix3x3<T>    operator * (const T&) const;
 
32
    Matrix3x3<T>    operator / (const T&) const;
 
33
    Matrix3x3<T>&   operator *= (const T&) const;
 
34
    Matrix3x3<T>&   operator /= (const T&) const;
 
35
 
 
36
    Vec3<T>         operator * (const Vec3<T>&) const;  
 
37
        Matrix3x3<T>    operator - ();
 
38
 
 
39
    // Get the (i, j) element of the current matrix.
 
40
    T& operator()(unsigned int i, unsigned int j);
 
41
    T operator ()(unsigned int i, unsigned int j) const;
 
42
 
 
43
    T Determinant() const ;
 
44
    void Inverse();
 
45
    Matrix3x3<T> GetInverse() const;
 
46
 
 
47
    //Matrix2x2<T> GetUpper2x2() const;
 
48
 
 
49
    void Zero();
 
50
    void Identity();
 
51
 
 
52
    static Matrix3x3<T> IDENTITY();
 
53
    static Matrix3x3<T> ZERO();
 
54
        T m[3][3];
 
55
};
 
56
        
 
57
 
 
58
/***************************************************************************************\
 
59
Function:       Matrix3x3<T>::Matrix3x3
 
60
 
 
61
Description:    Constructor. Initialize the matrix to identity.
 
62
 
 
63
Parameters:     None.
 
64
 
 
65
Return Value:   None.
 
66
 
 
67
Comments:       None.
 
68
\***************************************************************************************/
 
69
template <typename T>
 
70
Matrix3x3<T>::Matrix3x3()
 
71
{
 
72
    Identity();
 
73
}
 
74
 
 
75
/***************************************************************************************\
 
76
Function:       Matrix3x3<T>::~Matrix3x3
 
77
 
 
78
Description:    Destructor.
 
79
 
 
80
Parameters:     None.
 
81
 
 
82
Return Value:   None.
 
83
 
 
84
Comments:       None.
 
85
\***************************************************************************************/
 
86
template <typename T>
 
87
Matrix3x3<T>::~Matrix3x3()
 
88
{
 
89
 
 
90
}
 
91
 
 
92
/***************************************************************************************\
 
93
Function:       Matrix3x3<T>::Matrix3x3
 
94
 
 
95
Description:    None.
 
96
 
 
97
Parameters:     - M
 
98
 
 
99
Return Value:   None.
 
100
 
 
101
Comments:       None.
 
102
\***************************************************************************************/
 
103
template <typename T>
 
104
Matrix3x3<T>::Matrix3x3(const Matrix3x3<T>& M) 
 
105
{
 
106
    m[0][0] = M.m[0][0]; m[0][1] = M.m[0][1]; m[0][2] = M.m[0][2];
 
107
    m[1][0] = M.m[1][0]; m[1][1] = M.m[1][1]; m[1][2] = M.m[1][2];
 
108
    m[2][0] = M.m[2][0]; m[2][1] = M.m[2][1]; m[2][2] = M.m[2][2];
 
109
}
 
110
 
 
111
/***************************************************************************************\
 
112
Function:       Matrix3x3<T>::Matrix3x3
 
113
 
 
114
Description:    None. 
 
115
 
 
116
Parameters:     T a00, T a01, T a02, 
 
117
                T a10, T a11, T a12,
 
118
                T a20, T a21, T a22
 
119
 
 
120
Return Value:   None.
 
121
 
 
122
Comments:       None.
 
123
\***************************************************************************************/
 
124
template<typename T>
 
125
Matrix3x3<T>::Matrix3x3(
 
126
                               T a00, T a01, T a02, 
 
127
                               T a10, T a11, T a12,
 
128
                               T a20, T a21, T a22) 
 
129
{
 
130
    m[0][0] = a00; m[0][1] = a01; m[0][2] = a02;
 
131
    m[1][0] = a10; m[1][1] = a11; m[1][2] = a12;
 
132
    m[2][0] = a20; m[2][1] = a21; m[2][2] = a22;
 
133
}
 
134
 
 
135
/***************************************************************************************\
 
136
Function:       Matrix3x3<T>::operator =
 
137
 
 
138
Description:    None.
 
139
 
 
140
Parameters:     - M
 
141
 
 
142
Return Value:   Matrix3x3<T>.
 
143
 
 
144
Comments:       None.
 
145
\***************************************************************************************/
 
146
template <typename T>
 
147
Matrix3x3<T>& Matrix3x3<T>::operator = (const Matrix3x3<T>& M) 
 
148
{
 
149
    m[0][0] = M.m[0][0]; m[0][1] = M.m[0][1]; m[0][2] = M.m[0][2];
 
150
    m[1][0] = M.m[1][0]; m[1][1] = M.m[1][1]; m[1][2] = M.m[1][2];
 
151
    m[2][0] = M.m[2][0]; m[2][1] = M.m[2][1]; m[2][2] = M.m[2][2];
 
152
 
 
153
    return (*this);
 
154
}
 
155
 
 
156
template <typename T>
 
157
t_bool Matrix3x3<T>::operator == (const Matrix3x3<T>& M) 
 
158
{
 
159
    for(int i = 0; i < 3; i++)
 
160
        for(int j = 0; j < 3; j++)
 
161
        {
 
162
            if(m[i][j] != M.m[i][j])
 
163
                return false;
 
164
        }
 
165
    return true;
 
166
}
 
167
 
 
168
/***************************************************************************************\
 
169
Function:       Matrix3x3<T>::operator *
 
170
 
 
171
Description:    Multiply by matrix iM.
 
172
 
 
173
Parameters:     - iM
 
174
 
 
175
Return Value:   Matrix3x3<T>.
 
176
 
 
177
Comments:       None.
 
178
\***************************************************************************************/
 
179
template <typename T>
 
180
 Matrix3x3<T> Matrix3x3<T>::operator * (const Matrix3x3<T>& iM) const 
 
181
{
 
182
    Matrix3x3<T> oM;
 
183
 
 
184
    oM.m[0][0] = m[0][0] * iM.m[0][0] + m[0][1] * iM.m[1][0] + m[0][2] * iM.m[2][0];
 
185
    oM.m[1][0] = m[1][0] * iM.m[0][0] + m[1][1] * iM.m[1][0] + m[1][2] * iM.m[2][0];
 
186
    oM.m[2][0] = m[2][0] * iM.m[0][0] + m[2][1] * iM.m[1][0] + m[2][2] * iM.m[2][0];
 
187
 
 
188
    oM.m[0][1] = m[0][0] * iM.m[0][1] + m[0][1] * iM.m[1][1] + m[0][2] * iM.m[2][1];
 
189
    oM.m[1][1] = m[1][0] * iM.m[0][1] + m[1][1] * iM.m[1][1] + m[1][2] * iM.m[2][1];
 
190
    oM.m[2][1] = m[2][0] * iM.m[0][1] + m[2][1] * iM.m[1][1] + m[2][2] * iM.m[2][1];
 
191
 
 
192
    oM.m[0][2] = m[0][0] * iM.m[0][2] + m[0][1] * iM.m[1][2] + m[0][2] * iM.m[2][2];
 
193
    oM.m[1][2] = m[1][0] * iM.m[0][2] + m[1][1] * iM.m[1][2] + m[1][2] * iM.m[2][2];
 
194
    oM.m[2][2] = m[2][0] * iM.m[0][2] + m[2][1] * iM.m[1][2] + m[2][2] * iM.m[2][2];
 
195
 
 
196
    return oM;
 
197
}
 
198
 
 
199
/***************************************************************************************\
 
200
Function:       Matrix3x3<T>::operator +
 
201
 
 
202
Description:    Add matrix iM.
 
203
 
 
204
Parameters:     - iM
 
205
 
 
206
Return Value:   Matrix3x3<T>.
 
207
 
 
208
Comments:       None.
 
209
\***************************************************************************************/
 
210
template <typename T>
 
211
 Matrix3x3<T> Matrix3x3<T>::operator+ (const Matrix3x3<T>& iM) const 
 
212
{
 
213
    Matrix3x3<T> oM;
 
214
 
 
215
    oM.m[0][0] = m[0][0]+iM.m[0][0]; oM.m[0][1] = m[0][1]+iM.m[0][1]; oM.m[0][2] = m[0][2]+iM.m[0][2]; 
 
216
    oM.m[1][0] = m[1][0]+iM.m[1][0]; oM.m[1][1] = m[1][1]+iM.m[1][1]; oM.m[1][2] = m[1][2]+iM.m[1][2]; 
 
217
    oM.m[2][0] = m[2][0]+iM.m[2][0]; oM.m[2][1] = m[2][1]+iM.m[2][1]; oM.m[2][2] = m[2][2]+iM.m[2][2]; 
 
218
 
 
219
    return oM;
 
220
}
 
221
 
 
222
/***************************************************************************************\
 
223
Function:       Matrix3x3<T>::operator -
 
224
 
 
225
Description:    Substract matrix iM.
 
226
 
 
227
Parameters:     - iM
 
228
 
 
229
Return Value:   Matrix3x3<T>.
 
230
 
 
231
Comments:       None.
 
232
\***************************************************************************************/
 
233
template <typename T>
 
234
 Matrix3x3<T> Matrix3x3<T>::operator- (const Matrix3x3<T>& iM) const 
 
235
{
 
236
    Matrix3x3<T> oM;
 
237
 
 
238
    oM.m[0][0] = m[0][0]-iM.m[0][0]; oM.m[0][1] = m[0][1]-iM.m[0][1]; oM.m[0][2] = m[0][2]-iM.m[0][2]; 
 
239
    oM.m[1][0] = m[1][0]-iM.m[1][0]; oM.m[1][1] = m[1][1]-iM.m[1][1]; oM.m[1][2] = m[1][2]-iM.m[1][2]; 
 
240
    oM.m[2][0] = m[2][0]-iM.m[2][0]; oM.m[2][1] = m[2][1]-iM.m[2][1]; oM.m[2][2] = m[2][2]-iM.m[2][2]; 
 
241
 
 
242
    return oM;
 
243
}
 
244
 
 
245
 
 
246
 
 
247
 
 
248
 
 
249
 
 
250
 
 
251
/***************************************************************************************\
 
252
Function:       Matrix3x3<T>::operator *=
 
253
 
 
254
Description:    Multiply by matrix iM.
 
255
 
 
256
Parameters:     - iM
 
257
 
 
258
Return Value:   Matrix3x3<T>.
 
259
 
 
260
Comments:       None.
 
261
\***************************************************************************************/
 
262
template <typename T>
 
263
Matrix3x3<T>& Matrix3x3<T>::operator *= (const Matrix3x3<T>& iM) const 
 
264
{
 
265
    Matrix3x3<T> oM;
 
266
 
 
267
    oM.m[0][0] = m[0][0] * iM.m[0][0] + m[0][1] * iM.m[1][0] + m[0][2] * iM.m[2][0];
 
268
    oM.m[1][0] = m[1][0] * iM.m[0][0] + m[1][1] * iM.m[1][0] + m[1][2] * iM.m[2][0];
 
269
    oM.m[2][0] = m[2][0] * iM.m[0][0] + m[2][1] * iM.m[1][0] + m[2][2] * iM.m[2][0];
 
270
 
 
271
    oM.m[0][1] = m[0][0] * iM.m[0][1] + m[0][1] * iM.m[1][1] + m[0][2] * iM.m[2][1];
 
272
    oM.m[1][1] = m[1][0] * iM.m[0][1] + m[1][1] * iM.m[1][1] + m[1][2] * iM.m[2][1];
 
273
    oM.m[2][1] = m[2][0] * iM.m[0][1] + m[2][1] * iM.m[1][1] + m[2][2] * iM.m[2][1];
 
274
 
 
275
    oM.m[0][2] = m[0][0] * iM.m[0][2] + m[0][1] * iM.m[1][2] + m[0][2] * iM.m[2][2];
 
276
    oM.m[1][2] = m[1][0] * iM.m[0][2] + m[1][1] * iM.m[1][2] + m[1][2] * iM.m[2][2];
 
277
    oM.m[2][2] = m[2][0] * iM.m[0][2] + m[2][1] * iM.m[1][2] + m[2][2] * iM.m[2][2];
 
278
 
 
279
    *this = oM;
 
280
    return *this;
 
281
}
 
282
 
 
283
/***************************************************************************************\
 
284
Function:       Matrix3x3<T>::operator +=
 
285
 
 
286
Description:    Add matrix iM.
 
287
 
 
288
Parameters:     - iM
 
289
 
 
290
Return Value:   Matrix3x3<T>.
 
291
 
 
292
Comments:       None.
 
293
\***************************************************************************************/
 
294
template <typename T>
 
295
Matrix3x3<T>& Matrix3x3<T>::operator += (const Matrix3x3<T>& iM) const 
 
296
{
 
297
    Matrix3x3<T> oM;
 
298
 
 
299
    oM.m[0][0] = m[0][0]+iM.m[0][0]; oM.m[0][1] = m[0][1]+iM.m[0][1]; oM.m[0][2] = m[0][2]+iM.m[0][2]; 
 
300
    oM.m[1][0] = m[1][0]+iM.m[1][0]; oM.m[1][1] = m[1][1]+iM.m[1][1]; oM.m[1][2] = m[1][2]+iM.m[1][2]; 
 
301
    oM.m[2][0] = m[2][0]+iM.m[2][0]; oM.m[2][1] = m[2][1]+iM.m[2][1]; oM.m[2][2] = m[2][2]+iM.m[2][2]; 
 
302
 
 
303
    *this = oM;
 
304
    return *this;
 
305
}
 
306
 
 
307
/***************************************************************************************\
 
308
Function:       Matrix3x3<T>::operator -=
 
309
 
 
310
Description:    Substract matrix iM.
 
311
 
 
312
Parameters:     - iM
 
313
 
 
314
Return Value:   Matrix3x3<T>.
 
315
 
 
316
Comments:       None.
 
317
\***************************************************************************************/
 
318
template <typename T>
 
319
Matrix3x3<T>& Matrix3x3<T>::operator -= (const Matrix3x3<T>& iM) const 
 
320
{
 
321
    Matrix3x3<T> oM;
 
322
 
 
323
    oM.m[0][0] = m[0][0]-iM.m[0][0]; oM.m[0][1] = m[0][1]-iM.m[0][1]; oM.m[0][2] = m[0][2]-iM.m[0][2]; 
 
324
    oM.m[1][0] = m[1][0]-iM.m[1][0]; oM.m[1][1] = m[1][1]-iM.m[1][1]; oM.m[1][2] = m[1][2]-iM.m[1][2]; 
 
325
    oM.m[2][0] = m[2][0]-iM.m[2][0]; oM.m[2][1] = m[2][1]-iM.m[2][1]; oM.m[2][2] = m[2][2]-iM.m[2][2]; 
 
326
 
 
327
    *this = oM;
 
328
    return *this;
 
329
}
 
330
 
 
331
 
 
332
/***************************************************************************************\
 
333
Function:       Matrix3x3<T>::operator *
 
334
 
 
335
Description:    Multiply all elements by f.
 
336
 
 
337
Parameters:     - f
 
338
 
 
339
Return Value:   Matrix3x3<T>.
 
340
 
 
341
Comments:       None.
 
342
\***************************************************************************************/
 
343
template <typename T>
 
344
 Matrix3x3<T> Matrix3x3<T>::operator * (const T& f) const 
 
345
{
 
346
    Matrix3x3<T> oM;
 
347
 
 
348
    oM.m[0][0] = m[0][0]*f; oM.m[0][1] = m[0][1]*f; oM.m[0][2] = m[0][2]*f; 
 
349
    oM.m[1][0] = m[1][0]*f; oM.m[1][1] = m[1][1]*f; oM.m[1][2] = m[1][2]*f; 
 
350
    oM.m[2][0] = m[2][0]*f; oM.m[2][1] = m[2][1]*f; oM.m[2][2] = m[2][2]*f; 
 
351
 
 
352
    return oM;
 
353
}
 
354
 
 
355
/***************************************************************************************\
 
356
Function:       Matrix3x3<T>::operator /
 
357
 
 
358
Description:    Divide all elements by f.
 
359
 
 
360
Parameters:     - f
 
361
 
 
362
Return Value:   Matrix3x3<T>.
 
363
 
 
364
Comments:       None.
 
365
\***************************************************************************************/
 
366
template <typename T>
 
367
 Matrix3x3<T> Matrix3x3<T>::operator/ (const T& f) const 
 
368
{
 
369
    Matrix3x3<T> oM;
 
370
 
 
371
    oM.m[0][0] = m[0][0]/f; oM.m[0][1] = m[0][1]/f; oM.m[0][2] = m[0][2]/f; 
 
372
    oM.m[1][0] = m[1][0]/f; oM.m[1][1] = m[1][1]/f; oM.m[1][2] = m[1][2]/f; 
 
373
    oM.m[2][0] = m[2][0]/f; oM.m[2][1] = m[2][1]/f; oM.m[2][2] = m[2][2]/f; 
 
374
 
 
375
    return oM;
 
376
}
 
377
 
 
378
 
 
379
 
 
380
 
 
381
 
 
382
/***************************************************************************************\
 
383
Function:       Matrix3x3<T>::operator *=
 
384
 
 
385
Description:    Multiply all elements by f.
 
386
 
 
387
Parameters:     - f
 
388
 
 
389
Return Value:   Matrix3x3<T>.
 
390
 
 
391
Comments:       None.
 
392
\***************************************************************************************/
 
393
template <typename T>
 
394
Matrix3x3<T>& Matrix3x3<T>::operator *= (const T& f) const 
 
395
{
 
396
    Matrix3x3<T> oM;
 
397
 
 
398
    oM.m[0][0] = m[0][0]*f; oM.m[0][1] = m[0][1]*f; oM.m[0][2] = m[0][2]*f; 
 
399
    oM.m[1][0] = m[1][0]*f; oM.m[1][1] = m[1][1]*f; oM.m[1][2] = m[1][2]*f; 
 
400
    oM.m[2][0] = m[2][0]*f; oM.m[2][1] = m[2][1]*f; oM.m[2][2] = m[2][2]*f; 
 
401
 
 
402
    *this = oM;
 
403
    return *this;
 
404
}
 
405
 
 
406
/***************************************************************************************\
 
407
Function:       Matrix3x3<T>::operator /=
 
408
 
 
409
Description:    Divide all elements by f.
 
410
 
 
411
Parameters:     - f
 
412
 
 
413
Return Value:   Matrix3x3<T>.
 
414
 
 
415
Comments:       None.
 
416
\***************************************************************************************/
 
417
template <typename T>
 
418
Matrix3x3<T>& Matrix3x3<T>::operator /= (const T& f) const 
 
419
{
 
420
    Matrix3x3<T> oM;
 
421
 
 
422
    oM.m[0][0] = m[0][0]/f; oM.m[0][1] = m[0][1]/f; oM.m[0][2] = m[0][2]/f; 
 
423
    oM.m[1][0] = m[1][0]/f; oM.m[1][1] = m[1][1]/f; oM.m[1][2] = m[1][2]/f; 
 
424
    oM.m[2][0] = m[2][0]/f; oM.m[2][1] = m[2][1]/f; oM.m[2][2] = m[2][2]/f; 
 
425
 
 
426
    *this = oM;
 
427
    return *this;
 
428
}
 
429
 
 
430
/***************************************************************************************\
 
431
Function:       Matrix3x3<T>::operator *
 
432
 
 
433
Description:    Multiply a matrix by a vector.
 
434
 
 
435
Parameters:     - V
 
436
 
 
437
Return Value:   Vector4.
 
438
 
 
439
Comments:       None.
 
440
\***************************************************************************************/
 
441
template <typename T>
 
442
Vec3<T> Matrix3x3<T>::operator * (const Vec3<T>& V) const 
 
443
{
 
444
    Vec3<T> oV;
 
445
 
 
446
    oV.x = V.x*m[0][0] + V.y*m[0][1] + V.z*m[0][2];
 
447
    oV.y = V.x*m[1][0] + V.y*m[1][1] + V.z*m[1][2];
 
448
    oV.z = V.x*m[2][0] + V.y*m[2][1] + V.z*m[2][2];
 
449
 
 
450
    return oV;
 
451
}
 
452
 
 
453
/***************************************************************************************\
 
454
Function:       Matrix3x3<T>::operator - ()
 
455
 
 
456
Description:    Negate all elements of the matrix.
 
457
 
 
458
Parameters:     None.
 
459
 
 
460
Return Value:   Matrix3x3<T>.
 
461
 
 
462
Comments:       None.
 
463
\***************************************************************************************/
 
464
template <typename T>
 
465
 Matrix3x3<T> Matrix3x3<T>::operator- ()
 
466
{
 
467
    Matrix3x3<T> oM;
 
468
 
 
469
    oM.m[0][0] = -m[0][0];
 
470
    oM.m[0][1] = -m[0][1];
 
471
    oM.m[0][2] = -m[0][2];
 
472
    oM.m[1][0] = -m[1][0];
 
473
    oM.m[1][1] = -m[1][1];
 
474
    oM.m[1][2] = -m[1][2];
 
475
    oM.m[2][0] = -m[2][0];
 
476
    oM.m[2][1] = -m[2][1];
 
477
    oM.m[2][2] = -m[2][2];
 
478
 
 
479
    return oM;
 
480
}
 
481
 
 
482
template <typename T>
 
483
T& Matrix3x3<T>::operator ()(unsigned int i, unsigned int j)
 
484
{
 
485
    return m[i][j];
 
486
}
 
487
 
 
488
template <typename T>
 
489
T Matrix3x3<T>::operator ()(unsigned int i, unsigned int j) const
 
490
{
 
491
    return m[i][j];
 
492
}
 
493
 
 
494
/***************************************************************************************\
 
495
Function:       Matrix3x3<T>::zero
 
496
 
 
497
Description:    Set the matrix to zero.
 
498
 
 
499
Parameters:     None.
 
500
 
 
501
Return Value:   None.
 
502
 
 
503
Comments:       None.
 
504
\***************************************************************************************/
 
505
template <typename T>
 
506
void Matrix3x3<T>::Zero()
 
507
{
 
508
    m[0][0] = 0.0; m[0][1] = 0.0; m[0][2] = 0.0;
 
509
    m[1][0] = 0.0; m[1][1] = 0.0; m[1][2] = 0.0;
 
510
    m[2][0] = 0.0; m[2][1] = 0.0; m[2][2] = 0.0;
 
511
 
 
512
    //memset(m, 0, sizeof(m));
 
513
}
 
514
 
 
515
/***************************************************************************************\
 
516
Function:       Matrix3x3<T>::identity
 
517
 
 
518
Description:    Set the matrix to identity.
 
519
 
 
520
Parameters:     None.
 
521
 
 
522
Return Value:   None.
 
523
 
 
524
Comments:       None.
 
525
\***************************************************************************************/
 
526
template <typename T>
 
527
void Matrix3x3<T>::Identity()
 
528
{
 
529
    m[0][0] = 1.0; m[0][1] = 0.0; m[0][2] = 0.0;
 
530
    m[1][0] = 0.0; m[1][1] = 1.0; m[1][2] = 0.0;
 
531
    m[2][0] = 0.0; m[2][1] = 0.0; m[2][2] = 1.0;
 
532
}
 
533
 
 
534
template <typename T>
 
535
T Matrix3x3<T>::Determinant() const
 
536
{
 
537
    T det;
 
538
    det = m[0][0] * m[1][1] * m[2][2] +
 
539
        m[0][1] * m[1][2] * m[2][0] +
 
540
        m[0][2] * m[2][0] * m[2][1] -
 
541
        m[0][0] * m[1][2] * m[2][1] -
 
542
        m[0][1] * m[1][0] * m[2][2] -
 
543
        m[0][2] * m[1][1] * m[2][0];
 
544
 
 
545
    return det;
 
546
}
 
547
 
 
548
template <typename T>
 
549
void Matrix3x3<T>::Inverse()
 
550
{
 
551
    T det = Determinant();
 
552
    if(det == T(0))
 
553
    {
 
554
        // Determinant is null. Matrix cannot be inverted.
 
555
#ifdef _DEBUG
 
556
        INL_HARDWARE_BREAK;
 
557
#endif
 
558
        return;
 
559
    }
 
560
 
 
561
    Matrix3x3<T> Temp;
 
562
    Temp.m[0][0] = m[1][1]*m[2][2] - m[1][2]*m[2][1];   
 
563
    Temp.m[0][1] = m[0][2]*m[2][1] - m[0][1]*m[2][2];
 
564
    Temp.m[0][2] = m[0][1]*m[1][2] - m[0][2]*m[1][1];
 
565
 
 
566
    Temp.m[1][0] = m[1][2]*m[2][0] - m[1][0]*m[2][2];
 
567
    Temp.m[1][1] = m[0][0]*m[2][2] - m[0][2]*m[2][0];
 
568
    Temp.m[1][2] = m[0][2]*m[1][0] - m[0][0]*m[1][2];
 
569
 
 
570
    Temp.m[2][0] = m[1][0]*m[2][1] - m[1][1]*m[2][0];
 
571
    Temp.m[2][1] = m[0][1]*m[2][0] - m[0][0]*m[2][1];
 
572
    Temp.m[2][2] = m[0][0]*m[1][1] - m[0][1]*m[1][0];
 
573
 
 
574
    *this = (T(1) / det) * Temp; 
 
575
}
 
576
 
 
577
template <typename T>
 
578
Matrix3x3<T> Matrix3x3<T>::GetInverse() const
 
579
{
 
580
    Matrix3x3<T> Temp = *this;
 
581
    Temp.Inverse();
 
582
    return Temp;
 
583
}
 
584
 
 
585
// template <typename T>
 
586
// Matrix2x2<T> Matrix3x3<T>::GetUpper2x2() const
 
587
// {
 
588
//     Matrix2x2<T> Temp;
 
589
//     Temp.m[0][0] = m[0][0];
 
590
//     Temp.m[0][1] = m[0][1];
 
591
// 
 
592
//     Temp.m[1][0] = m[1][0];
 
593
//     Temp.m[1][1] = m[1][1];
 
594
// 
 
595
//     return Temp;
 
596
// }
 
597
 
 
598
template <typename T>
 
599
Matrix3x3<T> Matrix3x3<T>::IDENTITY()
 
600
{
 
601
    Matrix3x3<T> matrix;
 
602
    matrix.Identity();
 
603
    return matrix;
 
604
}
 
605
 
 
606
template <typename T>
 
607
Matrix3x3<T> Matrix3x3<T>::ZERO()
 
608
{
 
609
    Matrix3x3<T> matrix;
 
610
    matrix.Zero();
 
611
    return matrix;
 
612
}
 
613
 
 
614
/***************************************************************************************\
 
615
Function:       Matrix3x3<T>::operator *
 
616
 
 
617
Description:    Multiply matrix rhs by constant lhs.
 
618
Allow "f * matrix" operation..
 
619
 
 
620
Parameters:     None.
 
621
 
 
622
Return Value:   Matrix3x3<T>.
 
623
 
 
624
Comments:       None.
 
625
\***************************************************************************************/
 
626
template <typename T>
 
627
Matrix3x3<T> operator * (const T& lhs, const Matrix3x3<T>& rhs)
 
628
{
 
629
    Matrix3x3<T> oM;
 
630
 
 
631
    oM.m[0][0] = rhs.m[0][0]/lhs; oM.m[0][1] = rhs.m[0][1]/lhs; oM.m[0][2] = rhs.m[0][2]/lhs;
 
632
    oM.m[1][0] = rhs.m[1][0]/lhs; oM.m[1][1] = rhs.m[1][1]/lhs; oM.m[1][2] = rhs.m[1][2]/lhs;
 
633
    oM.m[2][0] = rhs.m[2][0]/lhs; oM.m[2][1] = rhs.m[2][1]/lhs; oM.m[2][2] = rhs.m[2][2]/lhs;
 
634
 
 
635
    return oM;
 
636
}
 
637
 
 
638
typedef Matrix3x3<float> Matrix3;
 
639
 
 
640
NAMESPACE_END
 
641
 
 
642
 
 
643
#endif // MATRIX3_H
 
644