Branch data Line data Source code
1 : : #ifndef GFXMATH_MAT4_INCLUDED // -*- C++ -*-
2 : : #define GFXMATH_MAT4_INCLUDED
3 : :
4 : : /************************************************************************
5 : :
6 : : 4x4 Matrix class
7 : :
8 : : $Id: Mat4.h,v 1.14 1997/06/18 15:55:22 garland Exp $
9 : :
10 : : ************************************************************************/
11 : :
12 : : #include "Vec3.h"
13 : : #include "Vec4.h"
14 : :
15 : : class Mat4
16 : : {
17 : : private:
18 : : Vec4 row[4];
19 : :
20 : : protected:
21 : :
22 : : inline void copy(const Mat4& m);
23 : 0 : inline Vec4 col(int i) const
24 : 0 : { return Vec4(row[0][i],row[1][i],row[2][i],row[3][i]); }
25 : :
26 : : public:
27 : : // Standard matrices
28 : : static Mat4 identity;
29 : : static Mat4 zero;
30 : : static Mat4 unit;
31 : :
32 : : static Mat4 trans(double,double,double);
33 : : static Mat4 scale(double,double,double);
34 : : static Mat4 xrot(double); //
35 : : static Mat4 yrot(double); // Arguments are in radians
36 : : static Mat4 zrot(double); //
37 : :
38 : :
39 : : // Standard constructors
40 [ + + ]: 363696 : Mat4() { copy(zero); }
41 : 60850 : Mat4(const Vec4& r0,const Vec4& r1,const Vec4& r2,const Vec4& r3)
42 [ + + ]: 304250 : { row[0]=r0; row[1]=r1; row[2]=r2; row[3]=r3; }
43 [ + + ]: 823404 : Mat4(const Mat4& m) { copy(m); }
44 : :
45 : : // Access methods
46 : : // M(i, j) == row i;col j
47 : 30469028 : double& operator()(int i, int j) { return row[i][j]; }
48 : 1212320 : double operator()(int i, int j) const { return row[i][j]; }
49 : : const Vec4& operator[](int i) const { return row[i]; }
50 : :
51 : : // Comparison methods
52 : : inline int operator==(const Mat4&);
53 : :
54 : : // Assignment methods
55 : 0 : inline Mat4& operator=(const Mat4& m) { copy(m); return *this; }
56 : : inline Mat4& operator+=(const Mat4& m);
57 : : inline Mat4& operator-=(const Mat4& m);
58 : :
59 : : inline Mat4& operator*=(double s);
60 : : inline Mat4& operator/=(double s);
61 : :
62 : :
63 : : // Arithmetic methods
64 : : inline Mat4 operator+(const Mat4& m) const;
65 : : inline Mat4 operator-(const Mat4& m) const;
66 : : inline Mat4 operator-() const;
67 : :
68 : : inline Mat4 operator*(double s) const;
69 : : inline Mat4 operator/(double s) const;
70 : : Mat4 operator*(const Mat4& m) const;
71 : :
72 : : inline Vec4 operator*(const Vec4& v) const; // [x y z w]
73 : : inline Vec3 operator*(const Vec3& v) const; // [x y z w]
74 : :
75 : : // Matrix operations
76 : : double det() const;
77 : : Mat4 transpose() const;
78 : : Mat4 adjoint() const;
79 : : double inverse(Mat4&) const;
80 : : double cramerInverse(Mat4&) const;
81 : :
82 : : // Output methods
83 : : friend std::ostream& operator<<(std::ostream&, const Mat4&);
84 : : };
85 : :
86 : :
87 : :
88 : 197850 : inline void Mat4::copy(const Mat4& m)
89 : : {
90 : 197850 : row[0] = m.row[0]; row[1] = m.row[1];
91 : 197850 : row[2] = m.row[2]; row[3] = m.row[3];
92 : 197850 : }
93 : :
94 : : inline int Mat4::operator==(const Mat4& m)
95 : : {
96 : : return row[0]==m.row[0] &&
97 : : row[1]==m.row[1] &&
98 : : row[2]==m.row[2] &&
99 : : row[3]==m.row[3] ;
100 : : }
101 : :
102 : 31744 : inline Mat4& Mat4::operator+=(const Mat4& m)
103 : : {
104 : 31744 : row[0] += m.row[0]; row[1] += m.row[1];
105 : 31744 : row[2] += m.row[2]; row[3] += m.row[3];
106 : 31744 : return *this;
107 : : }
108 : :
109 : : inline Mat4& Mat4::operator-=(const Mat4& m)
110 : : {
111 : : row[0] -= m.row[0]; row[1] -= m.row[1];
112 : : row[2] -= m.row[2]; row[3] -= m.row[3];
113 : : return *this;
114 : : }
115 : :
116 : 400 : inline Mat4& Mat4::operator*=(double s)
117 : : {
118 : 400 : row[0] *= s; row[1] *= s; row[2] *= s; row[3] *= s;
119 : 400 : return *this;
120 : : }
121 : :
122 : : inline Mat4& Mat4::operator/=(double s)
123 : : {
124 : : row[0] /= s; row[1] /= s; row[2] /= s; row[3] /= s;
125 : : return *this;
126 : : }
127 : :
128 : 60616 : inline Mat4 Mat4::operator+(const Mat4& m) const
129 : : {
130 [ + - ]: 60616 : return Mat4(row[0]+m.row[0],
131 [ + - ]: 60616 : row[1]+m.row[1],
132 [ + - ]: 60616 : row[2]+m.row[2],
133 [ + - ]: 121232 : row[3]+m.row[3]);
134 : : }
135 : :
136 : : inline Mat4 Mat4::operator-(const Mat4& m) const
137 : : {
138 : : return Mat4(row[0]-m.row[0],
139 : : row[1]-m.row[1],
140 : : row[2]-m.row[2],
141 : : row[3]-m.row[3]);
142 : : }
143 : :
144 : : inline Mat4 Mat4::operator-() const
145 : : {
146 : : return Mat4(-row[0], -row[1], -row[2], -row[3]);
147 : : }
148 : :
149 : : inline Mat4 Mat4::operator*(double s) const
150 : : {
151 : : return Mat4(row[0]*s, row[1]*s, row[2]*s, row[3]*s);
152 : : }
153 : :
154 : 0 : inline Mat4 Mat4::operator/(double s) const
155 : : {
156 [ # # ][ # # ]: 0 : return Mat4(row[0]/s, row[1]/s, row[2]/s, row[3]/s);
[ # # ][ # # ]
157 : : }
158 : :
159 : : inline Vec4 Mat4::operator*(const Vec4& v) const
160 : : {
161 : : return Vec4(row[0]*v, row[1]*v, row[2]*v, row[3]*v);
162 : : }
163 : :
164 : : //
165 : : // Transform a homogeneous 3-vector and reproject into normal 3-space
166 : : //
167 : 4 : inline Vec3 Mat4::operator*(const Vec3& v) const
168 : : {
169 [ + - ]: 4 : Vec4 u=Vec4(v,1);
170 [ + - ]: 4 : double w=row[3]*u;
171 : :
172 [ - + ]: 4 : if(w==0.0)
173 [ # # ][ # # ]: 0 : return Vec3(row[0]*u, row[1]*u, row[2]*u);
[ # # ][ # # ]
174 : : else
175 [ + - ][ + - ]: 4 : return Vec3(row[0]*u/w, row[1]*u/w, row[2]*u/w);
[ + - ][ + - ]
176 : : }
177 : :
178 : : inline std::ostream& operator<<(std::ostream& out, const Mat4& M)
179 : : {
180 : : return out<<M.row[0]<<std::endl<<M.row[1]<<std::endl<<M.row[2]<<std::endl<<M.row[3];
181 : : }
182 : :
183 : :
184 : : // GFXMATH_MAT4_INCLUDED
185 : : #endif
|
