git.mutantstargoat.com Git - summerhack/blob - src/3dengfx/src/n3dmath2/n3dmath2_vec.inl

   1 /*
   2 Copyright 2004 John Tsiombikas <nuclear@siggraph.org>
   3
   4 This file is part of the n3dmath2 library.
   5
   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.
  10
  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.
  15
  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
  19 */
  20
  21 // ------------------------------
  22 // inline function definitions
  23 // for Vector classes of n3dmath2
  24 // ------------------------------
  25
  26 #include <cmath>
  27
  28 // ---------- Vector2 -----------
  29
  30 inline scalar_t &Vector2::operator [](int elem) {
  31         return elem ? y : x;
  32 }
  33
  34 inline Vector2 operator -(const Vector2 &vec) {
  35         return Vector2(-vec.x, -vec.y);
  36 }
  37
  38 inline scalar_t dot_product(const Vector2 &v1, const Vector2 &v2) {
  39         return v1.x * v2.x + v1.y * v2.y;
  40 }
  41
  42 inline Vector2 operator +(const Vector2 &v1, const Vector2 &v2) {
  43         return Vector2(v1.x + v2.x, v1.y + v2.y);
  44 }
  45
  46 inline Vector2 operator -(const Vector2 &v1, const Vector2 &v2) {
  47         return Vector2(v1.x - v2.x, v1.y - v2.y);
  48 }
  49
  50 inline Vector2 operator *(const Vector2 &v1, const Vector2 &v2) {
  51         return Vector2(v1.x * v2.x, v1.y * v2.y);
  52 }
  53
  54 inline Vector2 operator /(const Vector2 &v1, const Vector2 &v2) {
  55         return Vector2(v1.x / v2.x, v1.y / v2.y);
  56 }
  57
  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);
  60 }
  61
  62 inline void operator +=(Vector2 &v1, const Vector2 &v2) {
  63         v1.x += v2.x;
  64         v1.y += v2.y;
  65 }
  66
  67 inline void operator -=(Vector2 &v1, const Vector2 &v2) {
  68         v1.x -= v2.x;
  69         v1.y -= v2.y;
  70 }
  71
  72 inline void operator *=(Vector2 &v1, const Vector2 &v2) {
  73         v1.x *= v2.x;
  74         v1.y *= v2.y;
  75 }
  76
  77 inline void operator /=(Vector2 &v1, const Vector2 &v2) {
  78         v1.x /= v2.x;
  79         v1.y /= v2.y;
  80 }
  81
  82 inline Vector2 operator +(const Vector2 &vec, scalar_t scalar) {
  83         return Vector2(vec.x + scalar, vec.y + scalar);
  84 }
  85
  86 inline Vector2 operator +(scalar_t scalar, const Vector2 &vec) {
  87         return Vector2(vec.x + scalar, vec.y + scalar);
  88 }
  89
  90 inline Vector2 operator -(const Vector2 &vec, scalar_t scalar) {
  91         return Vector2(vec.x - scalar, vec.y - scalar);
  92 }
  93
  94 inline Vector2 operator -(scalar_t scalar, const Vector2 &vec) {
  95         return Vector2(vec.x - scalar, vec.y - scalar);
  96 }
  97
  98 inline Vector2 operator *(const Vector2 &vec, scalar_t scalar) {
  99         return Vector2(vec.x * scalar, vec.y * scalar);
 100 }
 101
 102 inline Vector2 operator *(scalar_t scalar, const Vector2 &vec) {
 103         return Vector2(vec.x * scalar, vec.y * scalar);
 104 }
 105
 106 inline Vector2 operator /(const Vector2 &vec, scalar_t scalar) {
 107         return Vector2(vec.x / scalar, vec.y / scalar);
 108 }
 109
 110 inline Vector2 operator /(scalar_t scalar, const Vector2 &vec) {
 111         return Vector2(vec.x / scalar, vec.y / scalar);
 112 }
 113
 114 inline void operator +=(Vector2 &vec, scalar_t scalar) {
 115         vec.x += scalar;
 116         vec.y += scalar;
 117 }
 118
 119 inline void operator -=(Vector2 &vec, scalar_t scalar) {
 120         vec.x -= scalar;
 121         vec.y -= scalar;
 122 }
 123
 124 inline void operator *=(Vector2 &vec, scalar_t scalar) {
 125         vec.x *= scalar;
 126         vec.y *= scalar;
 127 }
 128
 129 inline void operator /=(Vector2 &vec, scalar_t scalar) {
 130         vec.x /= scalar;
 131         vec.y /= scalar;
 132 }
 133
 134 inline scalar_t Vector2::length() const {
 135         return sqrt(x*x + y*y);
 136 }
 137
 138 inline scalar_t Vector2::length_sq() const {
 139         return x*x + y*y;
 140 }
 141
 142
 143
 144 // ------------- Vector3 --------------
 145
 146 inline scalar_t &Vector3::operator [](int elem) {
 147         return elem ? (elem == 1 ? y : z) : x;
 148 }
 149
 150 // unary operations
 151 inline Vector3 operator -(const Vector3 &vec) {
 152         return Vector3(-vec.x, -vec.y, -vec.z);
 153 }
 154
 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;
 158 }
 159
 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);
 162 }
 163
 164
 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);
 167 }
 168
 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);
 171 }
 172
 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);
 175 }
 176
 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);
 179 }
 180
 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);
 183 }
 184
 185 inline void operator +=(Vector3 &v1, const Vector3 &v2) {
 186         v1.x += v2.x;
 187         v1.y += v2.y;
 188         v1.z += v2.z;
 189 }
 190
 191 inline void operator -=(Vector3 &v1, const Vector3 &v2) {
 192         v1.x -= v2.x;
 193         v1.y -= v2.y;
 194         v1.z -= v2.z;
 195 }
 196
 197 inline void operator *=(Vector3 &v1, const Vector3 &v2) {
 198         v1.x *= v2.x;
 199         v1.y *= v2.y;
 200         v1.z *= v2.z;
 201 }
 202
 203 inline void operator /=(Vector3 &v1, const Vector3 &v2) {
 204         v1.x /= v2.x;
 205         v1.y /= v2.y;
 206         v1.z /= v2.z;
 207 }
 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);
 211 }
 212
 213 inline Vector3 operator +(scalar_t scalar, const Vector3 &vec) {
 214         return Vector3(vec.x + scalar, vec.y + scalar, vec.z + scalar);
 215 }
 216
 217 inline Vector3 operator -(const Vector3 &vec, scalar_t scalar) {
 218         return Vector3(vec.x - scalar, vec.y - scalar, vec.z - scalar);
 219 }
 220
 221 inline Vector3 operator -(scalar_t scalar, const Vector3 &vec) {
 222         return Vector3(vec.x - scalar, vec.y - scalar, vec.z - scalar);
 223 }
 224
 225 inline Vector3 operator *(const Vector3 &vec, scalar_t scalar) {
 226         return Vector3(vec.x * scalar, vec.y * scalar, vec.z * scalar);
 227 }
 228
 229 inline Vector3 operator *(scalar_t scalar, const Vector3 &vec) {
 230         return Vector3(vec.x * scalar, vec.y * scalar, vec.z * scalar);
 231 }
 232
 233 inline Vector3 operator /(const Vector3 &vec, scalar_t scalar) {
 234         return Vector3(vec.x / scalar, vec.y / scalar, vec.z / scalar);
 235 }
 236
 237 inline Vector3 operator /(scalar_t scalar, const Vector3 &vec) {
 238         return Vector3(vec.x / scalar, vec.y / scalar, vec.z / scalar);
 239 }
 240
 241 inline void operator +=(Vector3 &vec, scalar_t scalar) {
 242         vec.x += scalar;
 243         vec.y += scalar;
 244         vec.z += scalar;
 245 }
 246
 247 inline void operator -=(Vector3 &vec, scalar_t scalar) {
 248         vec.x -= scalar;
 249         vec.y -= scalar;
 250         vec.z -= scalar;
 251 }
 252
 253 inline void operator *=(Vector3 &vec, scalar_t scalar) {
 254         vec.x *= scalar;
 255         vec.y *= scalar;
 256         vec.z *= scalar;
 257 }
 258
 259 inline void operator /=(Vector3 &vec, scalar_t scalar) {
 260         vec.x /= scalar;
 261         vec.y /= scalar;
 262         vec.z /= scalar;
 263 }
 264
 265 inline scalar_t Vector3::length() const {
 266         return sqrt(x*x + y*y + z*z);
 267 }
 268 inline scalar_t Vector3::length_sq() const {
 269         return x*x + y*y + z*z;
 270 }
 271
 272
 273
 274 // ----------- Vector4 -----------------
 275
 276 inline scalar_t &Vector4::operator [](int elem) {
 277         return elem ? (elem == 1 ? y : (elem == 2 ? z : w)) : x;
 278 }
 279
 280 inline Vector4 operator -(const Vector4 &vec) {
 281         return Vector4(-vec.x, -vec.y, -vec.z, -vec.w);
 282 }
 283
 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;
 286 }
 287
 288 inline Vector4 cross_product(const Vector4 &v1, const Vector4 &v2, const Vector4 &v3) {
 289         float  A, B, C, D, E, F;       // Intermediate Values
 290     Vector4 result;
 291
 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);
 299
 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);
 305     return result;
 306 }
 307
 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);
 310 }
 311
 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);
 314 }
 315
 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);
 318 }
 319
 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);
 322 }
 323
 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);
 329 }
 330
 331 inline void operator +=(Vector4 &v1, const Vector4 &v2) {
 332         v1.x += v2.x;
 333         v1.y += v2.y;
 334         v1.z += v2.z;
 335         v1.w += v2.w;
 336 }
 337
 338 inline void operator -=(Vector4 &v1, const Vector4 &v2) {
 339         v1.x -= v2.x;
 340         v1.y -= v2.y;
 341         v1.z -= v2.z;
 342         v1.w -= v2.w;
 343 }
 344
 345 inline void operator *=(Vector4 &v1, const Vector4 &v2) {
 346         v1.x *= v2.x;
 347         v1.y *= v2.y;
 348         v1.z *= v2.z;
 349         v1.w *= v2.w;
 350 }
 351
 352 inline void operator /=(Vector4 &v1, const Vector4 &v2) {
 353         v1.x /= v2.x;
 354         v1.y /= v2.y;
 355         v1.z /= v2.z;
 356         v1.w /= v2.w;
 357 }
 358
 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);
 362 }
 363
 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);
 366 }
 367
 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);
 370 }
 371
 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);
 374 }
 375
 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);
 378 }
 379
 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);
 382 }
 383
 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);
 386 }
 387
 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);
 390 }
 391
 392 inline void operator +=(Vector4 &vec, scalar_t scalar) {
 393         vec.x += scalar;
 394         vec.y += scalar;
 395         vec.z += scalar;
 396         vec.w += scalar;
 397 }
 398
 399 inline void operator -=(Vector4 &vec, scalar_t scalar) {
 400         vec.x -= scalar;
 401         vec.y -= scalar;
 402         vec.z -= scalar;
 403         vec.w -= scalar;
 404 }
 405
 406 inline void operator *=(Vector4 &vec, scalar_t scalar) {
 407         vec.x *= scalar;
 408         vec.y *= scalar;
 409         vec.z *= scalar;
 410         vec.w *= scalar;
 411 }
 412
 413 inline void operator /=(Vector4 &vec, scalar_t scalar) {
 414         vec.x /= scalar;
 415         vec.y /= scalar;
 416         vec.z /= scalar;
 417         vec.w /= scalar;
 418 }
 419
 420 inline scalar_t Vector4::length() const {
 421         return sqrt(x*x + y*y + z*z + w*w);
 422 }
 423 inline scalar_t Vector4::length_sq() const {
 424         return x*x + y*y + z*z + w*w;
 425 }