source/blender/blenlib/intern/math_vector_inline.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  19  * All rights reserved.
  20  *
  21  * The Original Code is: some of this file.
  22  *
  23  * ***** END GPL LICENSE BLOCK *****
  24  * */
  25
  26 /** \file blender/blenlib/intern/math_vector_inline.c
  27  *  \ingroup bli
  28  */
  29
  30 #ifndef __MATH_VECTOR_INLINE_C__
  31 #define __MATH_VECTOR_INLINE_C__
  32
  33 #include "BLI_math.h"
  34
  35 /********************************** Init *************************************/
  36
  37 MINLINE void zero_v2(float r[2])
  38 {
  39         r[0] = 0.0f;
  40         r[1] = 0.0f;
  41 }
  42
  43 MINLINE void zero_v3(float r[3])
  44 {
  45         r[0] = 0.0f;
  46         r[1] = 0.0f;
  47         r[2] = 0.0f;
  48 }
  49
  50 MINLINE void zero_v4(float r[4])
  51 {
  52         r[0] = 0.0f;
  53         r[1] = 0.0f;
  54         r[2] = 0.0f;
  55         r[3] = 0.0f;
  56 }
  57
  58 MINLINE void copy_v2_v2(float r[2], const float a[2])
  59 {
  60         r[0] = a[0];
  61         r[1] = a[1];
  62 }
  63
  64 MINLINE void copy_v3_v3(float r[3], const float a[3])
  65 {
  66         r[0] = a[0];
  67         r[1] = a[1];
  68         r[2] = a[2];
  69 }
  70
  71 MINLINE void copy_v4_v4(float r[4], const float a[4])
  72 {
  73         r[0] = a[0];
  74         r[1] = a[1];
  75         r[2] = a[2];
  76         r[3] = a[3];
  77 }
  78
  79 MINLINE void copy_v2_fl(float r[2], float f)
  80 {
  81         r[0] = f;
  82         r[1] = f;
  83 }
  84
  85 MINLINE void copy_v3_fl(float r[3], float f)
  86 {
  87         r[0] = f;
  88         r[1] = f;
  89         r[2] = f;
  90 }
  91
  92 MINLINE void copy_v4_fl(float r[4], float f)
  93 {
  94         r[0] = f;
  95         r[1] = f;
  96         r[2] = f;
  97         r[3] = f;
  98 }
  99
 100 /* short */
 101 MINLINE void copy_v2_v2_char(char r[2], const char a[2])
 102 {
 103         r[0] = a[0];
 104         r[1] = a[1];
 105 }
 106
 107 MINLINE void copy_v3_v3_char(char r[3], const char a[3])
 108 {
 109         r[0] = a[0];
 110         r[1] = a[1];
 111         r[2] = a[2];
 112 }
 113
 114 MINLINE void copy_v4_v4_char(char r[4], const char a[4])
 115 {
 116         r[0] = a[0];
 117         r[1] = a[1];
 118         r[2] = a[2];
 119         r[3] = a[3];
 120 }
 121
 122 /* short */
 123 MINLINE void zero_v3_int(int r[3])
 124 {
 125         r[0] = 0;
 126         r[1] = 0;
 127         r[2] = 0;
 128 }
 129
 130 MINLINE void copy_v2_v2_short(short r[2], const short a[2])
 131 {
 132         r[0] = a[0];
 133         r[1] = a[1];
 134 }
 135
 136 MINLINE void copy_v3_v3_short(short r[3], const short a[3])
 137 {
 138         r[0] = a[0];
 139         r[1] = a[1];
 140         r[2] = a[2];
 141 }
 142
 143 MINLINE void copy_v4_v4_short(short r[4], const short a[4])
 144 {
 145         r[0] = a[0];
 146         r[1] = a[1];
 147         r[2] = a[2];
 148         r[3] = a[3];
 149 }
 150
 151 /* int */
 152 MINLINE void copy_v2_v2_int(int r[2], const int a[2])
 153 {
 154         r[0] = a[0];
 155         r[1] = a[1];
 156 }
 157
 158 MINLINE void copy_v3_v3_int(int r[3], const int a[3])
 159 {
 160         r[0] = a[0];
 161         r[1] = a[1];
 162         r[2] = a[2];
 163 }
 164
 165 MINLINE void copy_v4_v4_int(int r[4], const int a[4])
 166 {
 167         r[0] = a[0];
 168         r[1] = a[1];
 169         r[2] = a[2];
 170         r[3] = a[3];
 171 }
 172
 173 /* double -> float */
 174 MINLINE void copy_v2fl_v2db(float r[2], const double a[2])
 175 {
 176         r[0] = (float)a[0];
 177         r[1] = (float)a[1];
 178 }
 179
 180 MINLINE void copy_v3fl_v3db(float r[3], const double a[3])
 181 {
 182         r[0] = (float)a[0];
 183         r[1] = (float)a[1];
 184         r[2] = (float)a[2];
 185 }
 186
 187 MINLINE void copy_v4fl_v4db(float r[4], const double a[4])
 188 {
 189         r[0] = (float)a[0];
 190         r[1] = (float)a[1];
 191         r[2] = (float)a[2];
 192         r[3] = (float)a[3];
 193 }
 194
 195 /* float -> double */
 196 MINLINE void copy_v2db_v2fl(double r[2], const float a[2])
 197 {
 198         r[0] = (double)a[0];
 199         r[1] = (double)a[1];
 200 }
 201
 202 MINLINE void copy_v3db_v3fl(double r[3], const float a[3])
 203 {
 204         r[0] = (double)a[0];
 205         r[1] = (double)a[1];
 206         r[2] = (double)a[2];
 207 }
 208
 209 MINLINE void copy_v4db_v4fl(double r[4], const float a[4])
 210 {
 211         r[0] = (double)a[0];
 212         r[1] = (double)a[1];
 213         r[2] = (double)a[2];
 214         r[3] = (double)a[3];
 215 }
 216
 217 MINLINE void swap_v2_v2(float a[2], float b[2])
 218 {
 219         SWAP(float, a[0], b[0]);
 220         SWAP(float, a[1], b[1]);
 221 }
 222
 223 MINLINE void swap_v3_v3(float a[3], float b[3])
 224 {
 225         SWAP(float, a[0], b[0]);
 226         SWAP(float, a[1], b[1]);
 227         SWAP(float, a[2], b[2]);
 228 }
 229
 230 MINLINE void swap_v4_v4(float a[4], float b[4])
 231 {
 232         SWAP(float, a[0], b[0]);
 233         SWAP(float, a[1], b[1]);
 234         SWAP(float, a[2], b[2]);
 235         SWAP(float, a[3], b[3]);
 236 }
 237
 238 /* float args -> vec */
 239 MINLINE void copy_v3_fl3(float v[3], float x, float y, float z)
 240 {
 241         v[0] = x;
 242         v[1] = y;
 243         v[2] = z;
 244 }
 245
 246 MINLINE void copy_v4_fl4(float v[4], float x, float y, float z, float w)
 247 {
 248         v[0] = x;
 249         v[1] = y;
 250         v[2] = z;
 251         v[3] = w;
 252 }
 253
 254 /********************************* Arithmetic ********************************/
 255
 256 MINLINE void add_v2_fl(float r[2], float f)
 257 {
 258         r[0] += f;
 259         r[1] += f;
 260 }
 261
 262
 263 MINLINE void add_v3_fl(float r[3], float f)
 264 {
 265         r[0] += f;
 266         r[1] += f;
 267         r[2] += f;
 268 }
 269
 270 MINLINE void add_v4_fl(float r[4], float f)
 271 {
 272         r[0] += f;
 273         r[1] += f;
 274         r[2] += f;
 275         r[3] += f;
 276 }
 277
 278 MINLINE void add_v2_v2(float r[2], const float a[2])
 279 {
 280         r[0] += a[0];
 281         r[1] += a[1];
 282 }
 283
 284 MINLINE void add_v2_v2v2(float r[2], const float a[2], const float b[2])
 285 {
 286         r[0] = a[0] + b[0];
 287         r[1] = a[1] + b[1];
 288 }
 289
 290 MINLINE void add_v2_v2v2_int(int r[2], const int a[2], const int b[2])
 291 {
 292         r[0] = a[0] + b[0];
 293         r[1] = a[1] + b[1];
 294 }
 295
 296 MINLINE void add_v3_v3(float r[3], const float a[3])
 297 {
 298         r[0] += a[0];
 299         r[1] += a[1];
 300         r[2] += a[2];
 301 }
 302
 303 MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
 304 {
 305         r[0] = a[0] + b[0];
 306         r[1] = a[1] + b[1];
 307         r[2] = a[2] + b[2];
 308 }
 309
 310 MINLINE void add_v4_v4(float r[4], const float a[4])
 311 {
 312         r[0] += a[0];
 313         r[1] += a[1];
 314         r[2] += a[2];
 315         r[3] += a[3];
 316 }
 317
 318 MINLINE void add_v4_v4v4(float r[4], const float a[4], const float b[4])
 319 {
 320         r[0] = a[0] + b[0];
 321         r[1] = a[1] + b[1];
 322         r[2] = a[2] + b[2];
 323         r[3] = a[3] + b[3];
 324 }
 325
 326 MINLINE void sub_v2_v2(float r[2], const float a[2])
 327 {
 328         r[0] -= a[0];
 329         r[1] -= a[1];
 330 }
 331
 332 MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
 333 {
 334         r[0] = a[0] - b[0];
 335         r[1] = a[1] - b[1];
 336 }
 337
 338 MINLINE void sub_v2_v2v2_int(int r[2], const int a[2], const int b[2])
 339 {
 340         r[0] = a[0] - b[0];
 341         r[1] = a[1] - b[1];
 342 }
 343
 344 MINLINE void sub_v3_v3(float r[3], const float a[3])
 345 {
 346         r[0] -= a[0];
 347         r[1] -= a[1];
 348         r[2] -= a[2];
 349 }
 350
 351 MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
 352 {
 353         r[0] = a[0] - b[0];
 354         r[1] = a[1] - b[1];
 355         r[2] = a[2] - b[2];
 356 }
 357
 358 MINLINE void sub_v4_v4(float r[4], const float a[4])
 359 {
 360         r[0] -= a[0];
 361         r[1] -= a[1];
 362         r[2] -= a[2];
 363         r[3] -= a[3];
 364 }
 365
 366 MINLINE void sub_v4_v4v4(float r[4], const float a[4], const float b[4])
 367 {
 368         r[0] = a[0] - b[0];
 369         r[1] = a[1] - b[1];
 370         r[2] = a[2] - b[2];
 371         r[3] = a[3] - b[3];
 372 }
 373
 374 MINLINE void mul_v2_fl(float r[2], float f)
 375 {
 376         r[0] *= f;
 377         r[1] *= f;
 378 }
 379
 380 MINLINE void mul_v2_v2fl(float r[2], const float a[2], float f)
 381 {
 382         r[0] = a[0] * f;
 383         r[1] = a[1] * f;
 384 }
 385
 386 MINLINE void mul_v3_fl(float r[3], float f)
 387 {
 388         r[0] *= f;
 389         r[1] *= f;
 390         r[2] *= f;
 391 }
 392
 393 MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
 394 {
 395         r[0] = a[0] * f;
 396         r[1] = a[1] * f;
 397         r[2] = a[2] * f;
 398 }
 399
 400 MINLINE void mul_v2_v2(float r[2], const float a[2])
 401 {
 402         r[0] *= a[0];
 403         r[1] *= a[1];
 404 }
 405
 406 MINLINE void mul_v3_v3(float r[3], const float a[3])
 407 {
 408         r[0] *= a[0];
 409         r[1] *= a[1];
 410         r[2] *= a[2];
 411 }
 412
 413 MINLINE void mul_v4_fl(float r[4], float f)
 414 {
 415         r[0] *= f;
 416         r[1] *= f;
 417         r[2] *= f;
 418         r[3] *= f;
 419 }
 420
 421 MINLINE void mul_v4_v4fl(float r[4], const float a[4], float f)
 422 {
 423         r[0] = a[0] * f;
 424         r[1] = a[1] * f;
 425         r[2] = a[2] * f;
 426         r[3] = a[3] * f;
 427 }
 428
 429 /* note: could add a matrix inline */
 430 MINLINE float mul_project_m4_v3_zfac(float mat[4][4], const float co[3])
 431 {
 432         return (mat[0][3] * co[0]) +
 433                (mat[1][3] * co[1]) +
 434                (mat[2][3] * co[2]) + mat[3][3];
 435 }
 436
 437 /**
 438  * Has the effect of mul_m3_v3(), on a single axis.
 439  */
 440 MINLINE float dot_m3_v3_row_x(float M[3][3], const float a[3])
 441 {
 442         return M[0][0] * a[0] + M[1][0] * a[1] + M[2][0] * a[2];
 443 }
 444 MINLINE float dot_m3_v3_row_y(float M[3][3], const float a[3])
 445 {
 446         return M[0][1] * a[0] + M[1][1] * a[1] + M[2][1] * a[2];
 447 }
 448 MINLINE float dot_m3_v3_row_z(float M[3][3], const float a[3])
 449 {
 450         return M[0][2] * a[0] + M[1][2] * a[1] + M[2][2] * a[2];
 451 }
 452
 453 MINLINE void madd_v2_v2fl(float r[2], const float a[2], float f)
 454 {
 455         r[0] += a[0] * f;
 456         r[1] += a[1] * f;
 457 }
 458
 459 MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
 460 {
 461         r[0] += a[0] * f;
 462         r[1] += a[1] * f;
 463         r[2] += a[2] * f;
 464 }
 465
 466 MINLINE void madd_v3_v3v3(float r[3], const float a[3], const float b[3])
 467 {
 468         r[0] += a[0] * b[0];
 469         r[1] += a[1] * b[1];
 470         r[2] += a[2] * b[2];
 471 }
 472
 473 MINLINE void madd_v2_v2v2fl(float r[2], const float a[2], const float b[2], float f)
 474 {
 475         r[0] = a[0] + b[0] * f;
 476         r[1] = a[1] + b[1] * f;
 477 }
 478
 479 MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
 480 {
 481         r[0] = a[0] + b[0] * f;
 482         r[1] = a[1] + b[1] * f;
 483         r[2] = a[2] + b[2] * f;
 484 }
 485
 486 MINLINE void madd_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3])
 487 {
 488         r[0] = a[0] + b[0] * c[0];
 489         r[1] = a[1] + b[1] * c[1];
 490         r[2] = a[2] + b[2] * c[2];
 491 }
 492
 493 MINLINE void madd_v4_v4fl(float r[4], const float a[4], float f)
 494 {
 495         r[0] += a[0] * f;
 496         r[1] += a[1] * f;
 497         r[2] += a[2] * f;
 498         r[3] += a[3] * f;
 499 }
 500
 501 MINLINE void madd_v4_v4v4(float r[4], const float a[4], const float b[4])
 502 {
 503         r[0] += a[0] * b[0];
 504         r[1] += a[1] * b[1];
 505         r[2] += a[2] * b[2];
 506         r[3] += a[3] * b[3];
 507 }
 508
 509 MINLINE void mul_v3_v3v3(float r[3], const float v1[3], const float v2[3])
 510 {
 511         r[0] = v1[0] * v2[0];
 512         r[1] = v1[1] * v2[1];
 513         r[2] = v1[2] * v2[2];
 514 }
 515
 516 MINLINE void negate_v2(float r[2])
 517 {
 518         r[0] = -r[0];
 519         r[1] = -r[1];
 520 }
 521
 522 MINLINE void negate_v2_v2(float r[2], const float a[2])
 523 {
 524         r[0] = -a[0];
 525         r[1] = -a[1];
 526 }
 527
 528 MINLINE void negate_v3(float r[3])
 529 {
 530         r[0] = -r[0];
 531         r[1] = -r[1];
 532         r[2] = -r[2];
 533 }
 534
 535 MINLINE void negate_v3_v3(float r[3], const float a[3])
 536 {
 537         r[0] = -a[0];
 538         r[1] = -a[1];
 539         r[2] = -a[2];
 540 }
 541
 542 MINLINE void negate_v4(float r[4])
 543 {
 544         r[0] = -r[0];
 545         r[1] = -r[1];
 546         r[2] = -r[2];
 547         r[3] = -r[3];
 548 }
 549
 550 MINLINE void negate_v4_v4(float r[4], const float a[4])
 551 {
 552         r[0] = -a[0];
 553         r[1] = -a[1];
 554         r[2] = -a[2];
 555         r[3] = -a[3];
 556 }
 557
 558 /* could add more... */
 559 MINLINE void negate_v3_short(short r[3])
 560 {
 561         r[0] = -r[0];
 562         r[1] = -r[1];
 563         r[2] = -r[2];
 564 }
 565
 566 MINLINE float dot_v2v2(const float a[2], const float b[2])
 567 {
 568         return a[0] * b[0] + a[1] * b[1];
 569 }
 570
 571 MINLINE float dot_v3v3(const float a[3], const float b[3])
 572 {
 573         return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 574 }
 575
 576 MINLINE float cross_v2v2(const float a[2], const float b[2])
 577 {
 578         return a[0] * b[1] - a[1] * b[0];
 579 }
 580
 581 MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
 582 {
 583         BLI_assert(r != a && r != b);
 584         r[0] = a[1] * b[2] - a[2] * b[1];
 585         r[1] = a[2] * b[0] - a[0] * b[2];
 586         r[2] = a[0] * b[1] - a[1] * b[0];
 587 }
 588
 589 /* Newell's Method */
 590 /* excuse this fairly specific function,
 591  * its used for polygon normals all over the place
 592  * could use a better name */
 593 MINLINE void add_newell_cross_v3_v3v3(float n[3], const float v_prev[3], const float v_curr[3])
 594 {
 595         n[0] += (v_prev[1] - v_curr[1]) * (v_prev[2] + v_curr[2]);
 596         n[1] += (v_prev[2] - v_curr[2]) * (v_prev[0] + v_curr[0]);
 597         n[2] += (v_prev[0] - v_curr[0]) * (v_prev[1] + v_curr[1]);
 598 }
 599
 600 MINLINE void star_m3_v3(float rmat[3][3], float a[3])
 601 {
 602         rmat[0][0] = rmat[1][1] = rmat[2][2] = 0.0;
 603         rmat[0][1] = -a[2];
 604         rmat[0][2] = a[1];
 605         rmat[1][0] = a[2];
 606         rmat[1][2] = -a[0];
 607         rmat[2][0] = -a[1];
 608         rmat[2][1] = a[0];
 609 }
 610
 611 /*********************************** Length **********************************/
 612
 613 MINLINE float len_squared_v2(const float v[2])
 614 {
 615         return v[0] * v[0] + v[1] * v[1];
 616 }
 617
 618 MINLINE float len_squared_v3(const float v[3])
 619 {
 620         return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
 621 }
 622
 623 MINLINE float len_manhattan_v2(const float v[2])
 624 {
 625         return fabsf(v[0]) + fabsf(v[1]);
 626 }
 627
 628 MINLINE int len_manhattan_v2_int(const int v[2])
 629 {
 630         return ABS(v[0]) + ABS(v[1]);
 631 }
 632
 633 MINLINE float len_manhattan_v3(const float v[3])
 634 {
 635         return fabsf(v[0]) + fabsf(v[1]) + fabsf(v[2]);
 636 }
 637
 638 MINLINE float len_v2(const float v[2])
 639 {
 640         return sqrtf(v[0] * v[0] + v[1] * v[1]);
 641 }
 642
 643 MINLINE float len_v2v2(const float v1[2], const float v2[2])
 644 {
 645         float x, y;
 646
 647         x = v1[0] - v2[0];
 648         y = v1[1] - v2[1];
 649         return sqrtf(x * x + y * y);
 650 }
 651
 652 MINLINE float len_v3(const float a[3])
 653 {
 654         return sqrtf(dot_v3v3(a, a));
 655 }
 656
 657 MINLINE float len_squared_v2v2(const float a[2], const float b[2])
 658 {
 659         float d[2];
 660
 661         sub_v2_v2v2(d, b, a);
 662         return dot_v2v2(d, d);
 663 }
 664
 665 MINLINE float len_squared_v3v3(const float a[3], const float b[3])
 666 {
 667         float d[3];
 668
 669         sub_v3_v3v3(d, b, a);
 670         return dot_v3v3(d, d);
 671 }
 672
 673 MINLINE float len_manhattan_v2v2(const float a[2], const float b[2])
 674 {
 675         float d[2];
 676
 677         sub_v2_v2v2(d, b, a);
 678         return len_manhattan_v2(d);
 679 }
 680
 681 MINLINE int len_manhattan_v2v2_int(const int a[2], const int b[2])
 682 {
 683         int d[2];
 684
 685         sub_v2_v2v2_int(d, b, a);
 686         return len_manhattan_v2_int(d);
 687 }
 688
 689 MINLINE float len_manhattan_v3v3(const float a[3], const float b[3])
 690 {
 691         float d[3];
 692
 693         sub_v3_v3v3(d, b, a);
 694         return len_manhattan_v3(d);
 695 }
 696
 697 MINLINE float len_v3v3(const float a[3], const float b[3])
 698 {
 699         float d[3];
 700
 701         sub_v3_v3v3(d, b, a);
 702         return len_v3(d);
 703 }
 704
 705 MINLINE float normalize_v2_v2(float r[2], const float a[2])
 706 {
 707         float d = dot_v2v2(a, a);
 708
 709         if (d > 1.0e-35f) {
 710                 d = sqrtf(d);
 711                 mul_v2_v2fl(r, a, 1.0f / d);
 712         }
 713         else {
 714                 zero_v2(r);
 715                 d = 0.0f;
 716         }
 717
 718         return d;
 719 }
 720
 721 MINLINE float normalize_v2(float n[2])
 722 {
 723         return normalize_v2_v2(n, n);
 724 }
 725
 726 MINLINE float normalize_v3_v3(float r[3], const float a[3])
 727 {
 728         float d = dot_v3v3(a, a);
 729
 730         /* a larger value causes normalize errors in a
 731          * scaled down models with camera extreme close */
 732         if (d > 1.0e-35f) {
 733                 d = sqrtf(d);
 734                 mul_v3_v3fl(r, a, 1.0f / d);
 735         }
 736         else {
 737                 zero_v3(r);
 738                 d = 0.0f;
 739         }
 740
 741         return d;
 742 }
 743
 744 MINLINE double normalize_v3_d(double n[3])
 745 {
 746         double d = n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
 747
 748         /* a larger value causes normalize errors in a
 749          * scaled down models with camera extreme close */
 750         if (d > 1.0e-35) {
 751                 double mul;
 752
 753                 d = sqrt(d);
 754                 mul = 1.0 / d;
 755
 756                 n[0] *= mul;
 757                 n[1] *= mul;
 758                 n[2] *= mul;
 759         }
 760         else {
 761                 n[0] = n[1] = n[2] = 0;
 762                 d = 0.0;
 763         }
 764
 765         return d;
 766 }
 767
 768 MINLINE float normalize_v3(float n[3])
 769 {
 770         return normalize_v3_v3(n, n);
 771 }
 772
 773 MINLINE void normal_short_to_float_v3(float out[3], const short in[3])
 774 {
 775         out[0] = in[0] * (1.0f / 32767.0f);
 776         out[1] = in[1] * (1.0f / 32767.0f);
 777         out[2] = in[2] * (1.0f / 32767.0f);
 778 }
 779
 780 MINLINE void normal_float_to_short_v3(short out[3], const float in[3])
 781 {
 782         out[0] = (short) (in[0] * 32767.0f);
 783         out[1] = (short) (in[1] * 32767.0f);
 784         out[2] = (short) (in[2] * 32767.0f);
 785 }
 786
 787 /********************************* Comparison ********************************/
 788
 789
 790 MINLINE bool is_zero_v2(const float v[2])
 791 {
 792         return (v[0] == 0 && v[1] == 0);
 793 }
 794
 795 MINLINE bool is_zero_v3(const float v[3])
 796 {
 797         return (v[0] == 0 && v[1] == 0 && v[2] == 0);
 798 }
 799
 800 MINLINE bool is_zero_v4(const float v[4])
 801 {
 802         return (v[0] == 0 && v[1] == 0 && v[2] == 0 && v[3] == 0);
 803 }
 804
 805 MINLINE bool is_finite_v2(const float v[2])
 806 {
 807         return (finite(v[0]) && finite(v[1]));
 808 }
 809
 810 MINLINE bool is_finite_v3(const float v[3])
 811 {
 812         return (finite(v[0]) && finite(v[1]) && finite(v[2]));
 813 }
 814
 815 MINLINE bool is_finite_v4(const float v[4])
 816 {
 817         return (finite(v[0]) && finite(v[1]) && finite(v[2]) && finite(v[3]));
 818 }
 819
 820 MINLINE bool is_one_v3(const float v[3])
 821 {
 822         return (v[0] == 1 && v[1] == 1 && v[2] == 1);
 823 }
 824
 825 MINLINE bool equals_v2v2(const float v1[2], const float v2[2])
 826 {
 827         return ((v1[0] == v2[0]) && (v1[1] == v2[1]));
 828 }
 829
 830 MINLINE bool equals_v3v3(const float v1[3], const float v2[3])
 831 {
 832         return ((v1[0] == v2[0]) && (v1[1] == v2[1]) && (v1[2] == v2[2]));
 833 }
 834
 835 MINLINE bool equals_v4v4(const float v1[4], const float v2[4])
 836 {
 837         return ((v1[0] == v2[0]) && (v1[1] == v2[1]) && (v1[2] == v2[2]) && (v1[3] == v2[3]));
 838 }
 839
 840 MINLINE bool compare_v2v2(const float v1[2], const float v2[2], const float limit)
 841 {
 842         if (fabsf(v1[0] - v2[0]) < limit)
 843                 if (fabsf(v1[1] - v2[1]) < limit)
 844                         return true;
 845
 846         return false;
 847 }
 848
 849 MINLINE bool compare_v3v3(const float v1[3], const float v2[3], const float limit)
 850 {
 851         if (fabsf(v1[0] - v2[0]) < limit)
 852                 if (fabsf(v1[1] - v2[1]) < limit)
 853                         if (fabsf(v1[2] - v2[2]) < limit)
 854                                 return true;
 855
 856         return false;
 857 }
 858
 859 MINLINE bool compare_len_v3v3(const float v1[3], const float v2[3], const float limit)
 860 {
 861         float x, y, z;
 862
 863         x = v1[0] - v2[0];
 864         y = v1[1] - v2[1];
 865         z = v1[2] - v2[2];
 866
 867         return ((x * x + y * y + z * z) < (limit * limit));
 868 }
 869
 870 MINLINE bool compare_v4v4(const float v1[4], const float v2[4], const float limit)
 871 {
 872         if (fabsf(v1[0] - v2[0]) < limit)
 873                 if (fabsf(v1[1] - v2[1]) < limit)
 874                         if (fabsf(v1[2] - v2[2]) < limit)
 875                                 if (fabsf(v1[3] - v2[3]) < limit)
 876                                         return true;
 877
 878         return false;
 879 }
 880
 881 MINLINE float line_point_side_v2(const float l1[2], const float l2[2], const float pt[2])
 882 {
 883         return (((l1[0] - pt[0]) * (l2[1] - pt[1])) -
 884                 ((l2[0] - pt[0]) * (l1[1] - pt[1])));
 885 }
 886
 887 #endif /* __MATH_VECTOR_INLINE_C__ */