src/vectormath/scalar/vectormath_aos.h

   1 /*
   2    Copyright (C) 2009 Sony Computer Entertainment Inc.
   3    All rights reserved.
   4
   5 This software is provided 'as-is', without any express or implied warranty.
   6 In no event will the authors be held liable for any damages arising from the use of this software.
   7 Permission is granted to anyone to use this software for any purpose,
   8 including commercial applications, and to alter it and redistribute it freely,
   9 subject to the following restrictions:
  10
  11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  13 3. This notice may not be removed or altered from any source distribution.
  14
  15 */
  16
  17 #ifndef _VECTORMATH_AOS_CPP_H
  18 #define _VECTORMATH_AOS_CPP_H
  19
  20 #include <math.h>
  21
  22 #ifdef _VECTORMATH_DEBUG
  23 #include <stdio.h>
  24 #endif
  25
  26 namespace Vectormath {
  27
  28 namespace Aos {
  29
  30 //-----------------------------------------------------------------------------
  31 // Forward Declarations
  32 //
  33
  34 class Vector3;
  35 class Vector4;
  36 class Point3;
  37 class Quat;
  38 class Matrix3;
  39 class Matrix4;
  40 class Transform3;
  41
  42 // A 3-D vector in array-of-structures format
  43 //
  44 class Vector3
  45 {
  46     float mX;
  47     float mY;
  48     float mZ;
  49 #ifndef __GNUC__
  50     float d;
  51 #endif
  52
  53 public:
  54     // Default constructor; does no initialization
  55     //
  56     inline Vector3( ) { };
  57
  58     // Copy a 3-D vector
  59     //
  60     inline Vector3( const Vector3 & vec );
  61
  62     // Construct a 3-D vector from x, y, and z elements
  63     //
  64     inline Vector3( float x, float y, float z );
  65
  66     // Copy elements from a 3-D point into a 3-D vector
  67     //
  68     explicit inline Vector3( const Point3 & pnt );
  69
  70     // Set all elements of a 3-D vector to the same scalar value
  71     //
  72     explicit inline Vector3( float scalar );
  73
  74     // Assign one 3-D vector to another
  75     //
  76     inline Vector3 & operator =( const Vector3 & vec );
  77
  78     // Set the x element of a 3-D vector
  79     //
  80     inline Vector3 & setX( float x );
  81
  82     // Set the y element of a 3-D vector
  83     //
  84     inline Vector3 & setY( float y );
  85
  86     // Set the z element of a 3-D vector
  87     //
  88     inline Vector3 & setZ( float z );
  89
  90     // Get the x element of a 3-D vector
  91     //
  92     inline float getX( ) const;
  93
  94     // Get the y element of a 3-D vector
  95     //
  96     inline float getY( ) const;
  97
  98     // Get the z element of a 3-D vector
  99     //
 100     inline float getZ( ) const;
 101
 102     // Set an x, y, or z element of a 3-D vector by index
 103     //
 104     inline Vector3 & setElem( int idx, float value );
 105
 106     // Get an x, y, or z element of a 3-D vector by index
 107     //
 108     inline float getElem( int idx ) const;
 109
 110     // Subscripting operator to set or get an element
 111     //
 112     inline float & operator []( int idx );
 113
 114     // Subscripting operator to get an element
 115     //
 116     inline float operator []( int idx ) const;
 117
 118     // Add two 3-D vectors
 119     //
 120     inline const Vector3 operator +( const Vector3 & vec ) const;
 121
 122     // Subtract a 3-D vector from another 3-D vector
 123     //
 124     inline const Vector3 operator -( const Vector3 & vec ) const;
 125
 126     // Add a 3-D vector to a 3-D point
 127     //
 128     inline const Point3 operator +( const Point3 & pnt ) const;
 129
 130     // Multiply a 3-D vector by a scalar
 131     //
 132     inline const Vector3 operator *( float scalar ) const;
 133
 134     // Divide a 3-D vector by a scalar
 135     //
 136     inline const Vector3 operator /( float scalar ) const;
 137
 138     // Perform compound assignment and addition with a 3-D vector
 139     //
 140     inline Vector3 & operator +=( const Vector3 & vec );
 141
 142     // Perform compound assignment and subtraction by a 3-D vector
 143     //
 144     inline Vector3 & operator -=( const Vector3 & vec );
 145
 146     // Perform compound assignment and multiplication by a scalar
 147     //
 148     inline Vector3 & operator *=( float scalar );
 149
 150     // Perform compound assignment and division by a scalar
 151     //
 152     inline Vector3 & operator /=( float scalar );
 153
 154     // Negate all elements of a 3-D vector
 155     //
 156     inline const Vector3 operator -( ) const;
 157
 158     // Construct x axis
 159     //
 160     static inline const Vector3 xAxis( );
 161
 162     // Construct y axis
 163     //
 164     static inline const Vector3 yAxis( );
 165
 166     // Construct z axis
 167     //
 168     static inline const Vector3 zAxis( );
 169
 170 }
 171 #ifdef __GNUC__
 172 __attribute__ ((aligned(16)))
 173 #endif
 174 ;
 175
 176 // Multiply a 3-D vector by a scalar
 177 //
 178 inline const Vector3 operator *( float scalar, const Vector3 & vec );
 179
 180 // Multiply two 3-D vectors per element
 181 //
 182 inline const Vector3 mulPerElem( const Vector3 & vec0, const Vector3 & vec1 );
 183
 184 // Divide two 3-D vectors per element
 185 // NOTE:
 186 // Floating-point behavior matches standard library function divf4.
 187 //
 188 inline const Vector3 divPerElem( const Vector3 & vec0, const Vector3 & vec1 );
 189
 190 // Compute the reciprocal of a 3-D vector per element
 191 // NOTE:
 192 // Floating-point behavior matches standard library function recipf4.
 193 //
 194 inline const Vector3 recipPerElem( const Vector3 & vec );
 195
 196 // Compute the square root of a 3-D vector per element
 197 // NOTE:
 198 // Floating-point behavior matches standard library function sqrtf4.
 199 //
 200 inline const Vector3 sqrtPerElem( const Vector3 & vec );
 201
 202 // Compute the reciprocal square root of a 3-D vector per element
 203 // NOTE:
 204 // Floating-point behavior matches standard library function rsqrtf4.
 205 //
 206 inline const Vector3 rsqrtPerElem( const Vector3 & vec );
 207
 208 // Compute the absolute value of a 3-D vector per element
 209 //
 210 inline const Vector3 absPerElem( const Vector3 & vec );
 211
 212 // Copy sign from one 3-D vector to another, per element
 213 //
 214 inline const Vector3 copySignPerElem( const Vector3 & vec0, const Vector3 & vec1 );
 215
 216 // Maximum of two 3-D vectors per element
 217 //
 218 inline const Vector3 maxPerElem( const Vector3 & vec0, const Vector3 & vec1 );
 219
 220 // Minimum of two 3-D vectors per element
 221 //
 222 inline const Vector3 minPerElem( const Vector3 & vec0, const Vector3 & vec1 );
 223
 224 // Maximum element of a 3-D vector
 225 //
 226 inline float maxElem( const Vector3 & vec );
 227
 228 // Minimum element of a 3-D vector
 229 //
 230 inline float minElem( const Vector3 & vec );
 231
 232 // Compute the sum of all elements of a 3-D vector
 233 //
 234 inline float sum( const Vector3 & vec );
 235
 236 // Compute the dot product of two 3-D vectors
 237 //
 238 inline float dot( const Vector3 & vec0, const Vector3 & vec1 );
 239
 240 // Compute the square of the length of a 3-D vector
 241 //
 242 inline float lengthSqr( const Vector3 & vec );
 243
 244 // Compute the length of a 3-D vector
 245 //
 246 inline float length( const Vector3 & vec );
 247
 248 // Normalize a 3-D vector
 249 // NOTE:
 250 // The result is unpredictable when all elements of vec are at or near zero.
 251 //
 252 inline const Vector3 normalize( const Vector3 & vec );
 253
 254 // Compute cross product of two 3-D vectors
 255 //
 256 inline const Vector3 cross( const Vector3 & vec0, const Vector3 & vec1 );
 257
 258 // Outer product of two 3-D vectors
 259 //
 260 inline const Matrix3 outer( const Vector3 & vec0, const Vector3 & vec1 );
 261
 262 // Pre-multiply a row vector by a 3x3 matrix
 263 //
 264 inline const Vector3 rowMul( const Vector3 & vec, const Matrix3 & mat );
 265
 266 // Cross-product matrix of a 3-D vector
 267 //
 268 inline const Matrix3 crossMatrix( const Vector3 & vec );
 269
 270 // Create cross-product matrix and multiply
 271 // NOTE:
 272 // Faster than separately creating a cross-product matrix and multiplying.
 273 //
 274 inline const Matrix3 crossMatrixMul( const Vector3 & vec, const Matrix3 & mat );
 275
 276 // Linear interpolation between two 3-D vectors
 277 // NOTE:
 278 // Does not clamp t between 0 and 1.
 279 //
 280 inline const Vector3 lerp( float t, const Vector3 & vec0, const Vector3 & vec1 );
 281
 282 // Spherical linear interpolation between two 3-D vectors
 283 // NOTE:
 284 // The result is unpredictable if the vectors point in opposite directions.
 285 // Does not clamp t between 0 and 1.
 286 //
 287 inline const Vector3 slerp( float t, const Vector3 & unitVec0, const Vector3 & unitVec1 );
 288
 289 // Conditionally select between two 3-D vectors
 290 //
 291 inline const Vector3 select( const Vector3 & vec0, const Vector3 & vec1, bool select1 );
 292
 293 // Load x, y, and z elements from the first three words of a float array.
 294 //
 295 //
 296 inline void loadXYZ( Vector3 & vec, const float * fptr );
 297
 298 // Store x, y, and z elements of a 3-D vector in the first three words of a float array.
 299 // Memory area of previous 16 bytes and next 32 bytes from fptr might be accessed
 300 //
 301 inline void storeXYZ( const Vector3 & vec, float * fptr );
 302
 303 // Load three-half-floats as a 3-D vector
 304 // NOTE:
 305 // This transformation does not support either denormalized numbers or NaNs.
 306 //
 307 inline void loadHalfFloats( Vector3 & vec, const unsigned short * hfptr );
 308
 309 // Store a 3-D vector as half-floats. Memory area of previous 16 bytes and next 32 bytes from <code><i>hfptr</i></code> might be accessed.
 310 // NOTE:
 311 // This transformation does not support either denormalized numbers or NaNs. Memory area of previous 16 bytes and next 32 bytes from hfptr might be accessed.
 312 //
 313 inline void storeHalfFloats( const Vector3 & vec, unsigned short * hfptr );
 314
 315 #ifdef _VECTORMATH_DEBUG
 316
 317 // Print a 3-D vector
 318 // NOTE:
 319 // Function is only defined when _VECTORMATH_DEBUG is defined.
 320 //
 321 inline void print( const Vector3 & vec );
 322
 323 // Print a 3-D vector and an associated string identifier
 324 // NOTE:
 325 // Function is only defined when _VECTORMATH_DEBUG is defined.
 326 //
 327 inline void print( const Vector3 & vec, const char * name );
 328
 329 #endif
 330
 331 // A 4-D vector in array-of-structures format
 332 //
 333 class Vector4
 334 {
 335     float mX;
 336     float mY;
 337     float mZ;
 338     float mW;
 339
 340 public:
 341     // Default constructor; does no initialization
 342     //
 343     inline Vector4( ) { };
 344
 345     // Copy a 4-D vector
 346     //
 347     inline Vector4( const Vector4 & vec );
 348
 349     // Construct a 4-D vector from x, y, z, and w elements
 350     //
 351     inline Vector4( float x, float y, float z, float w );
 352
 353     // Construct a 4-D vector from a 3-D vector and a scalar
 354     //
 355     inline Vector4( const Vector3 & xyz, float w );
 356
 357     // Copy x, y, and z from a 3-D vector into a 4-D vector, and set w to 0
 358     //
 359     explicit inline Vector4( const Vector3 & vec );
 360
 361     // Copy x, y, and z from a 3-D point into a 4-D vector, and set w to 1
 362     //
 363     explicit inline Vector4( const Point3 & pnt );
 364
 365     // Copy elements from a quaternion into a 4-D vector
 366     //
 367     explicit inline Vector4( const Quat & quat );
 368
 369     // Set all elements of a 4-D vector to the same scalar value
 370     //
 371     explicit inline Vector4( float scalar );
 372
 373     // Assign one 4-D vector to another
 374     //
 375     inline Vector4 & operator =( const Vector4 & vec );
 376
 377     // Set the x, y, and z elements of a 4-D vector
 378     // NOTE:
 379     // This function does not change the w element.
 380     //
 381     inline Vector4 & setXYZ( const Vector3 & vec );
 382
 383     // Get the x, y, and z elements of a 4-D vector
 384     //
 385     inline const Vector3 getXYZ( ) const;
 386
 387     // Set the x element of a 4-D vector
 388     //
 389     inline Vector4 & setX( float x );
 390
 391     // Set the y element of a 4-D vector
 392     //
 393     inline Vector4 & setY( float y );
 394
 395     // Set the z element of a 4-D vector
 396     //
 397     inline Vector4 & setZ( float z );
 398
 399     // Set the w element of a 4-D vector
 400     //
 401     inline Vector4 & setW( float w );
 402
 403     // Get the x element of a 4-D vector
 404     //
 405     inline float getX( ) const;
 406
 407     // Get the y element of a 4-D vector
 408     //
 409     inline float getY( ) const;
 410
 411     // Get the z element of a 4-D vector
 412     //
 413     inline float getZ( ) const;
 414
 415     // Get the w element of a 4-D vector
 416     //
 417     inline float getW( ) const;
 418
 419     // Set an x, y, z, or w element of a 4-D vector by index
 420     //
 421     inline Vector4 & setElem( int idx, float value );
 422
 423     // Get an x, y, z, or w element of a 4-D vector by index
 424     //
 425     inline float getElem( int idx ) const;
 426
 427     // Subscripting operator to set or get an element
 428     //
 429     inline float & operator []( int idx );
 430
 431     // Subscripting operator to get an element
 432     //
 433     inline float operator []( int idx ) const;
 434
 435     // Add two 4-D vectors
 436     //
 437     inline const Vector4 operator +( const Vector4 & vec ) const;
 438
 439     // Subtract a 4-D vector from another 4-D vector
 440     //
 441     inline const Vector4 operator -( const Vector4 & vec ) const;
 442
 443     // Multiply a 4-D vector by a scalar
 444     //
 445     inline const Vector4 operator *( float scalar ) const;
 446
 447     // Divide a 4-D vector by a scalar
 448     //
 449     inline const Vector4 operator /( float scalar ) const;
 450
 451     // Perform compound assignment and addition with a 4-D vector
 452     //
 453     inline Vector4 & operator +=( const Vector4 & vec );
 454
 455     // Perform compound assignment and subtraction by a 4-D vector
 456     //
 457     inline Vector4 & operator -=( const Vector4 & vec );
 458
 459     // Perform compound assignment and multiplication by a scalar
 460     //
 461     inline Vector4 & operator *=( float scalar );
 462
 463     // Perform compound assignment and division by a scalar
 464     //
 465     inline Vector4 & operator /=( float scalar );
 466
 467     // Negate all elements of a 4-D vector
 468     //
 469     inline const Vector4 operator -( ) const;
 470
 471     // Construct x axis
 472     //
 473     static inline const Vector4 xAxis( );
 474
 475     // Construct y axis
 476     //
 477     static inline const Vector4 yAxis( );
 478
 479     // Construct z axis
 480     //
 481     static inline const Vector4 zAxis( );
 482
 483     // Construct w axis
 484     //
 485     static inline const Vector4 wAxis( );
 486
 487 }
 488 #ifdef __GNUC__
 489 __attribute__ ((aligned(16)))
 490 #endif
 491 ;
 492
 493 // Multiply a 4-D vector by a scalar
 494 //
 495 inline const Vector4 operator *( float scalar, const Vector4 & vec );
 496
 497 // Multiply two 4-D vectors per element
 498 //
 499 inline const Vector4 mulPerElem( const Vector4 & vec0, const Vector4 & vec1 );
 500
 501 // Divide two 4-D vectors per element
 502 // NOTE:
 503 // Floating-point behavior matches standard library function divf4.
 504 //
 505 inline const Vector4 divPerElem( const Vector4 & vec0, const Vector4 & vec1 );
 506
 507 // Compute the reciprocal of a 4-D vector per element
 508 // NOTE:
 509 // Floating-point behavior matches standard library function recipf4.
 510 //
 511 inline const Vector4 recipPerElem( const Vector4 & vec );
 512
 513 // Compute the square root of a 4-D vector per element
 514 // NOTE:
 515 // Floating-point behavior matches standard library function sqrtf4.
 516 //
 517 inline const Vector4 sqrtPerElem( const Vector4 & vec );
 518
 519 // Compute the reciprocal square root of a 4-D vector per element
 520 // NOTE:
 521 // Floating-point behavior matches standard library function rsqrtf4.
 522 //
 523 inline const Vector4 rsqrtPerElem( const Vector4 & vec );
 524
 525 // Compute the absolute value of a 4-D vector per element
 526 //
 527 inline const Vector4 absPerElem( const Vector4 & vec );
 528
 529 // Copy sign from one 4-D vector to another, per element
 530 //
 531 inline const Vector4 copySignPerElem( const Vector4 & vec0, const Vector4 & vec1 );
 532
 533 // Maximum of two 4-D vectors per element
 534 //
 535 inline const Vector4 maxPerElem( const Vector4 & vec0, const Vector4 & vec1 );
 536
 537 // Minimum of two 4-D vectors per element
 538 //
 539 inline const Vector4 minPerElem( const Vector4 & vec0, const Vector4 & vec1 );
 540
 541 // Maximum element of a 4-D vector
 542 //
 543 inline float maxElem( const Vector4 & vec );
 544
 545 // Minimum element of a 4-D vector
 546 //
 547 inline float minElem( const Vector4 & vec );
 548
 549 // Compute the sum of all elements of a 4-D vector
 550 //
 551 inline float sum( const Vector4 & vec );
 552
 553 // Compute the dot product of two 4-D vectors
 554 //
 555 inline float dot( const Vector4 & vec0, const Vector4 & vec1 );
 556
 557 // Compute the square of the length of a 4-D vector
 558 //
 559 inline float lengthSqr( const Vector4 & vec );
 560
 561 // Compute the length of a 4-D vector
 562 //
 563 inline float length( const Vector4 & vec );
 564
 565 // Normalize a 4-D vector
 566 // NOTE:
 567 // The result is unpredictable when all elements of vec are at or near zero.
 568 //
 569 inline const Vector4 normalize( const Vector4 & vec );
 570
 571 // Outer product of two 4-D vectors
 572 //
 573 inline const Matrix4 outer( const Vector4 & vec0, const Vector4 & vec1 );
 574
 575 // Linear interpolation between two 4-D vectors
 576 // NOTE:
 577 // Does not clamp t between 0 and 1.
 578 //
 579 inline const Vector4 lerp( float t, const Vector4 & vec0, const Vector4 & vec1 );
 580
 581 // Spherical linear interpolation between two 4-D vectors
 582 // NOTE:
 583 // The result is unpredictable if the vectors point in opposite directions.
 584 // Does not clamp t between 0 and 1.
 585 //
 586 inline const Vector4 slerp( float t, const Vector4 & unitVec0, const Vector4 & unitVec1 );
 587
 588 // Conditionally select between two 4-D vectors
 589 //
 590 inline const Vector4 select( const Vector4 & vec0, const Vector4 & vec1, bool select1 );
 591
 592 // Load x, y, z, and w elements from the first four words of a float array.
 593 //
 594 //
 595 inline void loadXYZW( Vector4 & vec, const float * fptr );
 596
 597 // Store x, y, z, and w elements of a 4-D vector in the first four words of a float array.
 598 // Memory area of previous 16 bytes and next 32 bytes from fptr might be accessed
 599 //
 600 inline void storeXYZW( const Vector4 & vec, float * fptr );
 601
 602 // Load four-half-floats as a 4-D vector
 603 // NOTE:
 604 // This transformation does not support either denormalized numbers or NaNs.
 605 //
 606 inline void loadHalfFloats( Vector4 & vec, const unsigned short * hfptr );
 607
 608 // Store a 4-D vector as half-floats. Memory area of previous 16 bytes and next 32 bytes from <code><i>hfptr</i></code> might be accessed.
 609 // NOTE:
 610 // This transformation does not support either denormalized numbers or NaNs. Memory area of previous 16 bytes and next 32 bytes from hfptr might be accessed.
 611 //
 612 inline void storeHalfFloats( const Vector4 & vec, unsigned short * hfptr );
 613
 614 #ifdef _VECTORMATH_DEBUG
 615
 616 // Print a 4-D vector
 617 // NOTE:
 618 // Function is only defined when _VECTORMATH_DEBUG is defined.
 619 //
 620 inline void print( const Vector4 & vec );
 621
 622 // Print a 4-D vector and an associated string identifier
 623 // NOTE:
 624 // Function is only defined when _VECTORMATH_DEBUG is defined.
 625 //
 626 inline void print( const Vector4 & vec, const char * name );
 627
 628 #endif
 629
 630 // A 3-D point in array-of-structures format
 631 //
 632 class Point3
 633 {
 634     float mX;
 635     float mY;
 636     float mZ;
 637 #ifndef __GNUC__
 638     float d;
 639 #endif
 640
 641 public:
 642     // Default constructor; does no initialization
 643     //
 644     inline Point3( ) { };
 645
 646     // Copy a 3-D point
 647     //
 648     inline Point3( const Point3 & pnt );
 649
 650     // Construct a 3-D point from x, y, and z elements
 651     //
 652     inline Point3( float x, float y, float z );
 653
 654     // Copy elements from a 3-D vector into a 3-D point
 655     //
 656     explicit inline Point3( const Vector3 & vec );
 657
 658     // Set all elements of a 3-D point to the same scalar value
 659     //
 660     explicit inline Point3( float scalar );
 661
 662     // Assign one 3-D point to another
 663     //
 664     inline Point3 & operator =( const Point3 & pnt );
 665
 666     // Set the x element of a 3-D point
 667     //
 668     inline Point3 & setX( float x );
 669
 670     // Set the y element of a 3-D point
 671     //
 672     inline Point3 & setY( float y );
 673
 674     // Set the z element of a 3-D point
 675     //
 676     inline Point3 & setZ( float z );
 677
 678     // Get the x element of a 3-D point
 679     //
 680     inline float getX( ) const;
 681
 682     // Get the y element of a 3-D point
 683     //
 684     inline float getY( ) const;
 685
 686     // Get the z element of a 3-D point
 687     //
 688     inline float getZ( ) const;
 689
 690     // Set an x, y, or z element of a 3-D point by index
 691     //
 692     inline Point3 & setElem( int idx, float value );
 693
 694     // Get an x, y, or z element of a 3-D point by index
 695     //
 696     inline float getElem( int idx ) const;
 697
 698     // Subscripting operator to set or get an element
 699     //
 700     inline float & operator []( int idx );
 701
 702     // Subscripting operator to get an element
 703     //
 704     inline float operator []( int idx ) const;
 705
 706     // Subtract a 3-D point from another 3-D point
 707     //
 708     inline const Vector3 operator -( const Point3 & pnt ) const;
 709
 710     // Add a 3-D point to a 3-D vector
 711     //
 712     inline const Point3 operator +( const Vector3 & vec ) const;
 713
 714     // Subtract a 3-D vector from a 3-D point
 715     //
 716     inline const Point3 operator -( const Vector3 & vec ) const;
 717
 718     // Perform compound assignment and addition with a 3-D vector
 719     //
 720     inline Point3 & operator +=( const Vector3 & vec );
 721
 722     // Perform compound assignment and subtraction by a 3-D vector
 723     //
 724     inline Point3 & operator -=( const Vector3 & vec );
 725
 726 }
 727 #ifdef __GNUC__
 728 __attribute__ ((aligned(16)))
 729 #endif
 730 ;
 731
 732 // Multiply two 3-D points per element
 733 //
 734 inline const Point3 mulPerElem( const Point3 & pnt0, const Point3 & pnt1 );
 735
 736 // Divide two 3-D points per element
 737 // NOTE:
 738 // Floating-point behavior matches standard library function divf4.
 739 //
 740 inline const Point3 divPerElem( const Point3 & pnt0, const Point3 & pnt1 );
 741
 742 // Compute the reciprocal of a 3-D point per element
 743 // NOTE:
 744 // Floating-point behavior matches standard library function recipf4.
 745 //
 746 inline const Point3 recipPerElem( const Point3 & pnt );
 747
 748 // Compute the square root of a 3-D point per element
 749 // NOTE:
 750 // Floating-point behavior matches standard library function sqrtf4.
 751 //
 752 inline const Point3 sqrtPerElem( const Point3 & pnt );
 753
 754 // Compute the reciprocal square root of a 3-D point per element
 755 // NOTE:
 756 // Floating-point behavior matches standard library function rsqrtf4.
 757 //
 758 inline const Point3 rsqrtPerElem( const Point3 & pnt );
 759
 760 // Compute the absolute value of a 3-D point per element
 761 //
 762 inline const Point3 absPerElem( const Point3 & pnt );
 763
 764 // Copy sign from one 3-D point to another, per element
 765 //
 766 inline const Point3 copySignPerElem( const Point3 & pnt0, const Point3 & pnt1 );
 767
 768 // Maximum of two 3-D points per element
 769 //
 770 inline const Point3 maxPerElem( const Point3 & pnt0, const Point3 & pnt1 );
 771
 772 // Minimum of two 3-D points per element
 773 //
 774 inline const Point3 minPerElem( const Point3 & pnt0, const Point3 & pnt1 );
 775
 776 // Maximum element of a 3-D point
 777 //
 778 inline float maxElem( const Point3 & pnt );
 779
 780 // Minimum element of a 3-D point
 781 //
 782 inline float minElem( const Point3 & pnt );
 783
 784 // Compute the sum of all elements of a 3-D point
 785 //
 786 inline float sum( const Point3 & pnt );
 787
 788 // Apply uniform scale to a 3-D point
 789 //
 790 inline const Point3 scale( const Point3 & pnt, float scaleVal );
 791
 792 // Apply non-uniform scale to a 3-D point
 793 //
 794 inline const Point3 scale( const Point3 & pnt, const Vector3 & scaleVec );
 795
 796 // Scalar projection of a 3-D point on a unit-length 3-D vector
 797 //
 798 inline float projection( const Point3 & pnt, const Vector3 & unitVec );
 799
 800 // Compute the square of the distance of a 3-D point from the coordinate-system origin
 801 //
 802 inline float distSqrFromOrigin( const Point3 & pnt );
 803
 804 // Compute the distance of a 3-D point from the coordinate-system origin
 805 //
 806 inline float distFromOrigin( const Point3 & pnt );
 807
 808 // Compute the square of the distance between two 3-D points
 809 //
 810 inline float distSqr( const Point3 & pnt0, const Point3 & pnt1 );
 811
 812 // Compute the distance between two 3-D points
 813 //
 814 inline float dist( const Point3 & pnt0, const Point3 & pnt1 );
 815
 816 // Linear interpolation between two 3-D points
 817 // NOTE:
 818 // Does not clamp t between 0 and 1.
 819 //
 820 inline const Point3 lerp( float t, const Point3 & pnt0, const Point3 & pnt1 );
 821
 822 // Conditionally select between two 3-D points
 823 //
 824 inline const Point3 select( const Point3 & pnt0, const Point3 & pnt1, bool select1 );
 825
 826 // Load x, y, and z elements from the first three words of a float array.
 827 //
 828 //
 829 inline void loadXYZ( Point3 & pnt, const float * fptr );
 830
 831 // Store x, y, and z elements of a 3-D point in the first three words of a float array.
 832 // Memory area of previous 16 bytes and next 32 bytes from fptr might be accessed
 833 //
 834 inline void storeXYZ( const Point3 & pnt, float * fptr );
 835
 836 // Load three-half-floats as a 3-D point
 837 // NOTE:
 838 // This transformation does not support either denormalized numbers or NaNs.
 839 //
 840 inline void loadHalfFloats( Point3 & pnt, const unsigned short * hfptr );
 841
 842 // Store a 3-D point as half-floats. Memory area of previous 16 bytes and next 32 bytes from <code><i>hfptr</i></code> might be accessed.
 843 // NOTE:
 844 // This transformation does not support either denormalized numbers or NaNs. Memory area of previous 16 bytes and next 32 bytes from hfptr might be accessed.
 845 //
 846 inline void storeHalfFloats( const Point3 & pnt, unsigned short * hfptr );
 847
 848 #ifdef _VECTORMATH_DEBUG
 849
 850 // Print a 3-D point
 851 // NOTE:
 852 // Function is only defined when _VECTORMATH_DEBUG is defined.
 853 //
 854 inline void print( const Point3 & pnt );
 855
 856 // Print a 3-D point and an associated string identifier
 857 // NOTE:
 858 // Function is only defined when _VECTORMATH_DEBUG is defined.
 859 //
 860 inline void print( const Point3 & pnt, const char * name );
 861
 862 #endif
 863
 864 // A quaternion in array-of-structures format
 865 //
 866 class Quat
 867 {
 868     float mX;
 869     float mY;
 870     float mZ;
 871     float mW;
 872
 873 public:
 874     // Default constructor; does no initialization
 875     //
 876     inline Quat( ) { };
 877
 878     // Copy a quaternion
 879     //
 880     inline Quat( const Quat & quat );
 881
 882     // Construct a quaternion from x, y, z, and w elements
 883     //
 884     inline Quat( float x, float y, float z, float w );
 885
 886     // Construct a quaternion from a 3-D vector and a scalar
 887     //
 888     inline Quat( const Vector3 & xyz, float w );
 889
 890     // Copy elements from a 4-D vector into a quaternion
 891     //
 892     explicit inline Quat( const Vector4 & vec );
 893
 894     // Convert a rotation matrix to a unit-length quaternion
 895     //
 896     explicit inline Quat( const Matrix3 & rotMat );
 897
 898     // Set all elements of a quaternion to the same scalar value
 899     //
 900     explicit inline Quat( float scalar );
 901
 902     // Assign one quaternion to another
 903     //
 904     inline Quat & operator =( const Quat & quat );
 905
 906     // Set the x, y, and z elements of a quaternion
 907     // NOTE:
 908     // This function does not change the w element.
 909     //
 910     inline Quat & setXYZ( const Vector3 & vec );
 911
 912     // Get the x, y, and z elements of a quaternion
 913     //
 914     inline const Vector3 getXYZ( ) const;
 915
 916     // Set the x element of a quaternion
 917     //
 918     inline Quat & setX( float x );
 919
 920     // Set the y element of a quaternion
 921     //
 922     inline Quat & setY( float y );
 923
 924     // Set the z element of a quaternion
 925     //
 926     inline Quat & setZ( float z );
 927
 928     // Set the w element of a quaternion
 929     //
 930     inline Quat & setW( float w );
 931
 932     // Get the x element of a quaternion
 933     //
 934     inline float getX( ) const;
 935
 936     // Get the y element of a quaternion
 937     //
 938     inline float getY( ) const;
 939
 940     // Get the z element of a quaternion
 941     //
 942     inline float getZ( ) const;
 943
 944     // Get the w element of a quaternion
 945     //
 946     inline float getW( ) const;
 947
 948     // Set an x, y, z, or w element of a quaternion by index
 949     //
 950     inline Quat & setElem( int idx, float value );
 951
 952     // Get an x, y, z, or w element of a quaternion by index
 953     //
 954     inline float getElem( int idx ) const;
 955
 956     // Subscripting operator to set or get an element
 957     //
 958     inline float & operator []( int idx );
 959
 960     // Subscripting operator to get an element
 961     //
 962     inline float operator []( int idx ) const;
 963
 964     // Add two quaternions
 965     //
 966     inline const Quat operator +( const Quat & quat ) const;
 967
 968     // Subtract a quaternion from another quaternion
 969     //
 970     inline const Quat operator -( const Quat & quat ) const;
 971
 972     // Multiply two quaternions
 973     //
 974     inline const Quat operator *( const Quat & quat ) const;
 975
 976     // Multiply a quaternion by a scalar
 977     //
 978     inline const Quat operator *( float scalar ) const;
 979
 980     // Divide a quaternion by a scalar
 981     //
 982     inline const Quat operator /( float scalar ) const;
 983
 984     // Perform compound assignment and addition with a quaternion
 985     //
 986     inline Quat & operator +=( const Quat & quat );
 987
 988     // Perform compound assignment and subtraction by a quaternion
 989     //
 990     inline Quat & operator -=( const Quat & quat );
 991
 992     // Perform compound assignment and multiplication by a quaternion
 993     //
 994     inline Quat & operator *=( const Quat & quat );
 995
 996     // Perform compound assignment and multiplication by a scalar
 997     //
 998     inline Quat & operator *=( float scalar );
 999
1000     // Perform compound assignment and division by a scalar
1001     //
1002     inline Quat & operator /=( float scalar );
1003
1004     // Negate all elements of a quaternion
1005     //
1006     inline const Quat operator -( ) const;
1007
1008     // Construct an identity quaternion
1009     //
1010     static inline const Quat identity( );
1011
1012     // Construct a quaternion to rotate between two unit-length 3-D vectors
1013     // NOTE:
1014     // The result is unpredictable if unitVec0 and unitVec1 point in opposite directions.
1015     //
1016     static inline const Quat rotation( const Vector3 & unitVec0, const Vector3 & unitVec1 );
1017
1018     // Construct a quaternion to rotate around a unit-length 3-D vector
1019     //
1020     static inline const Quat rotation( float radians, const Vector3 & unitVec );
1021
1022     // Construct a quaternion to rotate around the x axis
1023     //
1024     static inline const Quat rotationX( float radians );
1025
1026     // Construct a quaternion to rotate around the y axis
1027     //
1028     static inline const Quat rotationY( float radians );
1029
1030     // Construct a quaternion to rotate around the z axis
1031     //
1032     static inline const Quat rotationZ( float radians );
1033
1034 }
1035 #ifdef __GNUC__
1036 __attribute__ ((aligned(16)))
1037 #endif
1038 ;
1039
1040 // Multiply a quaternion by a scalar
1041 //
1042 inline const Quat operator *( float scalar, const Quat & quat );
1043
1044 // Compute the conjugate of a quaternion
1045 //
1046 inline const Quat conj( const Quat & quat );
1047
1048 // Use a unit-length quaternion to rotate a 3-D vector
1049 //
1050 inline const Vector3 rotate( const Quat & unitQuat, const Vector3 & vec );
1051
1052 // Compute the dot product of two quaternions
1053 //
1054 inline float dot( const Quat & quat0, const Quat & quat1 );
1055
1056 // Compute the norm of a quaternion
1057 //
1058 inline float norm( const Quat & quat );
1059
1060 // Compute the length of a quaternion
1061 //
1062 inline float length( const Quat & quat );
1063
1064 // Normalize a quaternion
1065 // NOTE:
1066 // The result is unpredictable when all elements of quat are at or near zero.
1067 //
1068 inline const Quat normalize( const Quat & quat );
1069
1070 // Linear interpolation between two quaternions
1071 // NOTE:
1072 // Does not clamp t between 0 and 1.
1073 //
1074 inline const Quat lerp( float t, const Quat & quat0, const Quat & quat1 );
1075
1076 // Spherical linear interpolation between two quaternions
1077 // NOTE:
1078 // Interpolates along the shortest path between orientations.
1079 // Does not clamp t between 0 and 1.
1080 //
1081 inline const Quat slerp( float t, const Quat & unitQuat0, const Quat & unitQuat1 );
1082
1083 // Spherical quadrangle interpolation
1084 //
1085 inline const Quat squad( float t, const Quat & unitQuat0, const Quat & unitQuat1, const Quat & unitQuat2, const Quat & unitQuat3 );
1086
1087 // Conditionally select between two quaternions
1088 //
1089 inline const Quat select( const Quat & quat0, const Quat & quat1, bool select1 );
1090
1091 // Load x, y, z, and w elements from the first four words of a float array.
1092 //
1093 //
1094 inline void loadXYZW( Quat & quat, const float * fptr );
1095
1096 // Store x, y, z, and w elements of a quaternion in the first four words of a float array.
1097 // Memory area of previous 16 bytes and next 32 bytes from fptr might be accessed
1098 //
1099 inline void storeXYZW( const Quat & quat, float * fptr );
1100
1101 #ifdef _VECTORMATH_DEBUG
1102
1103 // Print a quaternion
1104 // NOTE:
1105 // Function is only defined when _VECTORMATH_DEBUG is defined.
1106 //
1107 inline void print( const Quat & quat );
1108
1109 // Print a quaternion and an associated string identifier
1110 // NOTE:
1111 // Function is only defined when _VECTORMATH_DEBUG is defined.
1112 //
1113 inline void print( const Quat & quat, const char * name );
1114
1115 #endif
1116
1117 // A 3x3 matrix in array-of-structures format
1118 //
1119 class Matrix3
1120 {
1121     Vector3 mCol0;
1122     Vector3 mCol1;
1123     Vector3 mCol2;
1124
1125 public:
1126     // Default constructor; does no initialization
1127     //
1128     inline Matrix3( ) { };
1129
1130     // Copy a 3x3 matrix
1131     //
1132     inline Matrix3( const Matrix3 & mat );
1133
1134     // Construct a 3x3 matrix containing the specified columns
1135     //
1136     inline Matrix3( const Vector3 & col0, const Vector3 & col1, const Vector3 & col2 );
1137
1138     // Construct a 3x3 rotation matrix from a unit-length quaternion
1139     //
1140     explicit inline Matrix3( const Quat & unitQuat );
1141
1142     // Set all elements of a 3x3 matrix to the same scalar value
1143     //
1144     explicit inline Matrix3( float scalar );
1145
1146     // Assign one 3x3 matrix to another
1147     //
1148     inline Matrix3 & operator =( const Matrix3 & mat );
1149
1150     // Set column 0 of a 3x3 matrix
1151     //
1152     inline Matrix3 & setCol0( const Vector3 & col0 );
1153
1154     // Set column 1 of a 3x3 matrix
1155     //
1156     inline Matrix3 & setCol1( const Vector3 & col1 );
1157
1158     // Set column 2 of a 3x3 matrix
1159     //
1160     inline Matrix3 & setCol2( const Vector3 & col2 );
1161
1162     // Get column 0 of a 3x3 matrix
1163     //
1164     inline const Vector3 getCol0( ) const;
1165
1166     // Get column 1 of a 3x3 matrix
1167     //
1168     inline const Vector3 getCol1( ) const;
1169
1170     // Get column 2 of a 3x3 matrix
1171     //
1172     inline const Vector3 getCol2( ) const;
1173
1174     // Set the column of a 3x3 matrix referred to by the specified index
1175     //
1176     inline Matrix3 & setCol( int col, const Vector3 & vec );
1177
1178     // Set the row of a 3x3 matrix referred to by the specified index
1179     //
1180     inline Matrix3 & setRow( int row, const Vector3 & vec );
1181
1182     // Get the column of a 3x3 matrix referred to by the specified index
1183     //
1184     inline const Vector3 getCol( int col ) const;
1185
1186     // Get the row of a 3x3 matrix referred to by the specified index
1187     //
1188     inline const Vector3 getRow( int row ) const;
1189
1190     // Subscripting operator to set or get a column
1191     //
1192     inline Vector3 & operator []( int col );
1193
1194     // Subscripting operator to get a column
1195     //
1196     inline const Vector3 operator []( int col ) const;
1197
1198     // Set the element of a 3x3 matrix referred to by column and row indices
1199     //
1200     inline Matrix3 & setElem( int col, int row, float val );
1201
1202     // Get the element of a 3x3 matrix referred to by column and row indices
1203     //
1204     inline float getElem( int col, int row ) const;
1205
1206     // Add two 3x3 matrices
1207     //
1208     inline const Matrix3 operator +( const Matrix3 & mat ) const;
1209
1210     // Subtract a 3x3 matrix from another 3x3 matrix
1211     //
1212     inline const Matrix3 operator -( const Matrix3 & mat ) const;
1213
1214     // Negate all elements of a 3x3 matrix
1215     //
1216     inline const Matrix3 operator -( ) const;
1217
1218     // Multiply a 3x3 matrix by a scalar
1219     //
1220     inline const Matrix3 operator *( float scalar ) const;
1221
1222     // Multiply a 3x3 matrix by a 3-D vector
1223     //
1224     inline const Vector3 operator *( const Vector3 & vec ) const;
1225
1226     // Multiply two 3x3 matrices
1227     //
1228     inline const Matrix3 operator *( const Matrix3 & mat ) const;
1229
1230     // Perform compound assignment and addition with a 3x3 matrix
1231     //
1232     inline Matrix3 & operator +=( const Matrix3 & mat );
1233
1234     // Perform compound assignment and subtraction by a 3x3 matrix
1235     //
1236     inline Matrix3 & operator -=( const Matrix3 & mat );
1237
1238     // Perform compound assignment and multiplication by a scalar
1239     //
1240     inline Matrix3 & operator *=( float scalar );
1241
1242     // Perform compound assignment and multiplication by a 3x3 matrix
1243     //
1244     inline Matrix3 & operator *=( const Matrix3 & mat );
1245
1246     // Construct an identity 3x3 matrix
1247     //
1248     static inline const Matrix3 identity( );
1249
1250     // Construct a 3x3 matrix to rotate around the x axis
1251     //
1252     static inline const Matrix3 rotationX( float radians );
1253
1254     // Construct a 3x3 matrix to rotate around the y axis
1255     //
1256     static inline const Matrix3 rotationY( float radians );
1257
1258     // Construct a 3x3 matrix to rotate around the z axis
1259     //
1260     static inline const Matrix3 rotationZ( float radians );
1261
1262     // Construct a 3x3 matrix to rotate around the x, y, and z axes
1263     //
1264     static inline const Matrix3 rotationZYX( const Vector3 & radiansXYZ );
1265
1266     // Construct a 3x3 matrix to rotate around a unit-length 3-D vector
1267     //
1268     static inline const Matrix3 rotation( float radians, const Vector3 & unitVec );
1269
1270     // Construct a rotation matrix from a unit-length quaternion
1271     //
1272     static inline const Matrix3 rotation( const Quat & unitQuat );
1273
1274     // Construct a 3x3 matrix to perform scaling
1275     //
1276     static inline const Matrix3 scale( const Vector3 & scaleVec );
1277
1278 };
1279 // Multiply a 3x3 matrix by a scalar
1280 //
1281 inline const Matrix3 operator *( float scalar, const Matrix3 & mat );
1282
1283 // Append (post-multiply) a scale transformation to a 3x3 matrix
1284 // NOTE:
1285 // Faster than creating and multiplying a scale transformation matrix.
1286 //
1287 inline const Matrix3 appendScale( const Matrix3 & mat, const Vector3 & scaleVec );
1288
1289 // Prepend (pre-multiply) a scale transformation to a 3x3 matrix
1290 // NOTE:
1291 // Faster than creating and multiplying a scale transformation matrix.
1292 //
1293 inline const Matrix3 prependScale( const Vector3 & scaleVec, const Matrix3 & mat );
1294
1295 // Multiply two 3x3 matrices per element
1296 //
1297 inline const Matrix3 mulPerElem( const Matrix3 & mat0, const Matrix3 & mat1 );
1298
1299 // Compute the absolute value of a 3x3 matrix per element
1300 //
1301 inline const Matrix3 absPerElem( const Matrix3 & mat );
1302
1303 // Transpose of a 3x3 matrix
1304 //
1305 inline const Matrix3 transpose( const Matrix3 & mat );
1306
1307 // Compute the inverse of a 3x3 matrix
1308 // NOTE:
1309 // Result is unpredictable when the determinant of mat is equal to or near 0.
1310 //
1311 inline const Matrix3 inverse( const Matrix3 & mat );
1312
1313 // Determinant of a 3x3 matrix
1314 //
1315 inline float determinant( const Matrix3 & mat );
1316
1317 // Conditionally select between two 3x3 matrices
1318 //
1319 inline const Matrix3 select( const Matrix3 & mat0, const Matrix3 & mat1, bool select1 );
1320
1321 #ifdef _VECTORMATH_DEBUG
1322
1323 // Print a 3x3 matrix
1324 // NOTE:
1325 // Function is only defined when _VECTORMATH_DEBUG is defined.
1326 //
1327 inline void print( const Matrix3 & mat );
1328
1329 // Print a 3x3 matrix and an associated string identifier
1330 // NOTE:
1331 // Function is only defined when _VECTORMATH_DEBUG is defined.
1332 //
1333 inline void print( const Matrix3 & mat, const char * name );
1334
1335 #endif
1336
1337 // A 4x4 matrix in array-of-structures format
1338 //
1339 class Matrix4
1340 {
1341     Vector4 mCol0;
1342     Vector4 mCol1;
1343     Vector4 mCol2;
1344     Vector4 mCol3;
1345
1346 public:
1347     // Default constructor; does no initialization
1348     //
1349     inline Matrix4( ) { };
1350
1351     // Copy a 4x4 matrix
1352     //
1353     inline Matrix4( const Matrix4 & mat );
1354
1355     // Construct a 4x4 matrix containing the specified columns
1356     //
1357     inline Matrix4( const Vector4 & col0, const Vector4 & col1, const Vector4 & col2, const Vector4 & col3 );
1358
1359     // Construct a 4x4 matrix from a 3x4 transformation matrix
1360     //
1361     explicit inline Matrix4( const Transform3 & mat );
1362
1363     // Construct a 4x4 matrix from a 3x3 matrix and a 3-D vector
1364     //
1365     inline Matrix4( const Matrix3 & mat, const Vector3 & translateVec );
1366
1367     // Construct a 4x4 matrix from a unit-length quaternion and a 3-D vector
1368     //
1369     inline Matrix4( const Quat & unitQuat, const Vector3 & translateVec );
1370
1371     // Set all elements of a 4x4 matrix to the same scalar value
1372     //
1373     explicit inline Matrix4( float scalar );
1374
1375     // Assign one 4x4 matrix to another
1376     //
1377     inline Matrix4 & operator =( const Matrix4 & mat );
1378
1379     // Set the upper-left 3x3 submatrix
1380     // NOTE:
1381     // This function does not change the bottom row elements.
1382     //
1383     inline Matrix4 & setUpper3x3( const Matrix3 & mat3 );
1384
1385     // Get the upper-left 3x3 submatrix of a 4x4 matrix
1386     //
1387     inline const Matrix3 getUpper3x3( ) const;
1388
1389     // Set translation component
1390     // NOTE:
1391     // This function does not change the bottom row elements.
1392     //
1393     inline Matrix4 & setTranslation( const Vector3 & translateVec );
1394
1395     // Get the translation component of a 4x4 matrix
1396     //
1397     inline const Vector3 getTranslation( ) const;
1398
1399     // Set column 0 of a 4x4 matrix
1400     //
1401     inline Matrix4 & setCol0( const Vector4 & col0 );
1402
1403     // Set column 1 of a 4x4 matrix
1404     //
1405     inline Matrix4 & setCol1( const Vector4 & col1 );
1406
1407     // Set column 2 of a 4x4 matrix
1408     //
1409     inline Matrix4 & setCol2( const Vector4 & col2 );
1410
1411     // Set column 3 of a 4x4 matrix
1412     //
1413     inline Matrix4 & setCol3( const Vector4 & col3 );
1414
1415     // Get column 0 of a 4x4 matrix
1416     //
1417     inline const Vector4 getCol0( ) const;
1418
1419     // Get column 1 of a 4x4 matrix
1420     //
1421     inline const Vector4 getCol1( ) const;
1422
1423     // Get column 2 of a 4x4 matrix
1424     //
1425     inline const Vector4 getCol2( ) const;
1426
1427     // Get column 3 of a 4x4 matrix
1428     //
1429     inline const Vector4 getCol3( ) const;
1430
1431     // Set the column of a 4x4 matrix referred to by the specified index
1432     //
1433     inline Matrix4 & setCol( int col, const Vector4 & vec );
1434
1435     // Set the row of a 4x4 matrix referred to by the specified index
1436     //
1437     inline Matrix4 & setRow( int row, const Vector4 & vec );
1438
1439     // Get the column of a 4x4 matrix referred to by the specified index
1440     //
1441     inline const Vector4 getCol( int col ) const;
1442
1443     // Get the row of a 4x4 matrix referred to by the specified index
1444     //
1445     inline const Vector4 getRow( int row ) const;
1446
1447     // Subscripting operator to set or get a column
1448     //
1449     inline Vector4 & operator []( int col );
1450
1451     // Subscripting operator to get a column
1452     //
1453     inline const Vector4 operator []( int col ) const;
1454
1455     // Set the element of a 4x4 matrix referred to by column and row indices
1456     //
1457     inline Matrix4 & setElem( int col, int row, float val );
1458
1459     // Get the element of a 4x4 matrix referred to by column and row indices
1460     //
1461     inline float getElem( int col, int row ) const;
1462
1463     // Add two 4x4 matrices
1464     //
1465     inline const Matrix4 operator +( const Matrix4 & mat ) const;
1466
1467     // Subtract a 4x4 matrix from another 4x4 matrix
1468     //
1469     inline const Matrix4 operator -( const Matrix4 & mat ) const;
1470
1471     // Negate all elements of a 4x4 matrix
1472     //
1473     inline const Matrix4 operator -( ) const;
1474
1475     // Multiply a 4x4 matrix by a scalar
1476     //
1477     inline const Matrix4 operator *( float scalar ) const;
1478
1479     // Multiply a 4x4 matrix by a 4-D vector
1480     //
1481     inline const Vector4 operator *( const Vector4 & vec ) const;
1482
1483     // Multiply a 4x4 matrix by a 3-D vector
1484     //
1485     inline const Vector4 operator *( const Vector3 & vec ) const;
1486
1487     // Multiply a 4x4 matrix by a 3-D point
1488     //
1489     inline const Vector4 operator *( const Point3 & pnt ) const;
1490
1491     // Multiply two 4x4 matrices
1492     //
1493     inline const Matrix4 operator *( const Matrix4 & mat ) const;
1494
1495     // Multiply a 4x4 matrix by a 3x4 transformation matrix
1496     //
1497     inline const Matrix4 operator *( const Transform3 & tfrm ) const;
1498
1499     // Perform compound assignment and addition with a 4x4 matrix
1500     //
1501     inline Matrix4 & operator +=( const Matrix4 & mat );
1502
1503     // Perform compound assignment and subtraction by a 4x4 matrix
1504     //
1505     inline Matrix4 & operator -=( const Matrix4 & mat );
1506
1507     // Perform compound assignment and multiplication by a scalar
1508     //
1509     inline Matrix4 & operator *=( float scalar );
1510
1511     // Perform compound assignment and multiplication by a 4x4 matrix
1512     //
1513     inline Matrix4 & operator *=( const Matrix4 & mat );
1514
1515     // Perform compound assignment and multiplication by a 3x4 transformation matrix
1516     //
1517     inline Matrix4 & operator *=( const Transform3 & tfrm );
1518
1519     // Construct an identity 4x4 matrix
1520     //
1521     static inline const Matrix4 identity( );
1522
1523     // Construct a 4x4 matrix to rotate around the x axis
1524     //
1525     static inline const Matrix4 rotationX( float radians );
1526
1527     // Construct a 4x4 matrix to rotate around the y axis
1528     //
1529     static inline const Matrix4 rotationY( float radians );
1530
1531     // Construct a 4x4 matrix to rotate around the z axis
1532     //
1533     static inline const Matrix4 rotationZ( float radians );
1534
1535     // Construct a 4x4 matrix to rotate around the x, y, and z axes
1536     //
1537     static inline const Matrix4 rotationZYX( const Vector3 & radiansXYZ );
1538
1539     // Construct a 4x4 matrix to rotate around a unit-length 3-D vector
1540     //
1541     static inline const Matrix4 rotation( float radians, const Vector3 & unitVec );
1542
1543     // Construct a rotation matrix from a unit-length quaternion
1544     //
1545     static inline const Matrix4 rotation( const Quat & unitQuat );
1546
1547     // Construct a 4x4 matrix to perform scaling
1548     //
1549     static inline const Matrix4 scale( const Vector3 & scaleVec );
1550
1551     // Construct a 4x4 matrix to perform translation
1552     //
1553     static inline const Matrix4 translation( const Vector3 & translateVec );
1554
1555     // Construct viewing matrix based on eye position, position looked at, and up direction
1556     //
1557     static inline const Matrix4 lookAt( const Point3 & eyePos, const Point3 & lookAtPos, const Vector3 & upVec );
1558
1559     // Construct a perspective projection matrix
1560     //
1561     static inline const Matrix4 perspective( float fovyRadians, float aspect, float zNear, float zFar );
1562
1563     // Construct a perspective projection matrix based on frustum
1564     //
1565     static inline const Matrix4 frustum( float left, float right, float bottom, float top, float zNear, float zFar );
1566
1567     // Construct an orthographic projection matrix
1568     //
1569     static inline const Matrix4 orthographic( float left, float right, float bottom, float top, float zNear, float zFar );
1570
1571 };
1572 // Multiply a 4x4 matrix by a scalar
1573 //
1574 inline const Matrix4 operator *( float scalar, const Matrix4 & mat );
1575
1576 // Append (post-multiply) a scale transformation to a 4x4 matrix
1577 // NOTE:
1578 // Faster than creating and multiplying a scale transformation matrix.
1579 //
1580 inline const Matrix4 appendScale( const Matrix4 & mat, const Vector3 & scaleVec );
1581
1582 // Prepend (pre-multiply) a scale transformation to a 4x4 matrix
1583 // NOTE:
1584 // Faster than creating and multiplying a scale transformation matrix.
1585 //
1586 inline const Matrix4 prependScale( const Vector3 & scaleVec, const Matrix4 & mat );
1587
1588 // Multiply two 4x4 matrices per element
1589 //
1590 inline const Matrix4 mulPerElem( const Matrix4 & mat0, const Matrix4 & mat1 );
1591
1592 // Compute the absolute value of a 4x4 matrix per element
1593 //
1594 inline const Matrix4 absPerElem( const Matrix4 & mat );
1595
1596 // Transpose of a 4x4 matrix
1597 //
1598 inline const Matrix4 transpose( const Matrix4 & mat );
1599
1600 // Compute the inverse of a 4x4 matrix
1601 // NOTE:
1602 // Result is unpredictable when the determinant of mat is equal to or near 0.
1603 //
1604 inline const Matrix4 inverse( const Matrix4 & mat );
1605
1606 // Compute the inverse of a 4x4 matrix, which is expected to be an affine matrix
1607 // NOTE:
1608 // This can be used to achieve better performance than a general inverse when the specified 4x4 matrix meets the given restrictions.  The result is unpredictable when the determinant of mat is equal to or near 0.
1609 //
1610 inline const Matrix4 affineInverse( const Matrix4 & mat );
1611
1612 // Compute the inverse of a 4x4 matrix, which is expected to be an affine matrix with an orthogonal upper-left 3x3 submatrix
1613 // NOTE:
1614 // This can be used to achieve better performance than a general inverse when the specified 4x4 matrix meets the given restrictions.
1615 //
1616 inline const Matrix4 orthoInverse( const Matrix4 & mat );
1617
1618 // Determinant of a 4x4 matrix
1619 //
1620 inline float determinant( const Matrix4 & mat );
1621
1622 // Conditionally select between two 4x4 matrices
1623 //
1624 inline const Matrix4 select( const Matrix4 & mat0, const Matrix4 & mat1, bool select1 );
1625
1626 #ifdef _VECTORMATH_DEBUG
1627
1628 // Print a 4x4 matrix
1629 // NOTE:
1630 // Function is only defined when _VECTORMATH_DEBUG is defined.
1631 //
1632 inline void print( const Matrix4 & mat );
1633
1634 // Print a 4x4 matrix and an associated string identifier
1635 // NOTE:
1636 // Function is only defined when _VECTORMATH_DEBUG is defined.
1637 //
1638 inline void print( const Matrix4 & mat, const char * name );
1639
1640 #endif
1641
1642 // A 3x4 transformation matrix in array-of-structures format
1643 //
1644 class Transform3
1645 {
1646     Vector3 mCol0;
1647     Vector3 mCol1;
1648     Vector3 mCol2;
1649     Vector3 mCol3;
1650
1651 public:
1652     // Default constructor; does no initialization
1653     //
1654     inline Transform3( ) { };
1655
1656     // Copy a 3x4 transformation matrix
1657     //
1658     inline Transform3( const Transform3 & tfrm );
1659
1660     // Construct a 3x4 transformation matrix containing the specified columns
1661     //
1662     inline Transform3( const Vector3 & col0, const Vector3 & col1, const Vector3 & col2, const Vector3 & col3 );
1663
1664     // Construct a 3x4 transformation matrix from a 3x3 matrix and a 3-D vector
1665     //
1666     inline Transform3( const Matrix3 & tfrm, const Vector3 & translateVec );
1667
1668     // Construct a 3x4 transformation matrix from a unit-length quaternion and a 3-D vector
1669     //
1670     inline Transform3( const Quat & unitQuat, const Vector3 & translateVec );
1671
1672     // Set all elements of a 3x4 transformation matrix to the same scalar value
1673     //
1674     explicit inline Transform3( float scalar );
1675
1676     // Assign one 3x4 transformation matrix to another
1677     //
1678     inline Transform3 & operator =( const Transform3 & tfrm );
1679
1680     // Set the upper-left 3x3 submatrix
1681     //
1682     inline Transform3 & setUpper3x3( const Matrix3 & mat3 );
1683
1684     // Get the upper-left 3x3 submatrix of a 3x4 transformation matrix
1685     //
1686     inline const Matrix3 getUpper3x3( ) const;
1687
1688     // Set translation component
1689     //
1690     inline Transform3 & setTranslation( const Vector3 & translateVec );
1691
1692     // Get the translation component of a 3x4 transformation matrix
1693     //
1694     inline const Vector3 getTranslation( ) const;
1695
1696     // Set column 0 of a 3x4 transformation matrix
1697     //
1698     inline Transform3 & setCol0( const Vector3 & col0 );
1699
1700     // Set column 1 of a 3x4 transformation matrix
1701     //
1702     inline Transform3 & setCol1( const Vector3 & col1 );
1703
1704     // Set column 2 of a 3x4 transformation matrix
1705     //
1706     inline Transform3 & setCol2( const Vector3 & col2 );
1707
1708     // Set column 3 of a 3x4 transformation matrix
1709     //
1710     inline Transform3 & setCol3( const Vector3 & col3 );
1711
1712     // Get column 0 of a 3x4 transformation matrix
1713     //
1714     inline const Vector3 getCol0( ) const;
1715
1716     // Get column 1 of a 3x4 transformation matrix
1717     //
1718     inline const Vector3 getCol1( ) const;
1719
1720     // Get column 2 of a 3x4 transformation matrix
1721     //
1722     inline const Vector3 getCol2( ) const;
1723
1724     // Get column 3 of a 3x4 transformation matrix
1725     //
1726     inline const Vector3 getCol3( ) const;
1727
1728     // Set the column of a 3x4 transformation matrix referred to by the specified index
1729     //
1730     inline Transform3 & setCol( int col, const Vector3 & vec );
1731
1732     // Set the row of a 3x4 transformation matrix referred to by the specified index
1733     //
1734     inline Transform3 & setRow( int row, const Vector4 & vec );
1735
1736     // Get the column of a 3x4 transformation matrix referred to by the specified index
1737     //
1738     inline const Vector3 getCol( int col ) const;
1739
1740     // Get the row of a 3x4 transformation matrix referred to by the specified index
1741     //
1742     inline const Vector4 getRow( int row ) const;
1743
1744     // Subscripting operator to set or get a column
1745     //
1746     inline Vector3 & operator []( int col );
1747
1748     // Subscripting operator to get a column
1749     //
1750     inline const Vector3 operator []( int col ) const;
1751
1752     // Set the element of a 3x4 transformation matrix referred to by column and row indices
1753     //
1754     inline Transform3 & setElem( int col, int row, float val );
1755
1756     // Get the element of a 3x4 transformation matrix referred to by column and row indices
1757     //
1758     inline float getElem( int col, int row ) const;
1759
1760     // Multiply a 3x4 transformation matrix by a 3-D vector
1761     //
1762     inline const Vector3 operator *( const Vector3 & vec ) const;
1763
1764     // Multiply a 3x4 transformation matrix by a 3-D point
1765     //
1766     inline const Point3 operator *( const Point3 & pnt ) const;
1767
1768     // Multiply two 3x4 transformation matrices
1769     //
1770     inline const Transform3 operator *( const Transform3 & tfrm ) const;
1771
1772     // Perform compound assignment and multiplication by a 3x4 transformation matrix
1773     //
1774     inline Transform3 & operator *=( const Transform3 & tfrm );
1775
1776     // Construct an identity 3x4 transformation matrix
1777     //
1778     static inline const Transform3 identity( );
1779
1780     // Construct a 3x4 transformation matrix to rotate around the x axis
1781     //
1782     static inline const Transform3 rotationX( float radians );
1783
1784     // Construct a 3x4 transformation matrix to rotate around the y axis
1785     //
1786     static inline const Transform3 rotationY( float radians );
1787
1788     // Construct a 3x4 transformation matrix to rotate around the z axis
1789     //
1790     static inline const Transform3 rotationZ( float radians );
1791
1792     // Construct a 3x4 transformation matrix to rotate around the x, y, and z axes
1793     //
1794     static inline const Transform3 rotationZYX( const Vector3 & radiansXYZ );
1795
1796     // Construct a 3x4 transformation matrix to rotate around a unit-length 3-D vector
1797     //
1798     static inline const Transform3 rotation( float radians, const Vector3 & unitVec );
1799
1800     // Construct a rotation matrix from a unit-length quaternion
1801     //
1802     static inline const Transform3 rotation( const Quat & unitQuat );
1803
1804     // Construct a 3x4 transformation matrix to perform scaling
1805     //
1806     static inline const Transform3 scale( const Vector3 & scaleVec );
1807
1808     // Construct a 3x4 transformation matrix to perform translation
1809     //
1810     static inline const Transform3 translation( const Vector3 & translateVec );
1811
1812 };
1813 // Append (post-multiply) a scale transformation to a 3x4 transformation matrix
1814 // NOTE:
1815 // Faster than creating and multiplying a scale transformation matrix.
1816 //
1817 inline const Transform3 appendScale( const Transform3 & tfrm, const Vector3 & scaleVec );
1818
1819 // Prepend (pre-multiply) a scale transformation to a 3x4 transformation matrix
1820 // NOTE:
1821 // Faster than creating and multiplying a scale transformation matrix.
1822 //
1823 inline const Transform3 prependScale( const Vector3 & scaleVec, const Transform3 & tfrm );
1824
1825 // Multiply two 3x4 transformation matrices per element
1826 //
1827 inline const Transform3 mulPerElem( const Transform3 & tfrm0, const Transform3 & tfrm1 );
1828
1829 // Compute the absolute value of a 3x4 transformation matrix per element
1830 //
1831 inline const Transform3 absPerElem( const Transform3 & tfrm );
1832
1833 // Inverse of a 3x4 transformation matrix
1834 // NOTE:
1835 // Result is unpredictable when the determinant of the left 3x3 submatrix is equal to or near 0.
1836 //
1837 inline const Transform3 inverse( const Transform3 & tfrm );
1838
1839 // Compute the inverse of a 3x4 transformation matrix, expected to have an orthogonal upper-left 3x3 submatrix
1840 // NOTE:
1841 // This can be used to achieve better performance than a general inverse when the specified 3x4 transformation matrix meets the given restrictions.
1842 //
1843 inline const Transform3 orthoInverse( const Transform3 & tfrm );
1844
1845 // Conditionally select between two 3x4 transformation matrices
1846 //
1847 inline const Transform3 select( const Transform3 & tfrm0, const Transform3 & tfrm1, bool select1 );
1848
1849 #ifdef _VECTORMATH_DEBUG
1850
1851 // Print a 3x4 transformation matrix
1852 // NOTE:
1853 // Function is only defined when _VECTORMATH_DEBUG is defined.
1854 //
1855 inline void print( const Transform3 & tfrm );
1856
1857 // Print a 3x4 transformation matrix and an associated string identifier
1858 // NOTE:
1859 // Function is only defined when _VECTORMATH_DEBUG is defined.
1860 //
1861 inline void print( const Transform3 & tfrm, const char * name );
1862
1863 #endif
1864
1865 } // namespace Aos
1866 } // namespace Vectormath
1867
1868 #include "vec_aos.h"
1869 #include "quat_aos.h"
1870 #include "mat_aos.h"
1871
1872 #endif