1 /*!**************************************************************************** 2 3 @file PVRTMatrix.h 4 @copyright Copyright (c) Imagination Technologies Limited. 5 @brief Vector and Matrix functions for floating and fixed point math. 6 @details The general matrix format used is directly compatible with, for 7 example, both DirectX and OpenGL. 8 9 ******************************************************************************/ 10 #ifndef _PVRTMATRIX_H_ 11 #define _PVRTMATRIX_H_ 12 13 #include "PVRTGlobal.h" 14 /**************************************************************************** 15 ** Defines 16 ****************************************************************************/ 17 #define MAT00 0 18 #define MAT01 1 19 #define MAT02 2 20 #define MAT03 3 21 #define MAT10 4 22 #define MAT11 5 23 #define MAT12 6 24 #define MAT13 7 25 #define MAT20 8 26 #define MAT21 9 27 #define MAT22 10 28 #define MAT23 11 29 #define MAT30 12 30 #define MAT31 13 31 #define MAT32 14 32 #define MAT33 15 33 34 /**************************************************************************** 35 ** Typedefs 36 ****************************************************************************/ 37 /*!*************************************************************************** 38 @brief 2D floating point vector 39 *****************************************************************************/ 40 typedef struct 41 { 42 float x; /*!< x coordinate */ 43 float y; /*!< y coordinate */ 44 } PVRTVECTOR2f; 45 46 /*!*************************************************************************** 47 @brief 2D fixed point vector 48 *****************************************************************************/ 49 typedef struct 50 { 51 int x; /*!< x coordinate */ 52 int y; /*!< y coordinate */ 53 } PVRTVECTOR2x; 54 55 /*!*************************************************************************** 56 @brief 3D floating point vector 57 *****************************************************************************/ 58 typedef struct 59 { 60 float x; /*!< x coordinate */ 61 float y; /*!< y coordinate */ 62 float z; /*!< z coordinate */ 63 } PVRTVECTOR3f; 64 65 /*!*************************************************************************** 66 @brief 3D fixed point vector 67 *****************************************************************************/ 68 typedef struct 69 { 70 int x; /*!< x coordinate */ 71 int y; /*!< y coordinate */ 72 int z; /*!< z coordinate */ 73 } PVRTVECTOR3x; 74 75 /*!*************************************************************************** 76 @brief 4D floating point vector 77 *****************************************************************************/ 78 typedef struct 79 { 80 float x; /*!< x coordinate */ 81 float y; /*!< y coordinate */ 82 float z; /*!< z coordinate */ 83 float w; /*!< w coordinate */ 84 } PVRTVECTOR4f; 85 86 /*!*************************************************************************** 87 @brief 4D fixed point vector 88 *****************************************************************************/ 89 typedef struct 90 { 91 int x; /*!< x coordinate */ 92 int y; /*!< y coordinate */ 93 int z; /*!< z coordinate */ 94 int w; /*!< w coordinate */ 95 } PVRTVECTOR4x; 96 97 /*!*************************************************************************** 98 @class PVRTMATRIXf 99 @brief 4x4 floating point matrix 100 *****************************************************************************/ 101 class PVRTMATRIXf 102 { 103 public: 104 float* operator [] ( const int Row ) 105 { 106 return &f[Row<<2]; 107 } 108 float f[16]; /*!< Array of float */ 109 }; 110 111 /*!*************************************************************************** 112 @class PVRTMATRIXx 113 @brief 4x4 fixed point matrix 114 *****************************************************************************/ 115 class PVRTMATRIXx 116 { 117 public: 118 int* operator [] ( const int Row ) 119 { 120 return &f[Row<<2]; 121 } 122 int f[16]; 123 }; 124 125 /*!*************************************************************************** 126 @class PVRTMATRIX3f 127 @brief 3x3 floating point matrix 128 *****************************************************************************/ 129 130 class PVRTMATRIX3f 131 { 132 public: 133 float* operator [] ( const int Row ) 134 { 135 return &f[Row*3]; 136 } 137 float f[9]; /*!< Array of float */ 138 }; 139 140 /*!*************************************************************************** 141 @class PVRTMATRIX3x 142 @brief 3x3 fixed point matrix 143 *****************************************************************************/ 144 class PVRTMATRIX3x 145 { 146 public: 147 int* operator [] ( const int Row ) 148 { 149 return &f[Row*3]; 150 } 151 int f[9]; 152 }; 153 154 155 /**************************************************************************** 156 ** Float or fixed 157 ****************************************************************************/ 158 #ifdef PVRT_FIXED_POINT_ENABLE 159 typedef PVRTVECTOR2x PVRTVECTOR2; 160 typedef PVRTVECTOR3x PVRTVECTOR3; 161 typedef PVRTVECTOR4x PVRTVECTOR4; 162 typedef PVRTMATRIX3x PVRTMATRIX3; 163 typedef PVRTMATRIXx PVRTMATRIX; 164 #define PVRTMatrixIdentity PVRTMatrixIdentityX 165 #define PVRTMatrixMultiply PVRTMatrixMultiplyX 166 #define PVRTMatrixTranslation PVRTMatrixTranslationX 167 #define PVRTMatrixScaling PVRTMatrixScalingX 168 #define PVRTMatrixRotationX PVRTMatrixRotationXX 169 #define PVRTMatrixRotationY PVRTMatrixRotationYX 170 #define PVRTMatrixRotationZ PVRTMatrixRotationZX 171 #define PVRTMatrixTranspose PVRTMatrixTransposeX 172 #define PVRTMatrixInverse PVRTMatrixInverseX 173 #define PVRTMatrixInverseEx PVRTMatrixInverseExX 174 #define PVRTMatrixLookAtLH PVRTMatrixLookAtLHX 175 #define PVRTMatrixLookAtRH PVRTMatrixLookAtRHX 176 #define PVRTMatrixPerspectiveFovLH PVRTMatrixPerspectiveFovLHX 177 #define PVRTMatrixPerspectiveFovRH PVRTMatrixPerspectiveFovRHX 178 #define PVRTMatrixOrthoLH PVRTMatrixOrthoLHX 179 #define PVRTMatrixOrthoRH PVRTMatrixOrthoRHX 180 #define PVRTMatrixVec3Lerp PVRTMatrixVec3LerpX 181 #define PVRTMatrixVec3DotProduct PVRTMatrixVec3DotProductX 182 #define PVRTMatrixVec3CrossProduct PVRTMatrixVec3CrossProductX 183 #define PVRTMatrixVec3Normalize PVRTMatrixVec3NormalizeX 184 #define PVRTMatrixVec3Length PVRTMatrixVec3LengthX 185 #define PVRTMatrixLinearEqSolve PVRTMatrixLinearEqSolveX 186 #else 187 typedef PVRTVECTOR2f PVRTVECTOR2; 188 typedef PVRTVECTOR3f PVRTVECTOR3; 189 typedef PVRTVECTOR4f PVRTVECTOR4; 190 typedef PVRTMATRIX3f PVRTMATRIX3; 191 typedef PVRTMATRIXf PVRTMATRIX; 192 #define PVRTMatrixIdentity PVRTMatrixIdentityF 193 #define PVRTMatrixMultiply PVRTMatrixMultiplyF 194 #define PVRTMatrixTranslation PVRTMatrixTranslationF 195 #define PVRTMatrixScaling PVRTMatrixScalingF 196 #define PVRTMatrixRotationX PVRTMatrixRotationXF 197 #define PVRTMatrixRotationY PVRTMatrixRotationYF 198 #define PVRTMatrixRotationZ PVRTMatrixRotationZF 199 #define PVRTMatrixTranspose PVRTMatrixTransposeF 200 #define PVRTMatrixInverse PVRTMatrixInverseF 201 #define PVRTMatrixInverseEx PVRTMatrixInverseExF 202 #define PVRTMatrixLookAtLH PVRTMatrixLookAtLHF 203 #define PVRTMatrixLookAtRH PVRTMatrixLookAtRHF 204 #define PVRTMatrixPerspectiveFovLH PVRTMatrixPerspectiveFovLHF 205 #define PVRTMatrixPerspectiveFovRH PVRTMatrixPerspectiveFovRHF 206 #define PVRTMatrixOrthoLH PVRTMatrixOrthoLHF 207 #define PVRTMatrixOrthoRH PVRTMatrixOrthoRHF 208 #define PVRTMatrixVec3Lerp PVRTMatrixVec3LerpF 209 #define PVRTMatrixVec3DotProduct PVRTMatrixVec3DotProductF 210 #define PVRTMatrixVec3CrossProduct PVRTMatrixVec3CrossProductF 211 #define PVRTMatrixVec3Normalize PVRTMatrixVec3NormalizeF 212 #define PVRTMatrixVec3Length PVRTMatrixVec3LengthF 213 #define PVRTMatrixLinearEqSolve PVRTMatrixLinearEqSolveF 214 #endif 215 216 /**************************************************************************** 217 ** Functions 218 ****************************************************************************/ 219 220 /*!*************************************************************************** 221 @fn PVRTMatrixIdentityF 222 @param[out] mOut Set to identity 223 @brief Reset matrix to identity matrix. 224 *****************************************************************************/ 225 void PVRTMatrixIdentityF(PVRTMATRIXf &mOut); 226 227 /*!*************************************************************************** 228 @fn PVRTMatrixIdentityX 229 @param[out] mOut Set to identity 230 @brief Reset matrix to identity matrix. 231 *****************************************************************************/ 232 void PVRTMatrixIdentityX(PVRTMATRIXx &mOut); 233 234 /*!*************************************************************************** 235 @fn PVRTMatrixMultiplyF 236 @param[out] mOut Result of mA x mB 237 @param[in] mA First operand 238 @param[in] mB Second operand 239 @brief Multiply mA by mB and assign the result to mOut 240 (mOut = p1 * p2). A copy of the result matrix is done in 241 the function because mOut can be a parameter mA or mB. 242 *****************************************************************************/ 243 void PVRTMatrixMultiplyF( 244 PVRTMATRIXf &mOut, 245 const PVRTMATRIXf &mA, 246 const PVRTMATRIXf &mB); 247 /*!*************************************************************************** 248 @fn PVRTMatrixMultiplyX 249 @param[out] mOut Result of mA x mB 250 @param[in] mA First operand 251 @param[in] mB Second operand 252 @brief Multiply mA by mB and assign the result to mOut 253 (mOut = p1 * p2). A copy of the result matrix is done in 254 the function because mOut can be a parameter mA or mB. 255 The fixed-point shift could be performed after adding 256 all four intermediate results together however this might 257 cause some overflow issues. 258 *****************************************************************************/ 259 void PVRTMatrixMultiplyX( 260 PVRTMATRIXx &mOut, 261 const PVRTMATRIXx &mA, 262 const PVRTMATRIXx &mB); 263 264 /*!*************************************************************************** 265 @fn PVRTMatrixTranslationF 266 @param[out] mOut Translation matrix 267 @param[in] fX X component of the translation 268 @param[in] fY Y component of the translation 269 @param[in] fZ Z component of the translation 270 @brief Build a transaltion matrix mOut using fX, fY and fZ. 271 *****************************************************************************/ 272 void PVRTMatrixTranslationF( 273 PVRTMATRIXf &mOut, 274 const float fX, 275 const float fY, 276 const float fZ); 277 /*!*************************************************************************** 278 @fn PVRTMatrixTranslationX 279 @param[out] mOut Translation matrix 280 @param[in] fX X component of the translation 281 @param[in] fY Y component of the translation 282 @param[in] fZ Z component of the translation 283 @brief Build a transaltion matrix mOut using fX, fY and fZ. 284 *****************************************************************************/ 285 void PVRTMatrixTranslationX( 286 PVRTMATRIXx &mOut, 287 const int fX, 288 const int fY, 289 const int fZ); 290 291 /*!*************************************************************************** 292 @fn PVRTMatrixScalingF 293 @param[out] mOut Scale matrix 294 @param[in] fX X component of the scaling 295 @param[in] fY Y component of the scaling 296 @param[in] fZ Z component of the scaling 297 @brief Build a scale matrix mOut using fX, fY and fZ. 298 *****************************************************************************/ 299 void PVRTMatrixScalingF( 300 PVRTMATRIXf &mOut, 301 const float fX, 302 const float fY, 303 const float fZ); 304 305 /*!*************************************************************************** 306 @fn PVRTMatrixScalingX 307 @param[out] mOut Scale matrix 308 @param[in] fX X component of the scaling 309 @param[in] fY Y component of the scaling 310 @param[in] fZ Z component of the scaling 311 @brief Build a scale matrix mOut using fX, fY and fZ. 312 *****************************************************************************/ 313 void PVRTMatrixScalingX( 314 PVRTMATRIXx &mOut, 315 const int fX, 316 const int fY, 317 const int fZ); 318 319 /*!*************************************************************************** 320 @fn PVRTMatrixRotationXF 321 @param[out] mOut Rotation matrix 322 @param[in] fAngle Angle of the rotation 323 @brief Create an X rotation matrix mOut. 324 *****************************************************************************/ 325 void PVRTMatrixRotationXF( 326 PVRTMATRIXf &mOut, 327 const float fAngle); 328 329 /*!*************************************************************************** 330 @fn PVRTMatrixRotationXX 331 @param[out] mOut Rotation matrix 332 @param[in] fAngle Angle of the rotation 333 @brief Create an X rotation matrix mOut. 334 *****************************************************************************/ 335 void PVRTMatrixRotationXX( 336 PVRTMATRIXx &mOut, 337 const int fAngle); 338 339 /*!*************************************************************************** 340 @fn PVRTMatrixRotationYF 341 @param[out] mOut Rotation matrix 342 @param[in] fAngle Angle of the rotation 343 @brief Create an Y rotation matrix mOut. 344 *****************************************************************************/ 345 void PVRTMatrixRotationYF( 346 PVRTMATRIXf &mOut, 347 const float fAngle); 348 349 /*!*************************************************************************** 350 @fn PVRTMatrixRotationYX 351 @param[out] mOut Rotation matrix 352 @param[in] fAngle Angle of the rotation 353 @brief Create an Y rotation matrix mOut. 354 *****************************************************************************/ 355 void PVRTMatrixRotationYX( 356 PVRTMATRIXx &mOut, 357 const int fAngle); 358 359 /*!*************************************************************************** 360 @fn PVRTMatrixRotationZF 361 @param[out] mOut Rotation matrix 362 @param[in] fAngle Angle of the rotation 363 @brief Create an Z rotation matrix mOut. 364 *****************************************************************************/ 365 void PVRTMatrixRotationZF( 366 PVRTMATRIXf &mOut, 367 const float fAngle); 368 /*!*************************************************************************** 369 @fn PVRTMatrixRotationZX 370 @param[out] mOut Rotation matrix 371 @param[in] fAngle Angle of the rotation 372 @brief Create an Z rotation matrix mOut. 373 *****************************************************************************/ 374 void PVRTMatrixRotationZX( 375 PVRTMATRIXx &mOut, 376 const int fAngle); 377 378 /*!*************************************************************************** 379 @fn PVRTMatrixTransposeF 380 @param[out] mOut Transposed matrix 381 @param[in] mIn Original matrix 382 @brief Compute the transpose matrix of mIn. 383 *****************************************************************************/ 384 void PVRTMatrixTransposeF( 385 PVRTMATRIXf &mOut, 386 const PVRTMATRIXf &mIn); 387 /*!*************************************************************************** 388 @fn PVRTMatrixTransposeX 389 @param[out] mOut Transposed matrix 390 @param[in] mIn Original matrix 391 @brief Compute the transpose matrix of mIn. 392 *****************************************************************************/ 393 void PVRTMatrixTransposeX( 394 PVRTMATRIXx &mOut, 395 const PVRTMATRIXx &mIn); 396 397 /*!*************************************************************************** 398 @fn PVRTMatrixInverseF 399 @param[out] mOut Inversed matrix 400 @param[in] mIn Original matrix 401 @brief Compute the inverse matrix of mIn. 402 The matrix must be of the form : 403 A 0 404 C 1 405 Where A is a 3x3 matrix and C is a 1x3 matrix. 406 *****************************************************************************/ 407 void PVRTMatrixInverseF( 408 PVRTMATRIXf &mOut, 409 const PVRTMATRIXf &mIn); 410 /*!*************************************************************************** 411 @fn PVRTMatrixInverseX 412 @param[out] mOut Inversed matrix 413 @param[in] mIn Original matrix 414 @brief Compute the inverse matrix of mIn. 415 The matrix must be of the form : 416 A 0 417 C 1 418 Where A is a 3x3 matrix and C is a 1x3 matrix. 419 *****************************************************************************/ 420 void PVRTMatrixInverseX( 421 PVRTMATRIXx &mOut, 422 const PVRTMATRIXx &mIn); 423 424 /*!*************************************************************************** 425 @fn PVRTMatrixInverseExF 426 @param[out] mOut Inversed matrix 427 @param[in] mIn Original matrix 428 @brief Compute the inverse matrix of mIn. 429 Uses a linear equation solver and the knowledge that M.M^-1=I. 430 Use this fn to calculate the inverse of matrices that 431 PVRTMatrixInverse() cannot. 432 *****************************************************************************/ 433 void PVRTMatrixInverseExF( 434 PVRTMATRIXf &mOut, 435 const PVRTMATRIXf &mIn); 436 /*!*************************************************************************** 437 @fn PVRTMatrixInverseExX 438 @param[out] mOut Inversed matrix 439 @param[in] mIn Original matrix 440 @brief Compute the inverse matrix of mIn. 441 Uses a linear equation solver and the knowledge that M.M^-1=I. 442 Use this fn to calculate the inverse of matrices that 443 PVRTMatrixInverse() cannot. 444 *****************************************************************************/ 445 void PVRTMatrixInverseExX( 446 PVRTMATRIXx &mOut, 447 const PVRTMATRIXx &mIn); 448 449 /*!*************************************************************************** 450 @fn PVRTMatrixLookAtLHF 451 @param[out] mOut Look-at view matrix 452 @param[in] vEye Position of the camera 453 @param[in] vAt Point the camera is looking at 454 @param[in] vUp Up direction for the camera 455 @brief Create a look-at view matrix. 456 *****************************************************************************/ 457 void PVRTMatrixLookAtLHF( 458 PVRTMATRIXf &mOut, 459 const PVRTVECTOR3f &vEye, 460 const PVRTVECTOR3f &vAt, 461 const PVRTVECTOR3f &vUp); 462 /*!*************************************************************************** 463 @fn PVRTMatrixLookAtLHX 464 @param[out] mOut Look-at view matrix 465 @param[in] vEye Position of the camera 466 @param[in] vAt Point the camera is looking at 467 @param[in] vUp Up direction for the camera 468 @brief Create a look-at view matrix. 469 *****************************************************************************/ 470 void PVRTMatrixLookAtLHX( 471 PVRTMATRIXx &mOut, 472 const PVRTVECTOR3x &vEye, 473 const PVRTVECTOR3x &vAt, 474 const PVRTVECTOR3x &vUp); 475 476 /*!*************************************************************************** 477 @fn PVRTMatrixLookAtRHF 478 @param[out] mOut Look-at view matrix 479 @param[in] vEye Position of the camera 480 @param[in] vAt Point the camera is looking at 481 @param[in] vUp Up direction for the camera 482 @brief Create a look-at view matrix. 483 *****************************************************************************/ 484 void PVRTMatrixLookAtRHF( 485 PVRTMATRIXf &mOut, 486 const PVRTVECTOR3f &vEye, 487 const PVRTVECTOR3f &vAt, 488 const PVRTVECTOR3f &vUp); 489 /*!*************************************************************************** 490 @fn PVRTMatrixLookAtRHX 491 @param[out] mOut Look-at view matrix 492 @param[in] vEye Position of the camera 493 @param[in] vAt Point the camera is looking at 494 @param[in] vUp Up direction for the camera 495 @brief Create a look-at view matrix. 496 *****************************************************************************/ 497 void PVRTMatrixLookAtRHX( 498 PVRTMATRIXx &mOut, 499 const PVRTVECTOR3x &vEye, 500 const PVRTVECTOR3x &vAt, 501 const PVRTVECTOR3x &vUp); 502 503 /*!*************************************************************************** 504 @fn PVRTMatrixPerspectiveFovLHF 505 @param[out] mOut Perspective matrix 506 @param[in] fFOVy Field of view 507 @param[in] fAspect Aspect ratio 508 @param[in] fNear Near clipping distance 509 @param[in] fFar Far clipping distance 510 @param[in] bRotate Should we rotate it ? (for upright screens) 511 @brief Create a perspective matrix. 512 *****************************************************************************/ 513 void PVRTMatrixPerspectiveFovLHF( 514 PVRTMATRIXf &mOut, 515 const float fFOVy, 516 const float fAspect, 517 const float fNear, 518 const float fFar, 519 const bool bRotate = false); 520 /*!*************************************************************************** 521 @fn PVRTMatrixPerspectiveFovLHX 522 @param[out] mOut Perspective matrix 523 @param[in] fFOVy Field of view 524 @param[in] fAspect Aspect ratio 525 @param[in] fNear Near clipping distance 526 @param[in] fFar Far clipping distance 527 @param[in] bRotate Should we rotate it ? (for upright screens) 528 @brief Create a perspective matrix. 529 *****************************************************************************/ 530 void PVRTMatrixPerspectiveFovLHX( 531 PVRTMATRIXx &mOut, 532 const int fFOVy, 533 const int fAspect, 534 const int fNear, 535 const int fFar, 536 const bool bRotate = false); 537 538 /*!*************************************************************************** 539 @fn PVRTMatrixPerspectiveFovRHF 540 @param[out] mOut Perspective matrix 541 @param[in] fFOVy Field of view 542 @param[in] fAspect Aspect ratio 543 @param[in] fNear Near clipping distance 544 @param[in] fFar Far clipping distance 545 @param[in] bRotate Should we rotate it ? (for upright screens) 546 @brief Create a perspective matrix. 547 *****************************************************************************/ 548 void PVRTMatrixPerspectiveFovRHF( 549 PVRTMATRIXf &mOut, 550 const float fFOVy, 551 const float fAspect, 552 const float fNear, 553 const float fFar, 554 const bool bRotate = false); 555 /*!*************************************************************************** 556 @fn PVRTMatrixPerspectiveFovRHX 557 @param[out] mOut Perspective matrix 558 @param[in] fFOVy Field of view 559 @param[in] fAspect Aspect ratio 560 @param[in] fNear Near clipping distance 561 @param[in] fFar Far clipping distance 562 @param[in] bRotate Should we rotate it ? (for upright screens) 563 @brief Create a perspective matrix. 564 *****************************************************************************/ 565 void PVRTMatrixPerspectiveFovRHX( 566 PVRTMATRIXx &mOut, 567 const int fFOVy, 568 const int fAspect, 569 const int fNear, 570 const int fFar, 571 const bool bRotate = false); 572 573 /*!*************************************************************************** 574 @fn PVRTMatrixOrthoLHF 575 @param[out] mOut Orthographic matrix 576 @param[in] w Width of the screen 577 @param[in] h Height of the screen 578 @param[in] zn Near clipping distance 579 @param[in] zf Far clipping distance 580 @param[in] bRotate Should we rotate it ? (for upright screens) 581 @brief Create an orthographic matrix. 582 *****************************************************************************/ 583 void PVRTMatrixOrthoLHF( 584 PVRTMATRIXf &mOut, 585 const float w, 586 const float h, 587 const float zn, 588 const float zf, 589 const bool bRotate = false); 590 /*!*************************************************************************** 591 @fn PVRTMatrixOrthoLHX 592 @param[out] mOut Orthographic matrix 593 @param[in] w Width of the screen 594 @param[in] h Height of the screen 595 @param[in] zn Near clipping distance 596 @param[in] zf Far clipping distance 597 @param[in] bRotate Should we rotate it ? (for upright screens) 598 @brief Create an orthographic matrix. 599 *****************************************************************************/ 600 void PVRTMatrixOrthoLHX( 601 PVRTMATRIXx &mOut, 602 const int w, 603 const int h, 604 const int zn, 605 const int zf, 606 const bool bRotate = false); 607 608 /*!*************************************************************************** 609 @fn PVRTMatrixOrthoRHF 610 @param[out] mOut Orthographic matrix 611 @param[in] w Width of the screen 612 @param[in] h Height of the screen 613 @param[in] zn Near clipping distance 614 @param[in] zf Far clipping distance 615 @param[in] bRotate Should we rotate it ? (for upright screens) 616 @brief Create an orthographic matrix. 617 *****************************************************************************/ 618 void PVRTMatrixOrthoRHF( 619 PVRTMATRIXf &mOut, 620 const float w, 621 const float h, 622 const float zn, 623 const float zf, 624 const bool bRotate = false); 625 /*!*************************************************************************** 626 @fn PVRTMatrixOrthoRHX 627 @param[out] mOut Orthographic matrix 628 @param[in] w Width of the screen 629 @param[in] h Height of the screen 630 @param[in] zn Near clipping distance 631 @param[in] zf Far clipping distance 632 @param[in] bRotate Should we rotate it ? (for upright screens) 633 @brief Create an orthographic matrix. 634 *****************************************************************************/ 635 void PVRTMatrixOrthoRHX( 636 PVRTMATRIXx &mOut, 637 const int w, 638 const int h, 639 const int zn, 640 const int zf, 641 const bool bRotate = false); 642 643 /*!*************************************************************************** 644 @fn PVRTMatrixVec3LerpF 645 @param[out] vOut Result of the interpolation 646 @param[in] v1 First vector to interpolate from 647 @param[in] v2 Second vector to interpolate form 648 @param[in] s Coefficient of interpolation 649 @brief This function performs the linear interpolation based on 650 the following formula: V1 + s(V2-V1). 651 *****************************************************************************/ 652 void PVRTMatrixVec3LerpF( 653 PVRTVECTOR3f &vOut, 654 const PVRTVECTOR3f &v1, 655 const PVRTVECTOR3f &v2, 656 const float s); 657 /*!*************************************************************************** 658 @fn PVRTMatrixVec3LerpX 659 @param[out] vOut Result of the interpolation 660 @param[in] v1 First vector to interpolate from 661 @param[in] v2 Second vector to interpolate form 662 @param[in] s Coefficient of interpolation 663 @brief This function performs the linear interpolation based on 664 the following formula: V1 + s(V2-V1). 665 *****************************************************************************/ 666 void PVRTMatrixVec3LerpX( 667 PVRTVECTOR3x &vOut, 668 const PVRTVECTOR3x &v1, 669 const PVRTVECTOR3x &v2, 670 const int s); 671 672 /*!*************************************************************************** 673 @fn PVRTMatrixVec3DotProductF 674 @param[in] v1 First vector 675 @param[in] v2 Second vector 676 @return Dot product of the two vectors. 677 @brief This function performs the dot product of the two 678 supplied vectors. 679 *****************************************************************************/ 680 float PVRTMatrixVec3DotProductF( 681 const PVRTVECTOR3f &v1, 682 const PVRTVECTOR3f &v2); 683 /*!*************************************************************************** 684 @fn PVRTMatrixVec3DotProductX 685 @param[in] v1 First vector 686 @param[in] v2 Second vector 687 @return Dot product of the two vectors. 688 @brief This function performs the dot product of the two 689 supplied vectors. 690 A single >> 16 shift could be applied to the final accumulated 691 result however this runs the risk of overflow between the 692 results of the intermediate additions. 693 *****************************************************************************/ 694 int PVRTMatrixVec3DotProductX( 695 const PVRTVECTOR3x &v1, 696 const PVRTVECTOR3x &v2); 697 698 /*!*************************************************************************** 699 @fn PVRTMatrixVec3CrossProductF 700 @param[out] vOut Cross product of the two vectors 701 @param[in] v1 First vector 702 @param[in] v2 Second vector 703 @brief This function performs the cross product of the two 704 supplied vectors. 705 *****************************************************************************/ 706 void PVRTMatrixVec3CrossProductF( 707 PVRTVECTOR3f &vOut, 708 const PVRTVECTOR3f &v1, 709 const PVRTVECTOR3f &v2); 710 /*!*************************************************************************** 711 @fn PVRTMatrixVec3CrossProductX 712 @param[out] vOut Cross product of the two vectors 713 @param[in] v1 First vector 714 @param[in] v2 Second vector 715 @brief This function performs the cross product of the two 716 supplied vectors. 717 *****************************************************************************/ 718 void PVRTMatrixVec3CrossProductX( 719 PVRTVECTOR3x &vOut, 720 const PVRTVECTOR3x &v1, 721 const PVRTVECTOR3x &v2); 722 723 /*!*************************************************************************** 724 @fn PVRTMatrixVec3NormalizeF 725 @param[out] vOut Normalized vector 726 @param[in] vIn Vector to normalize 727 @brief Normalizes the supplied vector. 728 *****************************************************************************/ 729 void PVRTMatrixVec3NormalizeF( 730 PVRTVECTOR3f &vOut, 731 const PVRTVECTOR3f &vIn); 732 /*!*************************************************************************** 733 @fn PVRTMatrixVec3NormalizeX 734 @param[out] vOut Normalized vector 735 @param[in] vIn Vector to normalize 736 @brief Normalizes the supplied vector. 737 The square root function is currently still performed 738 in floating-point. 739 Original vector is scaled down prior to be normalized in 740 order to avoid overflow issues. 741 *****************************************************************************/ 742 void PVRTMatrixVec3NormalizeX( 743 PVRTVECTOR3x &vOut, 744 const PVRTVECTOR3x &vIn); 745 /*!*************************************************************************** 746 @fn PVRTMatrixVec3LengthF 747 @param[in] vIn Vector to get the length of 748 @return The length of the vector 749 @brief Gets the length of the supplied vector. 750 *****************************************************************************/ 751 float PVRTMatrixVec3LengthF( 752 const PVRTVECTOR3f &vIn); 753 /*!*************************************************************************** 754 @fn PVRTMatrixVec3LengthX 755 @param[in] vIn Vector to get the length of 756 @return The length of the vector 757 @brief Gets the length of the supplied vector 758 *****************************************************************************/ 759 int PVRTMatrixVec3LengthX( 760 const PVRTVECTOR3x &vIn); 761 /*!*************************************************************************** 762 @fn PVRTMatrixLinearEqSolveF 763 @param[in] pSrc 2D array of floats. 4 Eq linear problem is 5x4 764 matrix, constants in first column 765 @param[in] nCnt Number of equations to solve 766 @param[out] pRes Result 767 @brief Solves 'nCnt' simultaneous equations of 'nCnt' variables. 768 pRes should be an array large enough to contain the 769 results: the values of the 'nCnt' variables. 770 This fn recursively uses Gaussian Elimination. 771 *****************************************************************************/ 772 773 void PVRTMatrixLinearEqSolveF( 774 float * const pRes, 775 float ** const pSrc, 776 const int nCnt); 777 /*!*************************************************************************** 778 @fn PVRTMatrixLinearEqSolveX 779 @param[in] pSrc 2D array of floats. 4 Eq linear problem is 5x4 780 matrix, constants in first column 781 @param[in] nCnt Number of equations to solve 782 @param[out] pRes Result 783 @brief Solves 'nCnt' simultaneous equations of 'nCnt' variables. 784 pRes should be an array large enough to contain the 785 results: the values of the 'nCnt' variables. 786 This fn recursively uses Gaussian Elimination. 787 *****************************************************************************/ 788 void PVRTMatrixLinearEqSolveX( 789 int * const pRes, 790 int ** const pSrc, 791 const int nCnt); 792 793 #endif 794 795 /***************************************************************************** 796 End of file (PVRTMatrix.h) 797 *****************************************************************************/ 798 799