glide_test1

view vmath.h @ 0:f3ddb2bb7024

find changesets by author, revision, files, or words in the commit message
first 3dfx glide test, initial commit
author John Tsiombikas <nuclear@member.fsf.org>
date Sun, 09 Mar 2014 06:27:58 +0200
parents
children
line source
1 #ifndef VMATH_H_
2 #define VMATH_H_
3
4 #include <math.h>
5 #include "matrix.h"
6
7 class Vector4;
8
9 class Vector3 {
10 public:
11 float x, y, z;
12
13 Vector3() : x(0), y(0), z(0) {}
14 Vector3(float xx, float yy, float zz) : x(xx), y(yy), z(zz) {}
15 explicit inline Vector3(const Vector4 &v);
16
17 inline float &operator [](int idx)
18 {
19 switch(idx) {
20 case 0:
21 return x;
22 case 1:
23 return y;
24 case 2:
25 default:
26 return z;
27 }
28 }
29
30 inline const float &operator [](int idx) const
31 {
32 switch(idx) {
33 case 0:
34 return x;
35 case 1:
36 return y;
37 case 2:
38 default:
39 return z;
40 }
41 }
42
43 inline float length() const
44 {
45 return sqrt(x * x + y * y + z * z);
46 }
47
48 inline void normalize()
49 {
50 float len = length();
51 if(len != 0) {
52 x /= len;
53 y /= len;
54 z /= len;
55 }
56 }
57 };
58
59 inline Vector3 operator +(const Vector3 &a, const Vector3 &b)
60 {
61 return Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
62 }
63
64 inline Vector3 operator -(const Vector3 &a, const Vector3 &b)
65 {
66 return Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
67 }
68
69 inline Vector3 operator *(const Vector3 &a, const Vector3 &b)
70 {
71 return Vector3(a.x * b.x, a.y * b.y, a.z * b.z);
72 }
73
74 inline Vector3 operator *(const Vector3 &v, float s)
75 {
76 return Vector3(v.x * s, v.y * s, v.z * s);
77 }
78
79 inline Vector3 operator *(float s, const Vector3 &v)
80 {
81 return Vector3(v.x * s, v.y * s, v.z * s);
82 }
83
84 inline Vector3 operator /(const Vector3 &a, const Vector3 &b)
85 {
86 return Vector3(a.x / b.x, a.y / b.y, a.z / b.z);
87 }
88
89 inline Vector3 operator /(const Vector3 &v, float s)
90 {
91 return Vector3(v.x / s, v.y / s, v.z / s);
92 }
93
94 inline float dot(const Vector3 &a, const Vector3 &b)
95 {
96 return a.x * b.x + a.y * b.y + a.z * b.z;
97 }
98
99 inline Vector3 cross(const Vector3 &a, const Vector3 &b)
100 {
101 return Vector3(a.y * b.z - a.z * b.y,
102 a.z * b.x - a.x * b.z,
103 a.x * b.y - a.y * b.z);
104 }
105
106
107 inline float length(const Vector3 &v)
108 {
109 return sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
110 }
111
112 inline float length_sq(const Vector3 &v)
113 {
114 return v.x * v.x + v.y * v.y + v.z * v.z;
115 }
116
117 inline Vector3 normalize(const Vector3 &v)
118 {
119 float len = length(v);
120 float s = len == 0 ? 1.0 : 1.0 / len;
121 return v * s;
122 }
123
124 inline Vector3 transform(const Vector3 &v, const Matrix4x4 &m)
125 {
126 return Vector3(
127 m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3],
128 m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3],
129 m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3]);
130 }
131
132
133 // ---- Vector4 ----
134 class Vector4 {
135 public:
136 float x, y, z, w;
137
138 Vector4() : x(0), y(0), z(0), w(1) {}
139 Vector4(float xx, float yy, float zz, float ww = 1.0f) : x(xx), y(yy), z(zz), w(ww) {}
140 explicit Vector4(const Vector3 &v) : x(v.x), y(v.y), z(v.z), w(1.0f) {}
141
142 inline float &operator [](int idx)
143 {
144 switch(idx) {
145 case 0:
146 return x;
147 case 1:
148 return y;
149 case 2:
150 return z;
151 default:
152 case 3:
153 return w;
154 }
155 }
156
157 inline const float &operator [](int idx) const
158 {
159 switch(idx) {
160 case 0:
161 return x;
162 case 1:
163 return y;
164 case 2:
165 return z;
166 case 3:
167 default:
168 return w;
169 }
170 }
171
172 inline float length() const
173 {
174 return sqrt(x * x + y * y + z * z + w * w);
175 }
176
177 inline void normalize()
178 {
179 float len = length();
180 if(len != 0) {
181 x /= len;
182 y /= len;
183 z /= len;
184 w /= len;
185 }
186 }
187 };
188
189 inline Vector4 operator +(const Vector4 &a, const Vector4 &b)
190 {
191 return Vector4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
192 }
193
194 inline Vector4 operator -(const Vector4 &a, const Vector4 &b)
195 {
196 return Vector4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
197 }
198
199 inline Vector4 operator *(const Vector4 &a, const Vector4 &b)
200 {
201 return Vector4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
202 }
203
204 inline Vector4 operator *(const Vector4 &v, float s)
205 {
206 return Vector4(v.x * s, v.y * s, v.z * s, v.w * s);
207 }
208
209 inline Vector4 operator *(float s, const Vector4 &v)
210 {
211 return Vector4(v.x * s, v.y * s, v.z * s, v.w * s);
212 }
213
214 inline Vector4 operator /(const Vector4 &a, const Vector4 &b)
215 {
216 return Vector4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
217 }
218
219 inline Vector4 operator /(const Vector4 &v, float s)
220 {
221 return Vector4(v.x / s, v.y / s, v.z / s, v.w / s);
222 }
223
224 inline float dot(const Vector4 &a, const Vector4 &b)
225 {
226 return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
227 }
228
229 inline float length(const Vector4 &v)
230 {
231 return sqrt(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w);
232 }
233
234 inline float length_sq(const Vector4 &v)
235 {
236 return v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
237 }
238
239 inline Vector4 normalize(const Vector4 &v)
240 {
241 float len = length(v);
242 float s = len == 0 ? 1.0 : 1.0 / len;
243 return v * s;
244 }
245
246 inline Vector4 transform(const Vector4 &v, const Matrix4x4 &m)
247 {
248 return Vector4(
249 m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w,
250 m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
251 m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
252 m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3] * v.w);
253 }
254
255 inline Vector3::Vector3(const Vector4 &v)
256 : x(v.x), y(v.y), z(v.z)
257 {
258 }
259
260
261 #endif // VMATH_H_