git.mutantstargoat.com Git - summerhack/blob - tools/curve_draw/vmath/vector.inl

   1 /*
   2 This file is part of XRay, a photorealistic 3D rendering library.
   3 Copyright (C) 2005 John Tsiombikas
   4
   5 XRay is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 XRay is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with XRay; if not, write to the Free Software
  17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18 */
  19
  20 #include <cmath>
  21 #include "vmath.h"
  22
  23 /**
  24  * @file vector.inl
  25  * @author John Tsiombikas
  26  * @date 28 June 2005
  27  *
  28  * Inline functions of vector classes.
  29  */
  30
  31
  32 inline scalar_t &Vector2::operator [](int elem) {
  33         return elem ? y : x;
  34 }
  35
  36 inline Vector2 operator -(const Vector2 &vec) {
  37         return Vector2(-vec.x, -vec.y);
  38 }
  39
  40 inline scalar_t dot_product(const Vector2 &v1, const Vector2 &v2) {
  41         return v1.x * v2.x + v1.y * v2.y;
  42 }
  43
  44 inline Vector2 operator +(const Vector2 &v1, const Vector2 &v2) {
  45         return Vector2(v1.x + v2.x, v1.y + v2.y);
  46 }
  47
  48 inline Vector2 operator -(const Vector2 &v1, const Vector2 &v2) {
  49         return Vector2(v1.x - v2.x, v1.y - v2.y);
  50 }
  51
  52 inline Vector2 operator *(const Vector2 &v1, const Vector2 &v2) {
  53         return Vector2(v1.x * v2.x, v1.y * v2.y);
  54 }
  55
  56 inline Vector2 operator /(const Vector2 &v1, const Vector2 &v2) {
  57         return Vector2(v1.x / v2.x, v1.y / v2.y);
  58 }
  59
  60 inline bool operator ==(const Vector2 &v1, const Vector2 &v2) {
  61         return (fabs(v1.x - v2.x) < xsmall_number) && (fabs(v1.y - v2.x) < xsmall_number);
  62 }
  63
  64 inline void operator +=(Vector2 &v1, const Vector2 &v2) {
  65         v1.x += v2.x;
  66         v1.y += v2.y;
  67 }
  68
  69 inline void operator -=(Vector2 &v1, const Vector2 &v2) {
  70         v1.x -= v2.x;
  71         v1.y -= v2.y;
  72 }
  73
  74 inline void operator *=(Vector2 &v1, const Vector2 &v2) {
  75         v1.x *= v2.x;
  76         v1.y *= v2.y;
  77 }
  78
  79 inline void operator /=(Vector2 &v1, const Vector2 &v2) {
  80         v1.x /= v2.x;
  81         v1.y /= v2.y;
  82 }
  83
  84 inline Vector2 operator +(const Vector2 &vec, scalar_t scalar) {
  85         return Vector2(vec.x + scalar, vec.y + scalar);
  86 }
  87
  88 inline Vector2 operator +(scalar_t scalar, const Vector2 &vec) {
  89         return Vector2(vec.x + scalar, vec.y + scalar);
  90 }
  91
  92 inline Vector2 operator -(const Vector2 &vec, scalar_t scalar) {
  93         return Vector2(vec.x - scalar, vec.y - scalar);
  94 }
  95
  96 inline Vector2 operator -(scalar_t scalar, const Vector2 &vec) {
  97         return Vector2(vec.x - scalar, vec.y - scalar);
  98 }
  99
 100 inline Vector2 operator *(const Vector2 &vec, scalar_t scalar) {
 101         return Vector2(vec.x * scalar, vec.y * scalar);
 102 }
 103
 104 inline Vector2 operator *(scalar_t scalar, const Vector2 &vec) {
 105         return Vector2(vec.x * scalar, vec.y * scalar);
 106 }
 107
 108 inline Vector2 operator /(const Vector2 &vec, scalar_t scalar) {
 109         return Vector2(vec.x / scalar, vec.y / scalar);
 110 }
 111
 112 inline Vector2 operator /(scalar_t scalar, const Vector2 &vec) {
 113         return Vector2(vec.x / scalar, vec.y / scalar);
 114 }
 115
 116 inline void operator +=(Vector2 &vec, scalar_t scalar) {
 117         vec.x += scalar;
 118         vec.y += scalar;
 119 }
 120
 121 inline void operator -=(Vector2 &vec, scalar_t scalar) {
 122         vec.x -= scalar;
 123         vec.y -= scalar;
 124 }
 125
 126 inline void operator *=(Vector2 &vec, scalar_t scalar) {
 127         vec.x *= scalar;
 128         vec.y *= scalar;
 129 }
 130
 131 inline void operator /=(Vector2 &vec, scalar_t scalar) {
 132         vec.x /= scalar;
 133         vec.y /= scalar;
 134 }
 135
 136 inline scalar_t Vector2::length() const {
 137         return sqrt(x*x + y*y);
 138 }
 139
 140 inline scalar_t Vector2::length_sq() const {
 141         return x*x + y*y;
 142 }
 143
 144
 145
 146 // ------------- Vector3 --------------
 147
 148 inline scalar_t &Vector3::operator [](int elem) {
 149         return elem ? (elem == 1 ? y : z) : x;
 150 }
 151
 152 // unary operations
 153 inline Vector3 operator -(const Vector3 &vec) {
 154         return Vector3(-vec.x, -vec.y, -vec.z);
 155 }
 156
 157 // binary vector (op) vector operations
 158 inline scalar_t dot_product(const Vector3 &v1, const Vector3 &v2) {
 159         return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
 160 }
 161
 162 inline Vector3 cross_product(const Vector3 &v1, const Vector3 &v2) {
 163         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);
 164 }
 165
 166
 167 inline Vector3 operator +(const Vector3 &v1, const Vector3 &v2) {
 168         return Vector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
 169 }
 170
 171 inline Vector3 operator -(const Vector3 &v1, const Vector3 &v2) {
 172         return Vector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
 173 }
 174
 175 inline Vector3 operator *(const Vector3 &v1, const Vector3 &v2) {
 176         return Vector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
 177 }
 178
 179 inline Vector3 operator /(const Vector3 &v1, const Vector3 &v2) {
 180         return Vector3(v1.x / v2.x, v1.y / v2.y, v1.z / v2.z);
 181 }
 182
 183 inline bool operator ==(const Vector3 &v1, const Vector3 &v2) {
 184         return (fabs(v1.x - v2.x) < xsmall_number) && (fabs(v1.y - v2.y) < xsmall_number) && (fabs(v1.z - v2.z) < xsmall_number);
 185 }
 186
 187 inline void operator +=(Vector3 &v1, const Vector3 &v2) {
 188         v1.x += v2.x;
 189         v1.y += v2.y;
 190         v1.z += v2.z;
 191 }
 192
 193 inline void operator -=(Vector3 &v1, const Vector3 &v2) {
 194         v1.x -= v2.x;
 195         v1.y -= v2.y;
 196         v1.z -= v2.z;
 197 }
 198
 199 inline void operator *=(Vector3 &v1, const Vector3 &v2) {
 200         v1.x *= v2.x;
 201         v1.y *= v2.y;
 202         v1.z *= v2.z;
 203 }
 204
 205 inline void operator /=(Vector3 &v1, const Vector3 &v2) {
 206         v1.x /= v2.x;
 207         v1.y /= v2.y;
 208         v1.z /= v2.z;
 209 }
 210 // binary vector (op) scalar and scalar (op) vector operations
 211 inline Vector3 operator +(const Vector3 &vec, scalar_t scalar) {
 212         return Vector3(vec.x + scalar, vec.y + scalar, vec.z + scalar);
 213 }
 214
 215 inline Vector3 operator +(scalar_t scalar, const Vector3 &vec) {
 216         return Vector3(vec.x + scalar, vec.y + scalar, vec.z + scalar);
 217 }
 218
 219 inline Vector3 operator -(const Vector3 &vec, scalar_t scalar) {
 220         return Vector3(vec.x - scalar, vec.y - scalar, vec.z - scalar);
 221 }
 222
 223 inline Vector3 operator -(scalar_t scalar, const Vector3 &vec) {
 224         return Vector3(vec.x - scalar, vec.y - scalar, vec.z - scalar);
 225 }
 226
 227 inline Vector3 operator *(const Vector3 &vec, scalar_t scalar) {
 228         return Vector3(vec.x * scalar, vec.y * scalar, vec.z * scalar);
 229 }
 230
 231 inline Vector3 operator *(scalar_t scalar, const Vector3 &vec) {
 232         return Vector3(vec.x * scalar, vec.y * scalar, vec.z * scalar);
 233 }
 234
 235 inline Vector3 operator /(const Vector3 &vec, scalar_t scalar) {
 236         return Vector3(vec.x / scalar, vec.y / scalar, vec.z / scalar);
 237 }
 238
 239 inline Vector3 operator /(scalar_t scalar, const Vector3 &vec) {
 240         return Vector3(vec.x / scalar, vec.y / scalar, vec.z / scalar);
 241 }
 242
 243 inline void operator +=(Vector3 &vec, scalar_t scalar) {
 244         vec.x += scalar;
 245         vec.y += scalar;
 246         vec.z += scalar;
 247 }
 248
 249 inline void operator -=(Vector3 &vec, scalar_t scalar) {
 250         vec.x -= scalar;
 251         vec.y -= scalar;
 252         vec.z -= scalar;
 253 }
 254
 255 inline void operator *=(Vector3 &vec, scalar_t scalar) {
 256         vec.x *= scalar;
 257         vec.y *= scalar;
 258         vec.z *= scalar;
 259 }
 260
 261 inline void operator /=(Vector3 &vec, scalar_t scalar) {
 262         vec.x /= scalar;
 263         vec.y /= scalar;
 264         vec.z /= scalar;
 265 }
 266
 267 inline scalar_t Vector3::length() const {
 268         return sqrt(x*x + y*y + z*z);
 269 }
 270 inline scalar_t Vector3::length_sq() const {
 271         return x*x + y*y + z*z;
 272 }
 273
 274
 275
 276 // ----------- Vector4 -----------------
 277
 278 inline scalar_t &Vector4::operator [](int elem) {
 279         return elem ? (elem == 1 ? y : (elem == 2 ? z : w)) : x;
 280 }
 281
 282 inline Vector4 operator -(const Vector4 &vec) {
 283         return Vector4(-vec.x, -vec.y, -vec.z, -vec.w);
 284 }
 285
 286 inline scalar_t dot_product(const Vector4 &v1, const Vector4 &v2) {
 287         return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + v1.w * v2.w;
 288 }
 289
 290 inline Vector4 cross_product(const Vector4 &v1, const Vector4 &v2, const Vector4 &v3) {
 291         float  A, B, C, D, E, F;       // Intermediate Values
 292     Vector4 result;
 293
 294     // Calculate intermediate values.
 295     A = (v2.x * v3.y) - (v2.y * v3.x);
 296     B = (v2.x * v3.z) - (v2.z * v3.x);
 297     C = (v2.x * v3.w) - (v2.w * v3.x);
 298     D = (v2.y * v3.z) - (v2.z * v3.y);
 299     E = (v2.y * v3.w) - (v2.w * v3.y);
 300     F = (v2.z * v3.w) - (v2.w * v3.z);
 301
 302     // Calculate the result-vector components.
 303     result.x =   (v1.y * F) - (v1.z * E) + (v1.w * D);
 304     result.y = - (v1.x * F) + (v1.z * C) - (v1.w * B);
 305     result.z =   (v1.x * E) - (v1.y * C) + (v1.w * A);
 306     result.w = - (v1.x * D) + (v1.y * B) - (v1.z * A);
 307     return result;
 308 }
 309
 310 inline Vector4 operator +(const Vector4 &v1, const Vector4 &v2) {
 311         return Vector4(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z, v1.w + v2.w);
 312 }
 313
 314 inline Vector4 operator -(const Vector4 &v1, const Vector4 &v2) {
 315         return Vector4(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z, v1.w - v2.w);
 316 }
 317
 318 inline Vector4 operator *(const Vector4 &v1, const Vector4 &v2) {
 319         return Vector4(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z, v1.w * v2.w);
 320 }
 321
 322 inline Vector4 operator /(const Vector4 &v1, const Vector4 &v2) {
 323         return Vector4(v1.x / v2.x, v1.y / v2.y, v1.z / v2.z, v1.w / v2.w);
 324 }
 325
 326 inline bool operator ==(const Vector4 &v1, const Vector4 &v2) {
 327         return  (fabs(v1.x - v2.x) < xsmall_number) &&
 328                         (fabs(v1.y - v2.y) < xsmall_number) &&
 329                         (fabs(v1.z - v2.z) < xsmall_number) &&
 330                         (fabs(v1.w - v2.w) < xsmall_number);
 331 }
 332
 333 inline void operator +=(Vector4 &v1, const Vector4 &v2) {
 334         v1.x += v2.x;
 335         v1.y += v2.y;
 336         v1.z += v2.z;
 337         v1.w += v2.w;
 338 }
 339
 340 inline void operator -=(Vector4 &v1, const Vector4 &v2) {
 341         v1.x -= v2.x;
 342         v1.y -= v2.y;
 343         v1.z -= v2.z;
 344         v1.w -= v2.w;
 345 }
 346
 347 inline void operator *=(Vector4 &v1, const Vector4 &v2) {
 348         v1.x *= v2.x;
 349         v1.y *= v2.y;
 350         v1.z *= v2.z;
 351         v1.w *= v2.w;
 352 }
 353
 354 inline void operator /=(Vector4 &v1, const Vector4 &v2) {
 355         v1.x /= v2.x;
 356         v1.y /= v2.y;
 357         v1.z /= v2.z;
 358         v1.w /= v2.w;
 359 }
 360
 361 // binary vector (op) scalar and scalar (op) vector operations
 362 inline Vector4 operator +(const Vector4 &vec, scalar_t scalar) {
 363         return Vector4(vec.x + scalar, vec.y + scalar, vec.z + scalar, vec.w + scalar);
 364 }
 365
 366 inline Vector4 operator +(scalar_t scalar, const Vector4 &vec) {
 367         return Vector4(vec.x + scalar, vec.y + scalar, vec.z + scalar, vec.w + scalar);
 368 }
 369
 370 inline Vector4 operator -(const Vector4 &vec, scalar_t scalar) {
 371         return Vector4(vec.x - scalar, vec.y - scalar, vec.z - scalar, vec.w - scalar);
 372 }
 373
 374 inline Vector4 operator -(scalar_t scalar, const Vector4 &vec) {
 375         return Vector4(vec.x - scalar, vec.y - scalar, vec.z - scalar, vec.w - scalar);
 376 }
 377
 378 inline Vector4 operator *(const Vector4 &vec, scalar_t scalar) {
 379         return Vector4(vec.x * scalar, vec.y * scalar, vec.z * scalar, vec.w * scalar);
 380 }
 381
 382 inline Vector4 operator *(scalar_t scalar, const Vector4 &vec) {
 383         return Vector4(vec.x * scalar, vec.y * scalar, vec.z * scalar, vec.w * scalar);
 384 }
 385
 386 inline Vector4 operator /(const Vector4 &vec, scalar_t scalar) {
 387         return Vector4(vec.x / scalar, vec.y / scalar, vec.z / scalar, vec.w / scalar);
 388 }
 389
 390 inline Vector4 operator /(scalar_t scalar, const Vector4 &vec) {
 391         return Vector4(vec.x / scalar, vec.y / scalar, vec.z / scalar, vec.w / scalar);
 392 }
 393
 394 inline void operator +=(Vector4 &vec, scalar_t scalar) {
 395         vec.x += scalar;
 396         vec.y += scalar;
 397         vec.z += scalar;
 398         vec.w += scalar;
 399 }
 400
 401 inline void operator -=(Vector4 &vec, scalar_t scalar) {
 402         vec.x -= scalar;
 403         vec.y -= scalar;
 404         vec.z -= scalar;
 405         vec.w -= scalar;
 406 }
 407
 408 inline void operator *=(Vector4 &vec, scalar_t scalar) {
 409         vec.x *= scalar;
 410         vec.y *= scalar;
 411         vec.z *= scalar;
 412         vec.w *= scalar;
 413 }
 414
 415 inline void operator /=(Vector4 &vec, scalar_t scalar) {
 416         vec.x /= scalar;
 417         vec.y /= scalar;
 418         vec.z /= scalar;
 419         vec.w /= scalar;
 420 }
 421
 422 inline scalar_t Vector4::length() const {
 423         return sqrt(x*x + y*y + z*z + w*w);
 424 }
 425 inline scalar_t Vector4::length_sq() const {
 426         return x*x + y*y + z*z + w*w;
 427 }