2 Copyright 2004 John Tsiombikas <nuclear@siggraph.org>
4 This file is part of the n3dmath2 library.
6 The n3dmath2 library is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 The n3dmath2 library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with the n3dmath2 library; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 // ------------------------------
22 // inline function definitions
23 // for Vector classes of n3dmath2
24 // ------------------------------
28 // ---------- Vector2 -----------
30 inline scalar_t &Vector2::operator [](int elem) {
34 inline Vector2 operator -(const Vector2 &vec) {
35 return Vector2(-vec.x, -vec.y);
38 inline scalar_t dot_product(const Vector2 &v1, const Vector2 &v2) {
39 return v1.x * v2.x + v1.y * v2.y;
42 inline Vector2 operator +(const Vector2 &v1, const Vector2 &v2) {
43 return Vector2(v1.x + v2.x, v1.y + v2.y);
46 inline Vector2 operator -(const Vector2 &v1, const Vector2 &v2) {
47 return Vector2(v1.x - v2.x, v1.y - v2.y);
50 inline Vector2 operator *(const Vector2 &v1, const Vector2 &v2) {
51 return Vector2(v1.x * v2.x, v1.y * v2.y);
54 inline Vector2 operator /(const Vector2 &v1, const Vector2 &v2) {
55 return Vector2(v1.x / v2.x, v1.y / v2.y);
58 inline bool operator ==(const Vector2 &v1, const Vector2 &v2) {
59 return (fabs(v1.x - v2.x) < xsmall_number) && (fabs(v1.y - v2.x) < xsmall_number);
62 inline void operator +=(Vector2 &v1, const Vector2 &v2) {
67 inline void operator -=(Vector2 &v1, const Vector2 &v2) {
72 inline void operator *=(Vector2 &v1, const Vector2 &v2) {
77 inline void operator /=(Vector2 &v1, const Vector2 &v2) {
82 inline Vector2 operator +(const Vector2 &vec, scalar_t scalar) {
83 return Vector2(vec.x + scalar, vec.y + scalar);
86 inline Vector2 operator +(scalar_t scalar, const Vector2 &vec) {
87 return Vector2(vec.x + scalar, vec.y + scalar);
90 inline Vector2 operator -(const Vector2 &vec, scalar_t scalar) {
91 return Vector2(vec.x - scalar, vec.y - scalar);
94 inline Vector2 operator -(scalar_t scalar, const Vector2 &vec) {
95 return Vector2(vec.x - scalar, vec.y - scalar);
98 inline Vector2 operator *(const Vector2 &vec, scalar_t scalar) {
99 return Vector2(vec.x * scalar, vec.y * scalar);
102 inline Vector2 operator *(scalar_t scalar, const Vector2 &vec) {
103 return Vector2(vec.x * scalar, vec.y * scalar);
106 inline Vector2 operator /(const Vector2 &vec, scalar_t scalar) {
107 return Vector2(vec.x / scalar, vec.y / scalar);
110 inline Vector2 operator /(scalar_t scalar, const Vector2 &vec) {
111 return Vector2(vec.x / scalar, vec.y / scalar);
114 inline void operator +=(Vector2 &vec, scalar_t scalar) {
119 inline void operator -=(Vector2 &vec, scalar_t scalar) {
124 inline void operator *=(Vector2 &vec, scalar_t scalar) {
129 inline void operator /=(Vector2 &vec, scalar_t scalar) {
134 inline scalar_t Vector2::length() const {
135 return sqrt(x*x + y*y);
138 inline scalar_t Vector2::length_sq() const {
144 // ------------- Vector3 --------------
146 inline scalar_t &Vector3::operator [](int elem) {
147 return elem ? (elem == 1 ? y : z) : x;
151 inline Vector3 operator -(const Vector3 &vec) {
152 return Vector3(-vec.x, -vec.y, -vec.z);
155 // binary vector (op) vector operations
156 inline scalar_t dot_product(const Vector3 &v1, const Vector3 &v2) {
157 return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
160 inline Vector3 cross_product(const Vector3 &v1, const Vector3 &v2) {
161 return Vector3(v1.y * v2.z - v1.z * v2.y, v1.z * v2.x - v1.x * v2.z, v1.x * v2.y - v1.y * v2.x);
165 inline Vector3 operator +(const Vector3 &v1, const Vector3 &v2) {
166 return Vector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
169 inline Vector3 operator -(const Vector3 &v1, const Vector3 &v2) {
170 return Vector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
173 inline Vector3 operator *(const Vector3 &v1, const Vector3 &v2) {
174 return Vector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
177 inline Vector3 operator /(const Vector3 &v1, const Vector3 &v2) {
178 return Vector3(v1.x / v2.x, v1.y / v2.y, v1.z / v2.z);
181 inline bool operator ==(const Vector3 &v1, const Vector3 &v2) {
182 return (fabs(v1.x - v2.x) < xsmall_number) && (fabs(v1.y - v2.y) < xsmall_number) && (fabs(v1.z - v2.z) < xsmall_number);
185 inline void operator +=(Vector3 &v1, const Vector3 &v2) {
191 inline void operator -=(Vector3 &v1, const Vector3 &v2) {
197 inline void operator *=(Vector3 &v1, const Vector3 &v2) {
203 inline void operator /=(Vector3 &v1, const Vector3 &v2) {
208 // binary vector (op) scalar and scalar (op) vector operations
209 inline Vector3 operator +(const Vector3 &vec, scalar_t scalar) {
210 return Vector3(vec.x + scalar, vec.y + scalar, vec.z + scalar);
213 inline Vector3 operator +(scalar_t scalar, const Vector3 &vec) {
214 return Vector3(vec.x + scalar, vec.y + scalar, vec.z + scalar);
217 inline Vector3 operator -(const Vector3 &vec, scalar_t scalar) {
218 return Vector3(vec.x - scalar, vec.y - scalar, vec.z - scalar);
221 inline Vector3 operator -(scalar_t scalar, const Vector3 &vec) {
222 return Vector3(vec.x - scalar, vec.y - scalar, vec.z - scalar);
225 inline Vector3 operator *(const Vector3 &vec, scalar_t scalar) {
226 return Vector3(vec.x * scalar, vec.y * scalar, vec.z * scalar);
229 inline Vector3 operator *(scalar_t scalar, const Vector3 &vec) {
230 return Vector3(vec.x * scalar, vec.y * scalar, vec.z * scalar);
233 inline Vector3 operator /(const Vector3 &vec, scalar_t scalar) {
234 return Vector3(vec.x / scalar, vec.y / scalar, vec.z / scalar);
237 inline Vector3 operator /(scalar_t scalar, const Vector3 &vec) {
238 return Vector3(vec.x / scalar, vec.y / scalar, vec.z / scalar);
241 inline void operator +=(Vector3 &vec, scalar_t scalar) {
247 inline void operator -=(Vector3 &vec, scalar_t scalar) {
253 inline void operator *=(Vector3 &vec, scalar_t scalar) {
259 inline void operator /=(Vector3 &vec, scalar_t scalar) {
265 inline scalar_t Vector3::length() const {
266 return sqrt(x*x + y*y + z*z);
268 inline scalar_t Vector3::length_sq() const {
269 return x*x + y*y + z*z;
274 // ----------- Vector4 -----------------
276 inline scalar_t &Vector4::operator [](int elem) {
277 return elem ? (elem == 1 ? y : (elem == 2 ? z : w)) : x;
280 inline Vector4 operator -(const Vector4 &vec) {
281 return Vector4(-vec.x, -vec.y, -vec.z, -vec.w);
284 inline scalar_t dot_product(const Vector4 &v1, const Vector4 &v2) {
285 return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + v1.w * v2.w;
288 inline Vector4 cross_product(const Vector4 &v1, const Vector4 &v2, const Vector4 &v3) {
289 float A, B, C, D, E, F; // Intermediate Values
292 // Calculate intermediate values.
293 A = (v2.x * v3.y) - (v2.y * v3.x);
294 B = (v2.x * v3.z) - (v2.z * v3.x);
295 C = (v2.x * v3.w) - (v2.w * v3.x);
296 D = (v2.y * v3.z) - (v2.z * v3.y);
297 E = (v2.y * v3.w) - (v2.w * v3.y);
298 F = (v2.z * v3.w) - (v2.w * v3.z);
300 // Calculate the result-vector components.
301 result.x = (v1.y * F) - (v1.z * E) + (v1.w * D);
302 result.y = - (v1.x * F) + (v1.z * C) - (v1.w * B);
303 result.z = (v1.x * E) - (v1.y * C) + (v1.w * A);
304 result.w = - (v1.x * D) + (v1.y * B) - (v1.z * A);
308 inline Vector4 operator +(const Vector4 &v1, const Vector4 &v2) {
309 return Vector4(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z, v1.w + v2.w);
312 inline Vector4 operator -(const Vector4 &v1, const Vector4 &v2) {
313 return Vector4(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z, v1.w - v2.w);
316 inline Vector4 operator *(const Vector4 &v1, const Vector4 &v2) {
317 return Vector4(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z, v1.w * v2.w);
320 inline Vector4 operator /(const Vector4 &v1, const Vector4 &v2) {
321 return Vector4(v1.x / v2.x, v1.y / v2.y, v1.z / v2.z, v1.w / v2.w);
324 inline bool operator ==(const Vector4 &v1, const Vector4 &v2) {
325 return (fabs(v1.x - v2.x) < xsmall_number) &&
326 (fabs(v1.y - v2.y) < xsmall_number) &&
327 (fabs(v1.z - v2.z) < xsmall_number) &&
328 (fabs(v1.w - v2.w) < xsmall_number);
331 inline void operator +=(Vector4 &v1, const Vector4 &v2) {
338 inline void operator -=(Vector4 &v1, const Vector4 &v2) {
345 inline void operator *=(Vector4 &v1, const Vector4 &v2) {
352 inline void operator /=(Vector4 &v1, const Vector4 &v2) {
359 // binary vector (op) scalar and scalar (op) vector operations
360 inline Vector4 operator +(const Vector4 &vec, scalar_t scalar) {
361 return Vector4(vec.x + scalar, vec.y + scalar, vec.z + scalar, vec.w + scalar);
364 inline Vector4 operator +(scalar_t scalar, const Vector4 &vec) {
365 return Vector4(vec.x + scalar, vec.y + scalar, vec.z + scalar, vec.w + scalar);
368 inline Vector4 operator -(const Vector4 &vec, scalar_t scalar) {
369 return Vector4(vec.x - scalar, vec.y - scalar, vec.z - scalar, vec.w - scalar);
372 inline Vector4 operator -(scalar_t scalar, const Vector4 &vec) {
373 return Vector4(vec.x - scalar, vec.y - scalar, vec.z - scalar, vec.w - scalar);
376 inline Vector4 operator *(const Vector4 &vec, scalar_t scalar) {
377 return Vector4(vec.x * scalar, vec.y * scalar, vec.z * scalar, vec.w * scalar);
380 inline Vector4 operator *(scalar_t scalar, const Vector4 &vec) {
381 return Vector4(vec.x * scalar, vec.y * scalar, vec.z * scalar, vec.w * scalar);
384 inline Vector4 operator /(const Vector4 &vec, scalar_t scalar) {
385 return Vector4(vec.x / scalar, vec.y / scalar, vec.z / scalar, vec.w / scalar);
388 inline Vector4 operator /(scalar_t scalar, const Vector4 &vec) {
389 return Vector4(vec.x / scalar, vec.y / scalar, vec.z / scalar, vec.w / scalar);
392 inline void operator +=(Vector4 &vec, scalar_t scalar) {
399 inline void operator -=(Vector4 &vec, scalar_t scalar) {
406 inline void operator *=(Vector4 &vec, scalar_t scalar) {
413 inline void operator /=(Vector4 &vec, scalar_t scalar) {
420 inline scalar_t Vector4::length() const {
421 return sqrt(x*x + y*y + z*z + w*w);
423 inline scalar_t Vector4::length_sq() const {
424 return x*x + y*y + z*z + w*w;