 |
+
+
+
+ Irrlicht 3D Engine
+
+
+
+ |
+
+
+
+
+
+
+
+
+
+
+ 
+
+ |
+
+
+
00001 // Copyright (C) 2002-2012 Nikolaus Gebhardt +00002 // This file is part of the "Irrlicht Engine". +00003 // For conditions of distribution and use, see copyright notice in irrlicht.h +00004 +00005 #ifndef __IRR_MATRIX_H_INCLUDED__ +00006 #define __IRR_MATRIX_H_INCLUDED__ +00007 +00008 #include "irrMath.h" +00009 #include "vector3d.h" +00010 #include "vector2d.h" +00011 #include "plane3d.h" +00012 #include "aabbox3d.h" +00013 #include "rect.h" +00014 #include "irrString.h" +00015 +00016 // enable this to keep track of changes to the matrix +00017 // and make simpler identity check for seldomly changing matrices +00018 // otherwise identity check will always compare the elements +00019 //#define USE_MATRIX_TEST +00020 +00021 // this is only for debugging purposes +00022 //#define USE_MATRIX_TEST_DEBUG +00023 +00024 #if defined( USE_MATRIX_TEST_DEBUG ) +00025 +00026 struct MatrixTest +00027 { +00028 MatrixTest () : ID(0), Calls(0) {} +00029 char buf[256]; +00030 int Calls; +00031 int ID; +00032 }; +00033 static MatrixTest MTest; +00034 +00035 #endif +00036 +00037 namespace irr +00038 { +00039 namespace core +00040 { +00041 +00043 +00044 template <class T> +00045 class CMatrix4 +00046 { +00047 public: +00048 +00050 enum eConstructor +00051 { +00052 EM4CONST_NOTHING = 0, +00053 EM4CONST_COPY, +00054 EM4CONST_IDENTITY, +00055 EM4CONST_TRANSPOSED, +00056 EM4CONST_INVERSE, +00057 EM4CONST_INVERSE_TRANSPOSED +00058 }; +00059 +00061 +00062 CMatrix4( eConstructor constructor = EM4CONST_IDENTITY ); +00064 +00066 CMatrix4(const CMatrix4<T>& other, eConstructor constructor = EM4CONST_COPY); +00067 +00069 T& operator()(const s32 row, const s32 col) +00070 { +00071 #if defined ( USE_MATRIX_TEST ) +00072 definitelyIdentityMatrix=false; +00073 #endif +00074 return M[ row * 4 + col ]; +00075 } +00076 +00078 const T& operator()(const s32 row, const s32 col) const { return M[row * 4 + col]; } +00079 +00081 T& operator[](u32 index) +00082 { +00083 #if defined ( USE_MATRIX_TEST ) +00084 definitelyIdentityMatrix=false; +00085 #endif +00086 return M[index]; +00087 } +00088 +00090 const T& operator[](u32 index) const { return M[index]; } +00091 +00093 inline CMatrix4<T>& operator=(const CMatrix4<T> &other); +00094 +00096 inline CMatrix4<T>& operator=(const T& scalar); +00097 +00099 const T* pointer() const { return M; } +00100 T* pointer() +00101 { +00102 #if defined ( USE_MATRIX_TEST ) +00103 definitelyIdentityMatrix=false; +00104 #endif +00105 return M; +00106 } +00107 +00109 bool operator==(const CMatrix4<T> &other) const; +00110 +00112 bool operator!=(const CMatrix4<T> &other) const; +00113 +00115 CMatrix4<T> operator+(const CMatrix4<T>& other) const; +00116 +00118 CMatrix4<T>& operator+=(const CMatrix4<T>& other); +00119 +00121 CMatrix4<T> operator-(const CMatrix4<T>& other) const; +00122 +00124 CMatrix4<T>& operator-=(const CMatrix4<T>& other); +00125 +00127 +00128 inline CMatrix4<T>& setbyproduct(const CMatrix4<T>& other_a,const CMatrix4<T>& other_b ); +00129 +00131 +00133 CMatrix4<T>& setbyproduct_nocheck(const CMatrix4<T>& other_a,const CMatrix4<T>& other_b ); +00134 +00136 +00137 CMatrix4<T> operator*(const CMatrix4<T>& other) const; +00138 +00140 +00141 CMatrix4<T>& operator*=(const CMatrix4<T>& other); +00142 +00144 CMatrix4<T> operator*(const T& scalar) const; +00145 +00147 CMatrix4<T>& operator*=(const T& scalar); +00148 +00150 inline CMatrix4<T>& makeIdentity(); +00151 +00153 inline bool isIdentity() const; +00154 +00156 inline bool isOrthogonal() const; +00157 +00159 bool isIdentity_integer_base () const; +00160 +00162 CMatrix4<T>& setTranslation( const vector3d<T>& translation ); +00163 +00165 vector3d<T> getTranslation() const; +00166 +00168 CMatrix4<T>& setInverseTranslation( const vector3d<T>& translation ); +00169 +00171 inline CMatrix4<T>& setRotationRadians( const vector3d<T>& rotation ); +00172 +00174 CMatrix4<T>& setRotationDegrees( const vector3d<T>& rotation ); +00175 +00177 +00178 core::vector3d<T> getRotationDegrees() const; +00179 +00181 +00182 inline CMatrix4<T>& setInverseRotationRadians( const vector3d<T>& rotation ); +00183 +00185 +00186 inline CMatrix4<T>& setInverseRotationDegrees( const vector3d<T>& rotation ); +00187 +00189 +00190 inline CMatrix4<T>& setRotationAxisRadians(const T& angle, const vector3d<T>& axis); +00191 +00193 CMatrix4<T>& setScale( const vector3d<T>& scale ); +00194 +00196 CMatrix4<T>& setScale( const T scale ) { return setScale(core::vector3d<T>(scale,scale,scale)); } +00197 +00199 core::vector3d<T> getScale() const; +00200 +00202 void inverseTranslateVect( vector3df& vect ) const; +00203 +00205 void inverseRotateVect( vector3df& vect ) const; +00206 +00208 void rotateVect( vector3df& vect ) const; +00209 +00211 void rotateVect(core::vector3df& out, const core::vector3df& in) const; +00212 +00214 void rotateVect(T *out,const core::vector3df &in) const; +00215 +00217 void transformVect( vector3df& vect) const; +00218 +00220 void transformVect( vector3df& out, const vector3df& in ) const; +00221 +00223 void transformVect(T *out,const core::vector3df &in) const; +00224 +00226 void transformVec3(T *out, const T * in) const; +00227 +00229 void translateVect( vector3df& vect ) const; +00230 +00232 void transformPlane( core::plane3d<f32> &plane) const; +00233 +00235 void transformPlane( const core::plane3d<f32> &in, core::plane3d<f32> &out) const; +00236 +00238 +00240 void transformBox(core::aabbox3d<f32>& box) const; +00241 +00243 +00245 void transformBoxEx(core::aabbox3d<f32>& box) const; +00246 +00248 void multiplyWith1x4Matrix(T* matrix) const; +00249 +00251 +00252 bool makeInverse(); +00253 +00254 +00256 +00257 bool getInversePrimitive ( CMatrix4<T>& out ) const; +00258 +00260 +00262 bool getInverse(CMatrix4<T>& out) const; +00263 +00265 CMatrix4<T>& buildProjectionMatrixPerspectiveFovRH(f32 fieldOfViewRadians, f32 aspectRatio, f32 zNear, f32 zFar); +00266 +00268 CMatrix4<T>& buildProjectionMatrixPerspectiveFovLH(f32 fieldOfViewRadians, f32 aspectRatio, f32 zNear, f32 zFar); +00269 +00271 CMatrix4<T>& buildProjectionMatrixPerspectiveFovInfinityLH(f32 fieldOfViewRadians, f32 aspectRatio, f32 zNear, f32 epsilon=0); +00272 +00274 CMatrix4<T>& buildProjectionMatrixPerspectiveRH(f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar); +00275 +00277 CMatrix4<T>& buildProjectionMatrixPerspectiveLH(f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar); +00278 +00280 CMatrix4<T>& buildProjectionMatrixOrthoLH(f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar); +00281 +00283 CMatrix4<T>& buildProjectionMatrixOrthoRH(f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar); +00284 +00286 CMatrix4<T>& buildCameraLookAtMatrixLH( +00287 const vector3df& position, +00288 const vector3df& target, +00289 const vector3df& upVector); +00290 +00292 CMatrix4<T>& buildCameraLookAtMatrixRH( +00293 const vector3df& position, +00294 const vector3df& target, +00295 const vector3df& upVector); +00296 +00298 +00302 CMatrix4<T>& buildShadowMatrix(const core::vector3df& light, core::plane3df plane, f32 point=1.0f); +00303 +00305 +00306 CMatrix4<T>& buildNDCToDCMatrix( const core::rect<s32>& area, f32 zScale); +00307 +00309 +00311 CMatrix4<T> interpolate(const core::CMatrix4<T>& b, f32 time) const; +00312 +00314 CMatrix4<T> getTransposed() const; +00315 +00317 inline void getTransposed( CMatrix4<T>& dest ) const; +00318 +00320 +00323 CMatrix4<T>& buildRotateFromTo(const core::vector3df& from, const core::vector3df& to); +00324 +00326 +00329 void setRotationCenter(const core::vector3df& center, const core::vector3df& translate); +00330 +00332 +00338 void buildAxisAlignedBillboard(const core::vector3df& camPos, +00339 const core::vector3df& center, +00340 const core::vector3df& translation, +00341 const core::vector3df& axis, +00342 const core::vector3df& from); +00343 +00344 /* +00345 construct 2D Texture transformations +00346 rotate about center, scale, and transform. +00347 */ +00349 CMatrix4<T>& buildTextureTransform( f32 rotateRad, +00350 const core::vector2df &rotatecenter, +00351 const core::vector2df &translate, +00352 const core::vector2df &scale); +00353 +00355 +00359 CMatrix4<T>& setTextureRotationCenter( f32 radAngle ); +00360 +00362 +00366 CMatrix4<T>& setTextureTranslate( f32 x, f32 y ); +00367 +00369 +00373 CMatrix4<T>& setTextureTranslateTransposed( f32 x, f32 y ); +00374 +00376 +00380 CMatrix4<T>& setTextureScale( f32 sx, f32 sy ); +00381 +00383 +00387 CMatrix4<T>& setTextureScaleCenter( f32 sx, f32 sy ); +00388 +00390 CMatrix4<T>& setM(const T* data); +00391 +00393 void setDefinitelyIdentityMatrix( bool isDefinitelyIdentityMatrix); +00394 +00396 bool getDefinitelyIdentityMatrix() const; +00397 +00399 bool equals(const core::CMatrix4<T>& other, const T tolerance=(T)ROUNDING_ERROR_f64) const; +00400 +00401 private: +00403 T M[16]; +00404 #if defined ( USE_MATRIX_TEST ) +00405 +00406 mutable u32 definitelyIdentityMatrix; +00407 #endif +00408 #if defined ( USE_MATRIX_TEST_DEBUG ) +00409 u32 id; +00410 mutable u32 calls; +00411 #endif +00412 +00413 }; +00414 +00415 // Default constructor +00416 template <class T> +00417 inline CMatrix4<T>::CMatrix4( eConstructor constructor ) +00418 #if defined ( USE_MATRIX_TEST ) +00419 : definitelyIdentityMatrix(BIT_UNTESTED) +00420 #endif +00421 #if defined ( USE_MATRIX_TEST_DEBUG ) +00422 ,id ( MTest.ID++), calls ( 0 ) +00423 #endif +00424 { +00425 switch ( constructor ) +00426 { +00427 case EM4CONST_NOTHING: +00428 case EM4CONST_COPY: +00429 break; +00430 case EM4CONST_IDENTITY: +00431 case EM4CONST_INVERSE: +00432 default: +00433 makeIdentity(); +00434 break; +00435 } +00436 } +00437 +00438 // Copy constructor +00439 template <class T> +00440 inline CMatrix4<T>::CMatrix4( const CMatrix4<T>& other, eConstructor constructor) +00441 #if defined ( USE_MATRIX_TEST ) +00442 : definitelyIdentityMatrix(BIT_UNTESTED) +00443 #endif +00444 #if defined ( USE_MATRIX_TEST_DEBUG ) +00445 ,id ( MTest.ID++), calls ( 0 ) +00446 #endif +00447 { +00448 switch ( constructor ) +00449 { +00450 case EM4CONST_IDENTITY: +00451 makeIdentity(); +00452 break; +00453 case EM4CONST_NOTHING: +00454 break; +00455 case EM4CONST_COPY: +00456 *this = other; +00457 break; +00458 case EM4CONST_TRANSPOSED: +00459 other.getTransposed(*this); +00460 break; +00461 case EM4CONST_INVERSE: +00462 if (!other.getInverse(*this)) +00463 memset(M, 0, 16*sizeof(T)); +00464 break; +00465 case EM4CONST_INVERSE_TRANSPOSED: +00466 if (!other.getInverse(*this)) +00467 memset(M, 0, 16*sizeof(T)); +00468 else +00469 *this=getTransposed(); +00470 break; +00471 } +00472 } +00473 +00475 template <class T> +00476 inline CMatrix4<T> CMatrix4<T>::operator+(const CMatrix4<T>& other) const +00477 { +00478 CMatrix4<T> temp ( EM4CONST_NOTHING ); +00479 +00480 temp[0] = M[0]+other[0]; +00481 temp[1] = M[1]+other[1]; +00482 temp[2] = M[2]+other[2]; +00483 temp[3] = M[3]+other[3]; +00484 temp[4] = M[4]+other[4]; +00485 temp[5] = M[5]+other[5]; +00486 temp[6] = M[6]+other[6]; +00487 temp[7] = M[7]+other[7]; +00488 temp[8] = M[8]+other[8]; +00489 temp[9] = M[9]+other[9]; +00490 temp[10] = M[10]+other[10]; +00491 temp[11] = M[11]+other[11]; +00492 temp[12] = M[12]+other[12]; +00493 temp[13] = M[13]+other[13]; +00494 temp[14] = M[14]+other[14]; +00495 temp[15] = M[15]+other[15]; +00496 +00497 return temp; +00498 } +00499 +00501 template <class T> +00502 inline CMatrix4<T>& CMatrix4<T>::operator+=(const CMatrix4<T>& other) +00503 { +00504 M[0]+=other[0]; +00505 M[1]+=other[1]; +00506 M[2]+=other[2]; +00507 M[3]+=other[3]; +00508 M[4]+=other[4]; +00509 M[5]+=other[5]; +00510 M[6]+=other[6]; +00511 M[7]+=other[7]; +00512 M[8]+=other[8]; +00513 M[9]+=other[9]; +00514 M[10]+=other[10]; +00515 M[11]+=other[11]; +00516 M[12]+=other[12]; +00517 M[13]+=other[13]; +00518 M[14]+=other[14]; +00519 M[15]+=other[15]; +00520 +00521 return *this; +00522 } +00523 +00525 template <class T> +00526 inline CMatrix4<T> CMatrix4<T>::operator-(const CMatrix4<T>& other) const +00527 { +00528 CMatrix4<T> temp ( EM4CONST_NOTHING ); +00529 +00530 temp[0] = M[0]-other[0]; +00531 temp[1] = M[1]-other[1]; +00532 temp[2] = M[2]-other[2]; +00533 temp[3] = M[3]-other[3]; +00534 temp[4] = M[4]-other[4]; +00535 temp[5] = M[5]-other[5]; +00536 temp[6] = M[6]-other[6]; +00537 temp[7] = M[7]-other[7]; +00538 temp[8] = M[8]-other[8]; +00539 temp[9] = M[9]-other[9]; +00540 temp[10] = M[10]-other[10]; +00541 temp[11] = M[11]-other[11]; +00542 temp[12] = M[12]-other[12]; +00543 temp[13] = M[13]-other[13]; +00544 temp[14] = M[14]-other[14]; +00545 temp[15] = M[15]-other[15]; +00546 +00547 return temp; +00548 } +00549 +00551 template <class T> +00552 inline CMatrix4<T>& CMatrix4<T>::operator-=(const CMatrix4<T>& other) +00553 { +00554 M[0]-=other[0]; +00555 M[1]-=other[1]; +00556 M[2]-=other[2]; +00557 M[3]-=other[3]; +00558 M[4]-=other[4]; +00559 M[5]-=other[5]; +00560 M[6]-=other[6]; +00561 M[7]-=other[7]; +00562 M[8]-=other[8]; +00563 M[9]-=other[9]; +00564 M[10]-=other[10]; +00565 M[11]-=other[11]; +00566 M[12]-=other[12]; +00567 M[13]-=other[13]; +00568 M[14]-=other[14]; +00569 M[15]-=other[15]; +00570 +00571 return *this; +00572 } +00573 +00575 template <class T> +00576 inline CMatrix4<T> CMatrix4<T>::operator*(const T& scalar) const +00577 { +00578 CMatrix4<T> temp ( EM4CONST_NOTHING ); +00579 +00580 temp[0] = M[0]*scalar; +00581 temp[1] = M[1]*scalar; +00582 temp[2] = M[2]*scalar; +00583 temp[3] = M[3]*scalar; +00584 temp[4] = M[4]*scalar; +00585 temp[5] = M[5]*scalar; +00586 temp[6] = M[6]*scalar; +00587 temp[7] = M[7]*scalar; +00588 temp[8] = M[8]*scalar; +00589 temp[9] = M[9]*scalar; +00590 temp[10] = M[10]*scalar; +00591 temp[11] = M[11]*scalar; +00592 temp[12] = M[12]*scalar; +00593 temp[13] = M[13]*scalar; +00594 temp[14] = M[14]*scalar; +00595 temp[15] = M[15]*scalar; +00596 +00597 return temp; +00598 } +00599 +00601 template <class T> +00602 inline CMatrix4<T>& CMatrix4<T>::operator*=(const T& scalar) +00603 { +00604 M[0]*=scalar; +00605 M[1]*=scalar; +00606 M[2]*=scalar; +00607 M[3]*=scalar; +00608 M[4]*=scalar; +00609 M[5]*=scalar; +00610 M[6]*=scalar; +00611 M[7]*=scalar; +00612 M[8]*=scalar; +00613 M[9]*=scalar; +00614 M[10]*=scalar; +00615 M[11]*=scalar; +00616 M[12]*=scalar; +00617 M[13]*=scalar; +00618 M[14]*=scalar; +00619 M[15]*=scalar; +00620 +00621 return *this; +00622 } +00623 +00625 template <class T> +00626 inline CMatrix4<T>& CMatrix4<T>::operator*=(const CMatrix4<T>& other) +00627 { +00628 #if defined ( USE_MATRIX_TEST ) +00629 // do checks on your own in order to avoid copy creation +00630 if ( !other.isIdentity() ) +00631 { +00632 if ( this->isIdentity() ) +00633 { +00634 return (*this = other); +00635 } +00636 else +00637 { +00638 CMatrix4<T> temp ( *this ); +00639 return setbyproduct_nocheck( temp, other ); +00640 } +00641 } +00642 return *this; +00643 #else +00644 CMatrix4<T> temp ( *this ); +00645 return setbyproduct_nocheck( temp, other ); +00646 #endif +00647 } +00648 +00650 // set this matrix to the product of two other matrices +00651 // goal is to reduce stack use and copy +00652 template <class T> +00653 inline CMatrix4<T>& CMatrix4<T>::setbyproduct_nocheck(const CMatrix4<T>& other_a,const CMatrix4<T>& other_b ) +00654 { +00655 const T *m1 = other_a.M; +00656 const T *m2 = other_b.M; +00657 +00658 M[0] = m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2] + m1[12]*m2[3]; +00659 M[1] = m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2] + m1[13]*m2[3]; +00660 M[2] = m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2] + m1[14]*m2[3]; +00661 M[3] = m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2] + m1[15]*m2[3]; +00662 +00663 M[4] = m1[0]*m2[4] + m1[4]*m2[5] + m1[8]*m2[6] + m1[12]*m2[7]; +00664 M[5] = m1[1]*m2[4] + m1[5]*m2[5] + m1[9]*m2[6] + m1[13]*m2[7]; +00665 M[6] = m1[2]*m2[4] + m1[6]*m2[5] + m1[10]*m2[6] + m1[14]*m2[7]; +00666 M[7] = m1[3]*m2[4] + m1[7]*m2[5] + m1[11]*m2[6] + m1[15]*m2[7]; +00667 +00668 M[8] = m1[0]*m2[8] + m1[4]*m2[9] + m1[8]*m2[10] + m1[12]*m2[11]; +00669 M[9] = m1[1]*m2[8] + m1[5]*m2[9] + m1[9]*m2[10] + m1[13]*m2[11]; +00670 M[10] = m1[2]*m2[8] + m1[6]*m2[9] + m1[10]*m2[10] + m1[14]*m2[11]; +00671 M[11] = m1[3]*m2[8] + m1[7]*m2[9] + m1[11]*m2[10] + m1[15]*m2[11]; +00672 +00673 M[12] = m1[0]*m2[12] + m1[4]*m2[13] + m1[8]*m2[14] + m1[12]*m2[15]; +00674 M[13] = m1[1]*m2[12] + m1[5]*m2[13] + m1[9]*m2[14] + m1[13]*m2[15]; +00675 M[14] = m1[2]*m2[12] + m1[6]*m2[13] + m1[10]*m2[14] + m1[14]*m2[15]; +00676 M[15] = m1[3]*m2[12] + m1[7]*m2[13] + m1[11]*m2[14] + m1[15]*m2[15]; +00677 #if defined ( USE_MATRIX_TEST ) +00678 definitelyIdentityMatrix=false; +00679 #endif +00680 return *this; +00681 } +00682 +00683 +00685 // set this matrix to the product of two other matrices +00686 // goal is to reduce stack use and copy +00687 template <class T> +00688 inline CMatrix4<T>& CMatrix4<T>::setbyproduct(const CMatrix4<T>& other_a, const CMatrix4<T>& other_b ) +00689 { +00690 #if defined ( USE_MATRIX_TEST ) +00691 if ( other_a.isIdentity () ) +00692 return (*this = other_b); +00693 else +00694 if ( other_b.isIdentity () ) +00695 return (*this = other_a); +00696 else +00697 return setbyproduct_nocheck(other_a,other_b); +00698 #else +00699 return setbyproduct_nocheck(other_a,other_b); +00700 #endif +00701 } +00702 +00704 template <class T> +00705 inline CMatrix4<T> CMatrix4<T>::operator*(const CMatrix4<T>& m2) const +00706 { +00707 #if defined ( USE_MATRIX_TEST ) +00708 // Testing purpose.. +00709 if ( this->isIdentity() ) +00710 return m2; +00711 if ( m2.isIdentity() ) +00712 return *this; +00713 #endif +00714 +00715 CMatrix4<T> m3 ( EM4CONST_NOTHING ); +00716 +00717 const T *m1 = M; +00718 +00719 m3[0] = m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2] + m1[12]*m2[3]; +00720 m3[1] = m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2] + m1[13]*m2[3]; +00721 m3[2] = m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2] + m1[14]*m2[3]; +00722 m3[3] = m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2] + m1[15]*m2[3]; +00723 +00724 m3[4] = m1[0]*m2[4] + m1[4]*m2[5] + m1[8]*m2[6] + m1[12]*m2[7]; +00725 m3[5] = m1[1]*m2[4] + m1[5]*m2[5] + m1[9]*m2[6] + m1[13]*m2[7]; +00726 m3[6] = m1[2]*m2[4] + m1[6]*m2[5] + m1[10]*m2[6] + m1[14]*m2[7]; +00727 m3[7] = m1[3]*m2[4] + m1[7]*m2[5] + m1[11]*m2[6] + m1[15]*m2[7]; +00728 +00729 m3[8] = m1[0]*m2[8] + m1[4]*m2[9] + m1[8]*m2[10] + m1[12]*m2[11]; +00730 m3[9] = m1[1]*m2[8] + m1[5]*m2[9] + m1[9]*m2[10] + m1[13]*m2[11]; +00731 m3[10] = m1[2]*m2[8] + m1[6]*m2[9] + m1[10]*m2[10] + m1[14]*m2[11]; +00732 m3[11] = m1[3]*m2[8] + m1[7]*m2[9] + m1[11]*m2[10] + m1[15]*m2[11]; +00733 +00734 m3[12] = m1[0]*m2[12] + m1[4]*m2[13] + m1[8]*m2[14] + m1[12]*m2[15]; +00735 m3[13] = m1[1]*m2[12] + m1[5]*m2[13] + m1[9]*m2[14] + m1[13]*m2[15]; +00736 m3[14] = m1[2]*m2[12] + m1[6]*m2[13] + m1[10]*m2[14] + m1[14]*m2[15]; +00737 m3[15] = m1[3]*m2[12] + m1[7]*m2[13] + m1[11]*m2[14] + m1[15]*m2[15]; +00738 return m3; +00739 } +00740 +00741 +00742 +00743 template <class T> +00744 inline vector3d<T> CMatrix4<T>::getTranslation() const +00745 { +00746 return vector3d<T>(M[12], M[13], M[14]); +00747 } +00748 +00749 +00750 template <class T> +00751 inline CMatrix4<T>& CMatrix4<T>::setTranslation( const vector3d<T>& translation ) +00752 { +00753 M[12] = translation.X; +00754 M[13] = translation.Y; +00755 M[14] = translation.Z; +00756 #if defined ( USE_MATRIX_TEST ) +00757 definitelyIdentityMatrix=false; +00758 #endif +00759 return *this; +00760 } +00761 +00762 template <class T> +00763 inline CMatrix4<T>& CMatrix4<T>::setInverseTranslation( const vector3d<T>& translation ) +00764 { +00765 M[12] = -translation.X; +00766 M[13] = -translation.Y; +00767 M[14] = -translation.Z; +00768 #if defined ( USE_MATRIX_TEST ) +00769 definitelyIdentityMatrix=false; +00770 #endif +00771 return *this; +00772 } +00773 +00774 template <class T> +00775 inline CMatrix4<T>& CMatrix4<T>::setScale( const vector3d<T>& scale ) +00776 { +00777 M[0] = scale.X; +00778 M[5] = scale.Y; +00779 M[10] = scale.Z; +00780 #if defined ( USE_MATRIX_TEST ) +00781 definitelyIdentityMatrix=false; +00782 #endif +00783 return *this; +00784 } +00785 +00787 +00794 template <class T> +00795 inline vector3d<T> CMatrix4<T>::getScale() const +00796 { +00797 // See http://www.robertblum.com/articles/2005/02/14/decomposing-matrices +00798 +00799 // Deal with the 0 rotation case first +00800 // Prior to Irrlicht 1.6, we always returned this value. +00801 if(core::iszero(M[1]) && core::iszero(M[2]) && +00802 core::iszero(M[4]) && core::iszero(M[6]) && +00803 core::iszero(M[8]) && core::iszero(M[9])) +00804 return vector3d<T>(M[0], M[5], M[10]); +00805 +00806 // We have to do the full calculation. +00807 return vector3d<T>(sqrtf(M[0] * M[0] + M[1] * M[1] + M[2] * M[2]), +00808 sqrtf(M[4] * M[4] + M[5] * M[5] + M[6] * M[6]), +00809 sqrtf(M[8] * M[8] + M[9] * M[9] + M[10] * M[10])); +00810 } +00811 +00812 template <class T> +00813 inline CMatrix4<T>& CMatrix4<T>::setRotationDegrees( const vector3d<T>& rotation ) +00814 { +00815 return setRotationRadians( rotation * core::DEGTORAD ); +00816 } +00817 +00818 template <class T> +00819 inline CMatrix4<T>& CMatrix4<T>::setInverseRotationDegrees( const vector3d<T>& rotation ) +00820 { +00821 return setInverseRotationRadians( rotation * core::DEGTORAD ); +00822 } +00823 +00824 template <class T> +00825 inline CMatrix4<T>& CMatrix4<T>::setRotationRadians( const vector3d<T>& rotation ) +00826 { +00827 const f64 cr = cos( rotation.X ); +00828 const f64 sr = sin( rotation.X ); +00829 const f64 cp = cos( rotation.Y ); +00830 const f64 sp = sin( rotation.Y ); +00831 const f64 cy = cos( rotation.Z ); +00832 const f64 sy = sin( rotation.Z ); +00833 +00834 M[0] = (T)( cp*cy ); +00835 M[1] = (T)( cp*sy ); +00836 M[2] = (T)( -sp ); +00837 +00838 const f64 srsp = sr*sp; +00839 const f64 crsp = cr*sp; +00840 +00841 M[4] = (T)( srsp*cy-cr*sy ); +00842 M[5] = (T)( srsp*sy+cr*cy ); +00843 M[6] = (T)( sr*cp ); +00844 +00845 M[8] = (T)( crsp*cy+sr*sy ); +00846 M[9] = (T)( crsp*sy-sr*cy ); +00847 M[10] = (T)( cr*cp ); +00848 #if defined ( USE_MATRIX_TEST ) +00849 definitelyIdentityMatrix=false; +00850 #endif +00851 return *this; +00852 } +00853 +00854 +00856 +00859 template <class T> +00860 inline core::vector3d<T> CMatrix4<T>::getRotationDegrees() const +00861 { +00862 const CMatrix4<T> &mat = *this; +00863 core::vector3d<T> scale = getScale(); +00864 // we need to check for negative scale on to axes, which would bring up wrong results +00865 if (scale.Y<0 && scale.Z<0) +00866 { +00867 scale.Y =-scale.Y; +00868 scale.Z =-scale.Z; +00869 } +00870 else if (scale.X<0 && scale.Z<0) +00871 { +00872 scale.X =-scale.X; +00873 scale.Z =-scale.Z; +00874 } +00875 else if (scale.X<0 && scale.Y<0) +00876 { +00877 scale.X =-scale.X; +00878 scale.Y =-scale.Y; +00879 } +00880 const core::vector3d<f64> invScale(core::reciprocal(scale.X),core::reciprocal(scale.Y),core::reciprocal(scale.Z)); +00881 +00882 f64 Y = -asin(core::clamp(mat[2]*invScale.X, -1.0, 1.0)); +00883 const f64 C = cos(Y); +00884 Y *= RADTODEG64; +00885 +00886 f64 rotx, roty, X, Z; +00887 +00888 if (!core::iszero(C)) +00889 { +00890 const f64 invC = core::reciprocal(C); +00891 rotx = mat[10] * invC * invScale.Z; +00892 roty = mat[6] * invC * invScale.Y; +00893 X = atan2( roty, rotx ) * RADTODEG64; +00894 rotx = mat[0] * invC * invScale.X; +00895 roty = mat[1] * invC * invScale.X; +00896 Z = atan2( roty, rotx ) * RADTODEG64; +00897 } +00898 else +00899 { +00900 X = 0.0; +00901 rotx = mat[5] * invScale.Y; +00902 roty = -mat[4] * invScale.Y; +00903 Z = atan2( roty, rotx ) * RADTODEG64; +00904 } +00905 +00906 // fix values that get below zero +00907 if (X < 0.0) X += 360.0; +00908 if (Y < 0.0) Y += 360.0; +00909 if (Z < 0.0) Z += 360.0; +00910 +00911 return vector3d<T>((T)X,(T)Y,(T)Z); +00912 } +00913 +00914 +00916 template <class T> +00917 inline CMatrix4<T>& CMatrix4<T>::setInverseRotationRadians( const vector3d<T>& rotation ) +00918 { +00919 f64 cr = cos( rotation.X ); +00920 f64 sr = sin( rotation.X ); +00921 f64 cp = cos( rotation.Y ); +00922 f64 sp = sin( rotation.Y ); +00923 f64 cy = cos( rotation.Z ); +00924 f64 sy = sin( rotation.Z ); +00925 +00926 M[0] = (T)( cp*cy ); +00927 M[4] = (T)( cp*sy ); +00928 M[8] = (T)( -sp ); +00929 +00930 f64 srsp = sr*sp; +00931 f64 crsp = cr*sp; +00932 +00933 M[1] = (T)( srsp*cy-cr*sy ); +00934 M[5] = (T)( srsp*sy+cr*cy ); +00935 M[9] = (T)( sr*cp ); +00936 +00937 M[2] = (T)( crsp*cy+sr*sy ); +00938 M[6] = (T)( crsp*sy-sr*cy ); +00939 M[10] = (T)( cr*cp ); +00940 #if defined ( USE_MATRIX_TEST ) +00941 definitelyIdentityMatrix=false; +00942 #endif +00943 return *this; +00944 } +00945 +00947 template <class T> +00948 inline CMatrix4<T>& CMatrix4<T>::setRotationAxisRadians( const T& angle, const vector3d<T>& axis ) +00949 { +00950 const f64 c = cos(angle); +00951 const f64 s = sin(angle); +00952 const f64 t = 1.0 - c; +00953 +00954 const f64 tx = t * axis.X; +00955 const f64 ty = t * axis.Y; +00956 const f64 tz = t * axis.Z; +00957 +00958 const f64 sx = s * axis.X; +00959 const f64 sy = s * axis.Y; +00960 const f64 sz = s * axis.Z; +00961 +00962 M[0] = (T)(tx * axis.X + c); +00963 M[1] = (T)(tx * axis.Y + sz); +00964 M[2] = (T)(tx * axis.Z - sy); +00965 +00966 M[4] = (T)(ty * axis.X - sz); +00967 M[5] = (T)(ty * axis.Y + c); +00968 M[6] = (T)(ty * axis.Z + sx); +00969 +00970 M[8] = (T)(tz * axis.X + sy); +00971 M[9] = (T)(tz * axis.Y - sx); +00972 M[10] = (T)(tz * axis.Z + c); +00973 +00974 #if defined ( USE_MATRIX_TEST ) +00975 definitelyIdentityMatrix=false; +00976 #endif +00977 return *this; +00978 } +00979 +00980 +00983 template <class T> +00984 inline CMatrix4<T>& CMatrix4<T>::makeIdentity() +00985 { +00986 memset(M, 0, 16*sizeof(T)); +00987 M[0] = M[5] = M[10] = M[15] = (T)1; +00988 #if defined ( USE_MATRIX_TEST ) +00989 definitelyIdentityMatrix=true; +00990 #endif +00991 return *this; +00992 } +00993 +00994 +00995 /* +00996 check identity with epsilon +00997 solve floating range problems.. +00998 */ +00999 template <class T> +01000 inline bool CMatrix4<T>::isIdentity() const +01001 { +01002 #if defined ( USE_MATRIX_TEST ) +01003 if (definitelyIdentityMatrix) +01004 return true; +01005 #endif +01006 if (!core::equals( M[12], (T)0 ) || !core::equals( M[13], (T)0 ) || !core::equals( M[14], (T)0 ) || !core::equals( M[15], (T)1 )) +01007 return false; +01008 +01009 if (!core::equals( M[ 0], (T)1 ) || !core::equals( M[ 1], (T)0 ) || !core::equals( M[ 2], (T)0 ) || !core::equals( M[ 3], (T)0 )) +01010 return false; +01011 +01012 if (!core::equals( M[ 4], (T)0 ) || !core::equals( M[ 5], (T)1 ) || !core::equals( M[ 6], (T)0 ) || !core::equals( M[ 7], (T)0 )) +01013 return false; +01014 +01015 if (!core::equals( M[ 8], (T)0 ) || !core::equals( M[ 9], (T)0 ) || !core::equals( M[10], (T)1 ) || !core::equals( M[11], (T)0 )) +01016 return false; +01017 /* +01018 if (!core::equals( M[ 0], (T)1 ) || +01019 !core::equals( M[ 5], (T)1 ) || +01020 !core::equals( M[10], (T)1 ) || +01021 !core::equals( M[15], (T)1 )) +01022 return false; +01023 +01024 for (s32 i=0; i<4; ++i) +01025 for (s32 j=0; j<4; ++j) +01026 if ((j != i) && (!iszero((*this)(i,j)))) +01027 return false; +01028 */ +01029 #if defined ( USE_MATRIX_TEST ) +01030 definitelyIdentityMatrix=true; +01031 #endif +01032 return true; +01033 } +01034 +01035 +01036 /* Check orthogonality of matrix. */ +01037 template <class T> +01038 inline bool CMatrix4<T>::isOrthogonal() const +01039 { +01040 T dp=M[0] * M[4 ] + M[1] * M[5 ] + M[2 ] * M[6 ] + M[3 ] * M[7 ]; +01041 if (!iszero(dp)) +01042 return false; +01043 dp = M[0] * M[8 ] + M[1] * M[9 ] + M[2 ] * M[10] + M[3 ] * M[11]; +01044 if (!iszero(dp)) +01045 return false; +01046 dp = M[0] * M[12] + M[1] * M[13] + M[2 ] * M[14] + M[3 ] * M[15]; +01047 if (!iszero(dp)) +01048 return false; +01049 dp = M[4] * M[8 ] + M[5] * M[9 ] + M[6 ] * M[10] + M[7 ] * M[11]; +01050 if (!iszero(dp)) +01051 return false; +01052 dp = M[4] * M[12] + M[5] * M[13] + M[6 ] * M[14] + M[7 ] * M[15]; +01053 if (!iszero(dp)) +01054 return false; +01055 dp = M[8] * M[12] + M[9] * M[13] + M[10] * M[14] + M[11] * M[15]; +01056 return (iszero(dp)); +01057 } +01058 +01059 +01060 /* +01061 doesn't solve floating range problems.. +01062 but takes care on +/- 0 on translation because we are changing it.. +01063 reducing floating point branches +01064 but it needs the floats in memory.. +01065 */ +01066 template <class T> +01067 inline bool CMatrix4<T>::isIdentity_integer_base() const +01068 { +01069 #if defined ( USE_MATRIX_TEST ) +01070 if (definitelyIdentityMatrix) +01071 return true; +01072 #endif +01073 if(IR(M[0])!=F32_VALUE_1) return false; +01074 if(IR(M[1])!=0) return false; +01075 if(IR(M[2])!=0) return false; +01076 if(IR(M[3])!=0) return false; +01077 +01078 if(IR(M[4])!=0) return false; +01079 if(IR(M[5])!=F32_VALUE_1) return false; +01080 if(IR(M[6])!=0) return false; +01081 if(IR(M[7])!=0) return false; +01082 +01083 if(IR(M[8])!=0) return false; +01084 if(IR(M[9])!=0) return false; +01085 if(IR(M[10])!=F32_VALUE_1) return false; +01086 if(IR(M[11])!=0) return false; +01087 +01088 if(IR(M[12])!=0) return false; +01089 if(IR(M[13])!=0) return false; +01090 if(IR(M[13])!=0) return false; +01091 if(IR(M[15])!=F32_VALUE_1) return false; +01092 +01093 #if defined ( USE_MATRIX_TEST ) +01094 definitelyIdentityMatrix=true; +01095 #endif +01096 return true; +01097 } +01098 +01099 +01100 template <class T> +01101 inline void CMatrix4<T>::rotateVect( vector3df& vect ) const +01102 { +01103 vector3df tmp = vect; +01104 vect.X = tmp.X*M[0] + tmp.Y*M[4] + tmp.Z*M[8]; +01105 vect.Y = tmp.X*M[1] + tmp.Y*M[5] + tmp.Z*M[9]; +01106 vect.Z = tmp.X*M[2] + tmp.Y*M[6] + tmp.Z*M[10]; +01107 } +01108 +01110 template <class T> +01111 inline void CMatrix4<T>::rotateVect(core::vector3df& out, const core::vector3df& in) const +01112 { +01113 out.X = in.X*M[0] + in.Y*M[4] + in.Z*M[8]; +01114 out.Y = in.X*M[1] + in.Y*M[5] + in.Z*M[9]; +01115 out.Z = in.X*M[2] + in.Y*M[6] + in.Z*M[10]; +01116 } +01117 +01119 template <class T> +01120 inline void CMatrix4<T>::rotateVect(T *out, const core::vector3df& in) const +01121 { +01122 out[0] = in.X*M[0] + in.Y*M[4] + in.Z*M[8]; +01123 out[1] = in.X*M[1] + in.Y*M[5] + in.Z*M[9]; +01124 out[2] = in.X*M[2] + in.Y*M[6] + in.Z*M[10]; +01125 } +01126 +01127 template <class T> +01128 inline void CMatrix4<T>::inverseRotateVect( vector3df& vect ) const +01129 { +01130 vector3df tmp = vect; +01131 vect.X = tmp.X*M[0] + tmp.Y*M[1] + tmp.Z*M[2]; +01132 vect.Y = tmp.X*M[4] + tmp.Y*M[5] + tmp.Z*M[6]; +01133 vect.Z = tmp.X*M[8] + tmp.Y*M[9] + tmp.Z*M[10]; +01134 } +01135 +01136 template <class T> +01137 inline void CMatrix4<T>::transformVect( vector3df& vect) const +01138 { +01139 f32 vector[3]; +01140 +01141 vector[0] = vect.X*M[0] + vect.Y*M[4] + vect.Z*M[8] + M[12]; +01142 vector[1] = vect.X*M[1] + vect.Y*M[5] + vect.Z*M[9] + M[13]; +01143 vector[2] = vect.X*M[2] + vect.Y*M[6] + vect.Z*M[10] + M[14]; +01144 +01145 vect.X = vector[0]; +01146 vect.Y = vector[1]; +01147 vect.Z = vector[2]; +01148 } +01149 +01150 template <class T> +01151 inline void CMatrix4<T>::transformVect( vector3df& out, const vector3df& in) const +01152 { +01153 out.X = in.X*M[0] + in.Y*M[4] + in.Z*M[8] + M[12]; +01154 out.Y = in.X*M[1] + in.Y*M[5] + in.Z*M[9] + M[13]; +01155 out.Z = in.X*M[2] + in.Y*M[6] + in.Z*M[10] + M[14]; +01156 } +01157 +01158 +01159 template <class T> +01160 inline void CMatrix4<T>::transformVect(T *out, const core::vector3df &in) const +01161 { +01162 out[0] = in.X*M[0] + in.Y*M[4] + in.Z*M[8] + M[12]; +01163 out[1] = in.X*M[1] + in.Y*M[5] + in.Z*M[9] + M[13]; +01164 out[2] = in.X*M[2] + in.Y*M[6] + in.Z*M[10] + M[14]; +01165 out[3] = in.X*M[3] + in.Y*M[7] + in.Z*M[11] + M[15]; +01166 } +01167 +01168 template <class T> +01169 inline void CMatrix4<T>::transformVec3(T *out, const T * in) const +01170 { +01171 out[0] = in[0]*M[0] + in[1]*M[4] + in[2]*M[8] + M[12]; +01172 out[1] = in[0]*M[1] + in[1]*M[5] + in[2]*M[9] + M[13]; +01173 out[2] = in[0]*M[2] + in[1]*M[6] + in[2]*M[10] + M[14]; +01174 } +01175 +01176 +01178 template <class T> +01179 inline void CMatrix4<T>::transformPlane( core::plane3d<f32> &plane) const +01180 { +01181 vector3df member; +01182 // Transform the plane member point, i.e. rotate, translate and scale it. +01183 transformVect(member, plane.getMemberPoint()); +01184 +01185 // Transform the normal by the transposed inverse of the matrix +01186 CMatrix4<T> transposedInverse(*this, EM4CONST_INVERSE_TRANSPOSED); +01187 vector3df normal = plane.Normal; +01188 transposedInverse.transformVect(normal); +01189 +01190 plane.setPlane(member, normal); +01191 } +01192 +01194 template <class T> +01195 inline void CMatrix4<T>::transformPlane( const core::plane3d<f32> &in, core::plane3d<f32> &out) const +01196 { +01197 out = in; +01198 transformPlane( out ); +01199 } +01200 +01202 template <class T> +01203 inline void CMatrix4<T>::transformBox(core::aabbox3d<f32>& box) const +01204 { +01205 #if defined ( USE_MATRIX_TEST ) +01206 if (isIdentity()) +01207 return; +01208 #endif +01209 +01210 transformVect(box.MinEdge); +01211 transformVect(box.MaxEdge); +01212 box.repair(); +01213 } +01214 +01216 template <class T> +01217 inline void CMatrix4<T>::transformBoxEx(core::aabbox3d<f32>& box) const +01218 { +01219 #if defined ( USE_MATRIX_TEST ) +01220 if (isIdentity()) +01221 return; +01222 #endif +01223 +01224 const f32 Amin[3] = {box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z}; +01225 const f32 Amax[3] = {box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z}; +01226 +01227 f32 Bmin[3]; +01228 f32 Bmax[3]; +01229 +01230 Bmin[0] = Bmax[0] = M[12]; +01231 Bmin[1] = Bmax[1] = M[13]; +01232 Bmin[2] = Bmax[2] = M[14]; +01233 +01234 const CMatrix4<T> &m = *this; +01235 +01236 for (u32 i = 0; i < 3; ++i) +01237 { +01238 for (u32 j = 0; j < 3; ++j) +01239 { +01240 const f32 a = m(j,i) * Amin[j]; +01241 const f32 b = m(j,i) * Amax[j]; +01242 +01243 if (a < b) +01244 { +01245 Bmin[i] += a; +01246 Bmax[i] += b; +01247 } +01248 else +01249 { +01250 Bmin[i] += b; +01251 Bmax[i] += a; +01252 } +01253 } +01254 } +01255 +01256 box.MinEdge.X = Bmin[0]; +01257 box.MinEdge.Y = Bmin[1]; +01258 box.MinEdge.Z = Bmin[2]; +01259 +01260 box.MaxEdge.X = Bmax[0]; +01261 box.MaxEdge.Y = Bmax[1]; +01262 box.MaxEdge.Z = Bmax[2]; +01263 } +01264 +01265 +01267 template <class T> +01268 inline void CMatrix4<T>::multiplyWith1x4Matrix(T* matrix) const +01269 { +01270 /* +01271 0 1 2 3 +01272 4 5 6 7 +01273 8 9 10 11 +01274 12 13 14 15 +01275 */ +01276 +01277 T mat[4]; +01278 mat[0] = matrix[0]; +01279 mat[1] = matrix[1]; +01280 mat[2] = matrix[2]; +01281 mat[3] = matrix[3]; +01282 +01283 matrix[0] = M[0]*mat[0] + M[4]*mat[1] + M[8]*mat[2] + M[12]*mat[3]; +01284 matrix[1] = M[1]*mat[0] + M[5]*mat[1] + M[9]*mat[2] + M[13]*mat[3]; +01285 matrix[2] = M[2]*mat[0] + M[6]*mat[1] + M[10]*mat[2] + M[14]*mat[3]; +01286 matrix[3] = M[3]*mat[0] + M[7]*mat[1] + M[11]*mat[2] + M[15]*mat[3]; +01287 } +01288 +01289 template <class T> +01290 inline void CMatrix4<T>::inverseTranslateVect( vector3df& vect ) const +01291 { +01292 vect.X = vect.X-M[12]; +01293 vect.Y = vect.Y-M[13]; +01294 vect.Z = vect.Z-M[14]; +01295 } +01296 +01297 template <class T> +01298 inline void CMatrix4<T>::translateVect( vector3df& vect ) const +01299 { +01300 vect.X = vect.X+M[12]; +01301 vect.Y = vect.Y+M[13]; +01302 vect.Z = vect.Z+M[14]; +01303 } +01304 +01305 +01306 template <class T> +01307 inline bool CMatrix4<T>::getInverse(CMatrix4<T>& out) const +01308 { +01312 +01313 #if defined ( USE_MATRIX_TEST ) +01314 if ( this->isIdentity() ) +01315 { +01316 out=*this; +01317 return true; +01318 } +01319 #endif +01320 const CMatrix4<T> &m = *this; +01321 +01322 f32 d = (m(0, 0) * m(1, 1) - m(0, 1) * m(1, 0)) * (m(2, 2) * m(3, 3) - m(2, 3) * m(3, 2)) - +01323 (m(0, 0) * m(1, 2) - m(0, 2) * m(1, 0)) * (m(2, 1) * m(3, 3) - m(2, 3) * m(3, 1)) + +01324 (m(0, 0) * m(1, 3) - m(0, 3) * m(1, 0)) * (m(2, 1) * m(3, 2) - m(2, 2) * m(3, 1)) + +01325 (m(0, 1) * m(1, 2) - m(0, 2) * m(1, 1)) * (m(2, 0) * m(3, 3) - m(2, 3) * m(3, 0)) - +01326 (m(0, 1) * m(1, 3) - m(0, 3) * m(1, 1)) * (m(2, 0) * m(3, 2) - m(2, 2) * m(3, 0)) + +01327 (m(0, 2) * m(1, 3) - m(0, 3) * m(1, 2)) * (m(2, 0) * m(3, 1) - m(2, 1) * m(3, 0)); +01328 +01329 if( core::iszero ( d, FLT_MIN ) ) +01330 return false; +01331 +01332 d = core::reciprocal ( d ); +01333 +01334 out(0, 0) = d * (m(1, 1) * (m(2, 2) * m(3, 3) - m(2, 3) * m(3, 2)) + +01335 m(1, 2) * (m(2, 3) * m(3, 1) - m(2, 1) * m(3, 3)) + +01336 m(1, 3) * (m(2, 1) * m(3, 2) - m(2, 2) * m(3, 1))); +01337 out(0, 1) = d * (m(2, 1) * (m(0, 2) * m(3, 3) - m(0, 3) * m(3, 2)) + +01338 m(2, 2) * (m(0, 3) * m(3, 1) - m(0, 1) * m(3, 3)) + +01339 m(2, 3) * (m(0, 1) * m(3, 2) - m(0, 2) * m(3, 1))); +01340 out(0, 2) = d * (m(3, 1) * (m(0, 2) * m(1, 3) - m(0, 3) * m(1, 2)) + +01341 m(3, 2) * (m(0, 3) * m(1, 1) - m(0, 1) * m(1, 3)) + +01342 m(3, 3) * (m(0, 1) * m(1, 2) - m(0, 2) * m(1, 1))); +01343 out(0, 3) = d * (m(0, 1) * (m(1, 3) * m(2, 2) - m(1, 2) * m(2, 3)) + +01344 m(0, 2) * (m(1, 1) * m(2, 3) - m(1, 3) * m(2, 1)) + +01345 m(0, 3) * (m(1, 2) * m(2, 1) - m(1, 1) * m(2, 2))); +01346 out(1, 0) = d * (m(1, 2) * (m(2, 0) * m(3, 3) - m(2, 3) * m(3, 0)) + +01347 m(1, 3) * (m(2, 2) * m(3, 0) - m(2, 0) * m(3, 2)) + +01348 m(1, 0) * (m(2, 3) * m(3, 2) - m(2, 2) * m(3, 3))); +01349 out(1, 1) = d * (m(2, 2) * (m(0, 0) * m(3, 3) - m(0, 3) * m(3, 0)) + +01350 m(2, 3) * (m(0, 2) * m(3, 0) - m(0, 0) * m(3, 2)) + +01351 m(2, 0) * (m(0, 3) * m(3, 2) - m(0, 2) * m(3, 3))); +01352 out(1, 2) = d * (m(3, 2) * (m(0, 0) * m(1, 3) - m(0, 3) * m(1, 0)) + +01353 m(3, 3) * (m(0, 2) * m(1, 0) - m(0, 0) * m(1, 2)) + +01354 m(3, 0) * (m(0, 3) * m(1, 2) - m(0, 2) * m(1, 3))); +01355 out(1, 3) = d * (m(0, 2) * (m(1, 3) * m(2, 0) - m(1, 0) * m(2, 3)) + +01356 m(0, 3) * (m(1, 0) * m(2, 2) - m(1, 2) * m(2, 0)) + +01357 m(0, 0) * (m(1, 2) * m(2, 3) - m(1, 3) * m(2, 2))); +01358 out(2, 0) = d * (m(1, 3) * (m(2, 0) * m(3, 1) - m(2, 1) * m(3, 0)) + +01359 m(1, 0) * (m(2, 1) * m(3, 3) - m(2, 3) * m(3, 1)) + +01360 m(1, 1) * (m(2, 3) * m(3, 0) - m(2, 0) * m(3, 3))); +01361 out(2, 1) = d * (m(2, 3) * (m(0, 0) * m(3, 1) - m(0, 1) * m(3, 0)) + +01362 m(2, 0) * (m(0, 1) * m(3, 3) - m(0, 3) * m(3, 1)) + +01363 m(2, 1) * (m(0, 3) * m(3, 0) - m(0, 0) * m(3, 3))); +01364 out(2, 2) = d * (m(3, 3) * (m(0, 0) * m(1, 1) - m(0, 1) * m(1, 0)) + +01365 m(3, 0) * (m(0, 1) * m(1, 3) - m(0, 3) * m(1, 1)) + +01366 m(3, 1) * (m(0, 3) * m(1, 0) - m(0, 0) * m(1, 3))); +01367 out(2, 3) = d * (m(0, 3) * (m(1, 1) * m(2, 0) - m(1, 0) * m(2, 1)) + +01368 m(0, 0) * (m(1, 3) * m(2, 1) - m(1, 1) * m(2, 3)) + +01369 m(0, 1) * (m(1, 0) * m(2, 3) - m(1, 3) * m(2, 0))); +01370 out(3, 0) = d * (m(1, 0) * (m(2, 2) * m(3, 1) - m(2, 1) * m(3, 2)) + +01371 m(1, 1) * (m(2, 0) * m(3, 2) - m(2, 2) * m(3, 0)) + +01372 m(1, 2) * (m(2, 1) * m(3, 0) - m(2, 0) * m(3, 1))); +01373 out(3, 1) = d * (m(2, 0) * (m(0, 2) * m(3, 1) - m(0, 1) * m(3, 2)) + +01374 m(2, 1) * (m(0, 0) * m(3, 2) - m(0, 2) * m(3, 0)) + +01375 m(2, 2) * (m(0, 1) * m(3, 0) - m(0, 0) * m(3, 1))); +01376 out(3, 2) = d * (m(3, 0) * (m(0, 2) * m(1, 1) - m(0, 1) * m(1, 2)) + +01377 m(3, 1) * (m(0, 0) * m(1, 2) - m(0, 2) * m(1, 0)) + +01378 m(3, 2) * (m(0, 1) * m(1, 0) - m(0, 0) * m(1, 1))); +01379 out(3, 3) = d * (m(0, 0) * (m(1, 1) * m(2, 2) - m(1, 2) * m(2, 1)) + +01380 m(0, 1) * (m(1, 2) * m(2, 0) - m(1, 0) * m(2, 2)) + +01381 m(0, 2) * (m(1, 0) * m(2, 1) - m(1, 1) * m(2, 0))); +01382 +01383 #if defined ( USE_MATRIX_TEST ) +01384 out.definitelyIdentityMatrix = definitelyIdentityMatrix; +01385 #endif +01386 return true; +01387 } +01388 +01389 +01392 template <class T> +01393 inline bool CMatrix4<T>::getInversePrimitive ( CMatrix4<T>& out ) const +01394 { +01395 out.M[0 ] = M[0]; +01396 out.M[1 ] = M[4]; +01397 out.M[2 ] = M[8]; +01398 out.M[3 ] = 0; +01399 +01400 out.M[4 ] = M[1]; +01401 out.M[5 ] = M[5]; +01402 out.M[6 ] = M[9]; +01403 out.M[7 ] = 0; +01404 +01405 out.M[8 ] = M[2]; +01406 out.M[9 ] = M[6]; +01407 out.M[10] = M[10]; +01408 out.M[11] = 0; +01409 +01410 out.M[12] = (T)-(M[12]*M[0] + M[13]*M[1] + M[14]*M[2]); +01411 out.M[13] = (T)-(M[12]*M[4] + M[13]*M[5] + M[14]*M[6]); +01412 out.M[14] = (T)-(M[12]*M[8] + M[13]*M[9] + M[14]*M[10]); +01413 out.M[15] = 1; +01414 +01415 #if defined ( USE_MATRIX_TEST ) +01416 out.definitelyIdentityMatrix = definitelyIdentityMatrix; +01417 #endif +01418 return true; +01419 } +01420 +01423 template <class T> +01424 inline bool CMatrix4<T>::makeInverse() +01425 { +01426 #if defined ( USE_MATRIX_TEST ) +01427 if (definitelyIdentityMatrix) +01428 return true; +01429 #endif +01430 CMatrix4<T> temp ( EM4CONST_NOTHING ); +01431 +01432 if (getInverse(temp)) +01433 { +01434 *this = temp; +01435 return true; +01436 } +01437 +01438 return false; +01439 } +01440 +01441 +01442 template <class T> +01443 inline CMatrix4<T>& CMatrix4<T>::operator=(const CMatrix4<T> &other) +01444 { +01445 if (this==&other) +01446 return *this; +01447 memcpy(M, other.M, 16*sizeof(T)); +01448 #if defined ( USE_MATRIX_TEST ) +01449 definitelyIdentityMatrix=other.definitelyIdentityMatrix; +01450 #endif +01451 return *this; +01452 } +01453 +01454 +01455 template <class T> +01456 inline CMatrix4<T>& CMatrix4<T>::operator=(const T& scalar) +01457 { +01458 for (s32 i = 0; i < 16; ++i) +01459 M[i]=scalar; +01460 +01461 #if defined ( USE_MATRIX_TEST ) +01462 definitelyIdentityMatrix=false; +01463 #endif +01464 return *this; +01465 } +01466 +01467 +01468 template <class T> +01469 inline bool CMatrix4<T>::operator==(const CMatrix4<T> &other) const +01470 { +01471 #if defined ( USE_MATRIX_TEST ) +01472 if (definitelyIdentityMatrix && other.definitelyIdentityMatrix) +01473 return true; +01474 #endif +01475 for (s32 i = 0; i < 16; ++i) +01476 if (M[i] != other.M[i]) +01477 return false; +01478 +01479 return true; +01480 } +01481 +01482 +01483 template <class T> +01484 inline bool CMatrix4<T>::operator!=(const CMatrix4<T> &other) const +01485 { +01486 return !(*this == other); +01487 } +01488 +01489 +01490 // Builds a right-handed perspective projection matrix based on a field of view +01491 template <class T> +01492 inline CMatrix4<T>& CMatrix4<T>::buildProjectionMatrixPerspectiveFovRH( +01493 f32 fieldOfViewRadians, f32 aspectRatio, f32 zNear, f32 zFar) +01494 { +01495 const f64 h = reciprocal(tan(fieldOfViewRadians*0.5)); +01496 _IRR_DEBUG_BREAK_IF(aspectRatio==0.f); //divide by zero +01497 const T w = static_cast<T>(h / aspectRatio); +01498 +01499 _IRR_DEBUG_BREAK_IF(zNear==zFar); //divide by zero +01500 M[0] = w; +01501 M[1] = 0; +01502 M[2] = 0; +01503 M[3] = 0; +01504 +01505 M[4] = 0; +01506 M[5] = (T)h; +01507 M[6] = 0; +01508 M[7] = 0; +01509 +01510 M[8] = 0; +01511 M[9] = 0; +01512 M[10] = (T)(zFar/(zNear-zFar)); // DirectX version +01513 // M[10] = (T)(zFar+zNear/(zNear-zFar)); // OpenGL version +01514 M[11] = -1; +01515 +01516 M[12] = 0; +01517 M[13] = 0; +01518 M[14] = (T)(zNear*zFar/(zNear-zFar)); // DirectX version +01519 // M[14] = (T)(2.0f*zNear*zFar/(zNear-zFar)); // OpenGL version +01520 M[15] = 0; +01521 +01522 #if defined ( USE_MATRIX_TEST ) +01523 definitelyIdentityMatrix=false; +01524 #endif +01525 return *this; +01526 } +01527 +01528 +01529 // Builds a left-handed perspective projection matrix based on a field of view +01530 template <class T> +01531 inline CMatrix4<T>& CMatrix4<T>::buildProjectionMatrixPerspectiveFovLH( +01532 f32 fieldOfViewRadians, f32 aspectRatio, f32 zNear, f32 zFar) +01533 { +01534 const f64 h = reciprocal(tan(fieldOfViewRadians*0.5)); +01535 _IRR_DEBUG_BREAK_IF(aspectRatio==0.f); //divide by zero +01536 const T w = static_cast<T>(h / aspectRatio); +01537 +01538 _IRR_DEBUG_BREAK_IF(zNear==zFar); //divide by zero +01539 M[0] = w; +01540 M[1] = 0; +01541 M[2] = 0; +01542 M[3] = 0; +01543 +01544 M[4] = 0; +01545 M[5] = (T)h; +01546 M[6] = 0; +01547 M[7] = 0; +01548 +01549 M[8] = 0; +01550 M[9] = 0; +01551 M[10] = (T)(zFar/(zFar-zNear)); +01552 M[11] = 1; +01553 +01554 M[12] = 0; +01555 M[13] = 0; +01556 M[14] = (T)(-zNear*zFar/(zFar-zNear)); +01557 M[15] = 0; +01558 +01559 #if defined ( USE_MATRIX_TEST ) +01560 definitelyIdentityMatrix=false; +01561 #endif +01562 return *this; +01563 } +01564 +01565 +01566 // Builds a left-handed perspective projection matrix based on a field of view, with far plane culling at infinity +01567 template <class T> +01568 inline CMatrix4<T>& CMatrix4<T>::buildProjectionMatrixPerspectiveFovInfinityLH( +01569 f32 fieldOfViewRadians, f32 aspectRatio, f32 zNear, f32 epsilon) +01570 { +01571 const f64 h = reciprocal(tan(fieldOfViewRadians*0.5)); +01572 _IRR_DEBUG_BREAK_IF(aspectRatio==0.f); //divide by zero +01573 const T w = static_cast<T>(h / aspectRatio); +01574 +01575 M[0] = w; +01576 M[1] = 0; +01577 M[2] = 0; +01578 M[3] = 0; +01579 +01580 M[4] = 0; +01581 M[5] = (T)h; +01582 M[6] = 0; +01583 M[7] = 0; +01584 +01585 M[8] = 0; +01586 M[9] = 0; +01587 M[10] = (T)(1.f-epsilon); +01588 M[11] = 1; +01589 +01590 M[12] = 0; +01591 M[13] = 0; +01592 M[14] = (T)(zNear*(epsilon-1.f)); +01593 M[15] = 0; +01594 +01595 #if defined ( USE_MATRIX_TEST ) +01596 definitelyIdentityMatrix=false; +01597 #endif +01598 return *this; +01599 } +01600 +01601 +01602 // Builds a left-handed orthogonal projection matrix. +01603 template <class T> +01604 inline CMatrix4<T>& CMatrix4<T>::buildProjectionMatrixOrthoLH( +01605 f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar) +01606 { +01607 _IRR_DEBUG_BREAK_IF(widthOfViewVolume==0.f); //divide by zero +01608 _IRR_DEBUG_BREAK_IF(heightOfViewVolume==0.f); //divide by zero +01609 _IRR_DEBUG_BREAK_IF(zNear==zFar); //divide by zero +01610 M[0] = (T)(2/widthOfViewVolume); +01611 M[1] = 0; +01612 M[2] = 0; +01613 M[3] = 0; +01614 +01615 M[4] = 0; +01616 M[5] = (T)(2/heightOfViewVolume); +01617 M[6] = 0; +01618 M[7] = 0; +01619 +01620 M[8] = 0; +01621 M[9] = 0; +01622 M[10] = (T)(1/(zFar-zNear)); +01623 M[11] = 0; +01624 +01625 M[12] = 0; +01626 M[13] = 0; +01627 M[14] = (T)(zNear/(zNear-zFar)); +01628 M[15] = 1; +01629 +01630 #if defined ( USE_MATRIX_TEST ) +01631 definitelyIdentityMatrix=false; +01632 #endif +01633 return *this; +01634 } +01635 +01636 +01637 // Builds a right-handed orthogonal projection matrix. +01638 template <class T> +01639 inline CMatrix4<T>& CMatrix4<T>::buildProjectionMatrixOrthoRH( +01640 f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar) +01641 { +01642 _IRR_DEBUG_BREAK_IF(widthOfViewVolume==0.f); //divide by zero +01643 _IRR_DEBUG_BREAK_IF(heightOfViewVolume==0.f); //divide by zero +01644 _IRR_DEBUG_BREAK_IF(zNear==zFar); //divide by zero +01645 M[0] = (T)(2/widthOfViewVolume); +01646 M[1] = 0; +01647 M[2] = 0; +01648 M[3] = 0; +01649 +01650 M[4] = 0; +01651 M[5] = (T)(2/heightOfViewVolume); +01652 M[6] = 0; +01653 M[7] = 0; +01654 +01655 M[8] = 0; +01656 M[9] = 0; +01657 M[10] = (T)(1/(zNear-zFar)); +01658 M[11] = 0; +01659 +01660 M[12] = 0; +01661 M[13] = 0; +01662 M[14] = (T)(zNear/(zNear-zFar)); +01663 M[15] = 1; +01664 +01665 #if defined ( USE_MATRIX_TEST ) +01666 definitelyIdentityMatrix=false; +01667 #endif +01668 return *this; +01669 } +01670 +01671 +01672 // Builds a right-handed perspective projection matrix. +01673 template <class T> +01674 inline CMatrix4<T>& CMatrix4<T>::buildProjectionMatrixPerspectiveRH( +01675 f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar) +01676 { +01677 _IRR_DEBUG_BREAK_IF(widthOfViewVolume==0.f); //divide by zero +01678 _IRR_DEBUG_BREAK_IF(heightOfViewVolume==0.f); //divide by zero +01679 _IRR_DEBUG_BREAK_IF(zNear==zFar); //divide by zero +01680 M[0] = (T)(2*zNear/widthOfViewVolume); +01681 M[1] = 0; +01682 M[2] = 0; +01683 M[3] = 0; +01684 +01685 M[4] = 0; +01686 M[5] = (T)(2*zNear/heightOfViewVolume); +01687 M[6] = 0; +01688 M[7] = 0; +01689 +01690 M[8] = 0; +01691 M[9] = 0; +01692 M[10] = (T)(zFar/(zNear-zFar)); +01693 M[11] = -1; +01694 +01695 M[12] = 0; +01696 M[13] = 0; +01697 M[14] = (T)(zNear*zFar/(zNear-zFar)); +01698 M[15] = 0; +01699 +01700 #if defined ( USE_MATRIX_TEST ) +01701 definitelyIdentityMatrix=false; +01702 #endif +01703 return *this; +01704 } +01705 +01706 +01707 // Builds a left-handed perspective projection matrix. +01708 template <class T> +01709 inline CMatrix4<T>& CMatrix4<T>::buildProjectionMatrixPerspectiveLH( +01710 f32 widthOfViewVolume, f32 heightOfViewVolume, f32 zNear, f32 zFar) +01711 { +01712 _IRR_DEBUG_BREAK_IF(widthOfViewVolume==0.f); //divide by zero +01713 _IRR_DEBUG_BREAK_IF(heightOfViewVolume==0.f); //divide by zero +01714 _IRR_DEBUG_BREAK_IF(zNear==zFar); //divide by zero +01715 M[0] = (T)(2*zNear/widthOfViewVolume); +01716 M[1] = 0; +01717 M[2] = 0; +01718 M[3] = 0; +01719 +01720 M[4] = 0; +01721 M[5] = (T)(2*zNear/heightOfViewVolume); +01722 M[6] = 0; +01723 M[7] = 0; +01724 +01725 M[8] = 0; +01726 M[9] = 0; +01727 M[10] = (T)(zFar/(zFar-zNear)); +01728 M[11] = 1; +01729 +01730 M[12] = 0; +01731 M[13] = 0; +01732 M[14] = (T)(zNear*zFar/(zNear-zFar)); +01733 M[15] = 0; +01734 #if defined ( USE_MATRIX_TEST ) +01735 definitelyIdentityMatrix=false; +01736 #endif +01737 return *this; +01738 } +01739 +01740 +01741 // Builds a matrix that flattens geometry into a plane. +01742 template <class T> +01743 inline CMatrix4<T>& CMatrix4<T>::buildShadowMatrix(const core::vector3df& light, core::plane3df plane, f32 point) +01744 { +01745 plane.Normal.normalize(); +01746 const f32 d = plane.Normal.dotProduct(light); +01747 +01748 M[ 0] = (T)(-plane.Normal.X * light.X + d); +01749 M[ 1] = (T)(-plane.Normal.X * light.Y); +01750 M[ 2] = (T)(-plane.Normal.X * light.Z); +01751 M[ 3] = (T)(-plane.Normal.X * point); +01752 +01753 M[ 4] = (T)(-plane.Normal.Y * light.X); +01754 M[ 5] = (T)(-plane.Normal.Y * light.Y + d); +01755 M[ 6] = (T)(-plane.Normal.Y * light.Z); +01756 M[ 7] = (T)(-plane.Normal.Y * point); +01757 +01758 M[ 8] = (T)(-plane.Normal.Z * light.X); +01759 M[ 9] = (T)(-plane.Normal.Z * light.Y); +01760 M[10] = (T)(-plane.Normal.Z * light.Z + d); +01761 M[11] = (T)(-plane.Normal.Z * point); +01762 +01763 M[12] = (T)(-plane.D * light.X); +01764 M[13] = (T)(-plane.D * light.Y); +01765 M[14] = (T)(-plane.D * light.Z); +01766 M[15] = (T)(-plane.D * point + d); +01767 #if defined ( USE_MATRIX_TEST ) +01768 definitelyIdentityMatrix=false; +01769 #endif +01770 return *this; +01771 } +01772 +01773 // Builds a left-handed look-at matrix. +01774 template <class T> +01775 inline CMatrix4<T>& CMatrix4<T>::buildCameraLookAtMatrixLH( +01776 const vector3df& position, +01777 const vector3df& target, +01778 const vector3df& upVector) +01779 { +01780 vector3df zaxis = target - position; +01781 zaxis.normalize(); +01782 +01783 vector3df xaxis = upVector.crossProduct(zaxis); +01784 xaxis.normalize(); +01785 +01786 vector3df yaxis = zaxis.crossProduct(xaxis); +01787 +01788 M[0] = (T)xaxis.X; +01789 M[1] = (T)yaxis.X; +01790 M[2] = (T)zaxis.X; +01791 M[3] = 0; +01792 +01793 M[4] = (T)xaxis.Y; +01794 M[5] = (T)yaxis.Y; +01795 M[6] = (T)zaxis.Y; +01796 M[7] = 0; +01797 +01798 M[8] = (T)xaxis.Z; +01799 M[9] = (T)yaxis.Z; +01800 M[10] = (T)zaxis.Z; +01801 M[11] = 0; +01802 +01803 M[12] = (T)-xaxis.dotProduct(position); +01804 M[13] = (T)-yaxis.dotProduct(position); +01805 M[14] = (T)-zaxis.dotProduct(position); +01806 M[15] = 1; +01807 #if defined ( USE_MATRIX_TEST ) +01808 definitelyIdentityMatrix=false; +01809 #endif +01810 return *this; +01811 } +01812 +01813 +01814 // Builds a right-handed look-at matrix. +01815 template <class T> +01816 inline CMatrix4<T>& CMatrix4<T>::buildCameraLookAtMatrixRH( +01817 const vector3df& position, +01818 const vector3df& target, +01819 const vector3df& upVector) +01820 { +01821 vector3df zaxis = position - target; +01822 zaxis.normalize(); +01823 +01824 vector3df xaxis = upVector.crossProduct(zaxis); +01825 xaxis.normalize(); +01826 +01827 vector3df yaxis = zaxis.crossProduct(xaxis); +01828 +01829 M[0] = (T)xaxis.X; +01830 M[1] = (T)yaxis.X; +01831 M[2] = (T)zaxis.X; +01832 M[3] = 0; +01833 +01834 M[4] = (T)xaxis.Y; +01835 M[5] = (T)yaxis.Y; +01836 M[6] = (T)zaxis.Y; +01837 M[7] = 0; +01838 +01839 M[8] = (T)xaxis.Z; +01840 M[9] = (T)yaxis.Z; +01841 M[10] = (T)zaxis.Z; +01842 M[11] = 0; +01843 +01844 M[12] = (T)-xaxis.dotProduct(position); +01845 M[13] = (T)-yaxis.dotProduct(position); +01846 M[14] = (T)-zaxis.dotProduct(position); +01847 M[15] = 1; +01848 #if defined ( USE_MATRIX_TEST ) +01849 definitelyIdentityMatrix=false; +01850 #endif +01851 return *this; +01852 } +01853 +01854 +01855 // creates a new matrix as interpolated matrix from this and the passed one. +01856 template <class T> +01857 inline CMatrix4<T> CMatrix4<T>::interpolate(const core::CMatrix4<T>& b, f32 time) const +01858 { +01859 CMatrix4<T> mat ( EM4CONST_NOTHING ); +01860 +01861 for (u32 i=0; i < 16; i += 4) +01862 { +01863 mat.M[i+0] = (T)(M[i+0] + ( b.M[i+0] - M[i+0] ) * time); +01864 mat.M[i+1] = (T)(M[i+1] + ( b.M[i+1] - M[i+1] ) * time); +01865 mat.M[i+2] = (T)(M[i+2] + ( b.M[i+2] - M[i+2] ) * time); +01866 mat.M[i+3] = (T)(M[i+3] + ( b.M[i+3] - M[i+3] ) * time); +01867 } +01868 return mat; +01869 } +01870 +01871 +01872 // returns transposed matrix +01873 template <class T> +01874 inline CMatrix4<T> CMatrix4<T>::getTransposed() const +01875 { +01876 CMatrix4<T> t ( EM4CONST_NOTHING ); +01877 getTransposed ( t ); +01878 return t; +01879 } +01880 +01881 +01882 // returns transposed matrix +01883 template <class T> +01884 inline void CMatrix4<T>::getTransposed( CMatrix4<T>& o ) const +01885 { +01886 o[ 0] = M[ 0]; +01887 o[ 1] = M[ 4]; +01888 o[ 2] = M[ 8]; +01889 o[ 3] = M[12]; +01890 +01891 o[ 4] = M[ 1]; +01892 o[ 5] = M[ 5]; +01893 o[ 6] = M[ 9]; +01894 o[ 7] = M[13]; +01895 +01896 o[ 8] = M[ 2]; +01897 o[ 9] = M[ 6]; +01898 o[10] = M[10]; +01899 o[11] = M[14]; +01900 +01901 o[12] = M[ 3]; +01902 o[13] = M[ 7]; +01903 o[14] = M[11]; +01904 o[15] = M[15]; +01905 #if defined ( USE_MATRIX_TEST ) +01906 o.definitelyIdentityMatrix=definitelyIdentityMatrix; +01907 #endif +01908 } +01909 +01910 +01911 // used to scale <-1,-1><1,1> to viewport +01912 template <class T> +01913 inline CMatrix4<T>& CMatrix4<T>::buildNDCToDCMatrix( const core::rect<s32>& viewport, f32 zScale) +01914 { +01915 const f32 scaleX = (viewport.getWidth() - 0.75f ) * 0.5f; +01916 const f32 scaleY = -(viewport.getHeight() - 0.75f ) * 0.5f; +01917 +01918 const f32 dx = -0.5f + ( (viewport.UpperLeftCorner.X + viewport.LowerRightCorner.X ) * 0.5f ); +01919 const f32 dy = -0.5f + ( (viewport.UpperLeftCorner.Y + viewport.LowerRightCorner.Y ) * 0.5f ); +01920 +01921 makeIdentity(); +01922 M[12] = (T)dx; +01923 M[13] = (T)dy; +01924 return setScale(core::vector3d<T>((T)scaleX, (T)scaleY, (T)zScale)); +01925 } +01926 +01928 +01933 template <class T> +01934 inline CMatrix4<T>& CMatrix4<T>::buildRotateFromTo(const core::vector3df& from, const core::vector3df& to) +01935 { +01936 // unit vectors +01937 core::vector3df f(from); +01938 core::vector3df t(to); +01939 f.normalize(); +01940 t.normalize(); +01941 +01942 // axis multiplication by sin +01943 core::vector3df vs(t.crossProduct(f)); +01944 +01945 // axis of rotation +01946 core::vector3df v(vs); +01947 v.normalize(); +01948 +01949 // cosinus angle +01950 T ca = f.dotProduct(t); +01951 +01952 core::vector3df vt(v * (1 - ca)); +01953 +01954 M[0] = vt.X * v.X + ca; +01955 M[5] = vt.Y * v.Y + ca; +01956 M[10] = vt.Z * v.Z + ca; +01957 +01958 vt.X *= v.Y; +01959 vt.Z *= v.X; +01960 vt.Y *= v.Z; +01961 +01962 M[1] = vt.X - vs.Z; +01963 M[2] = vt.Z + vs.Y; +01964 M[3] = 0; +01965 +01966 M[4] = vt.X + vs.Z; +01967 M[6] = vt.Y - vs.X; +01968 M[7] = 0; +01969 +01970 M[8] = vt.Z - vs.Y; +01971 M[9] = vt.Y + vs.X; +01972 M[11] = 0; +01973 +01974 M[12] = 0; +01975 M[13] = 0; +01976 M[14] = 0; +01977 M[15] = 1; +01978 +01979 return *this; +01980 } +01981 +01983 +01989 template <class T> +01990 inline void CMatrix4<T>::buildAxisAlignedBillboard( +01991 const core::vector3df& camPos, +01992 const core::vector3df& center, +01993 const core::vector3df& translation, +01994 const core::vector3df& axis, +01995 const core::vector3df& from) +01996 { +01997 // axis of rotation +01998 core::vector3df up = axis; +01999 up.normalize(); +02000 const core::vector3df forward = (camPos - center).normalize(); +02001 const core::vector3df right = up.crossProduct(forward).normalize(); +02002 +02003 // correct look vector +02004 const core::vector3df look = right.crossProduct(up); +02005 +02006 // rotate from to +02007 // axis multiplication by sin +02008 const core::vector3df vs = look.crossProduct(from); +02009 +02010 // cosinus angle +02011 const f32 ca = from.dotProduct(look); +02012 +02013 core::vector3df vt(up * (1.f - ca)); +02014 +02015 M[0] = static_cast<T>(vt.X * up.X + ca); +02016 M[5] = static_cast<T>(vt.Y * up.Y + ca); +02017 M[10] = static_cast<T>(vt.Z * up.Z + ca); +02018 +02019 vt.X *= up.Y; +02020 vt.Z *= up.X; +02021 vt.Y *= up.Z; +02022 +02023 M[1] = static_cast<T>(vt.X - vs.Z); +02024 M[2] = static_cast<T>(vt.Z + vs.Y); +02025 M[3] = 0; +02026 +02027 M[4] = static_cast<T>(vt.X + vs.Z); +02028 M[6] = static_cast<T>(vt.Y - vs.X); +02029 M[7] = 0; +02030 +02031 M[8] = static_cast<T>(vt.Z - vs.Y); +02032 M[9] = static_cast<T>(vt.Y + vs.X); +02033 M[11] = 0; +02034 +02035 setRotationCenter(center, translation); +02036 } +02037 +02038 +02040 template <class T> +02041 inline void CMatrix4<T>::setRotationCenter(const core::vector3df& center, const core::vector3df& translation) +02042 { +02043 M[12] = -M[0]*center.X - M[4]*center.Y - M[8]*center.Z + (center.X - translation.X ); +02044 M[13] = -M[1]*center.X - M[5]*center.Y - M[9]*center.Z + (center.Y - translation.Y ); +02045 M[14] = -M[2]*center.X - M[6]*center.Y - M[10]*center.Z + (center.Z - translation.Z ); +02046 M[15] = (T) 1.0; +02047 #if defined ( USE_MATRIX_TEST ) +02048 definitelyIdentityMatrix=false; +02049 #endif +02050 } +02051 +02064 template <class T> +02065 inline CMatrix4<T>& CMatrix4<T>::buildTextureTransform( f32 rotateRad, +02066 const core::vector2df &rotatecenter, +02067 const core::vector2df &translate, +02068 const core::vector2df &scale) +02069 { +02070 const f32 c = cosf(rotateRad); +02071 const f32 s = sinf(rotateRad); +02072 +02073 M[0] = (T)(c * scale.X); +02074 M[1] = (T)(s * scale.Y); +02075 M[2] = 0; +02076 M[3] = 0; +02077 +02078 M[4] = (T)(-s * scale.X); +02079 M[5] = (T)(c * scale.Y); +02080 M[6] = 0; +02081 M[7] = 0; +02082 +02083 M[8] = (T)(c * scale.X * rotatecenter.X + -s * rotatecenter.Y + translate.X); +02084 M[9] = (T)(s * scale.Y * rotatecenter.X + c * rotatecenter.Y + translate.Y); +02085 M[10] = 1; +02086 M[11] = 0; +02087 +02088 M[12] = 0; +02089 M[13] = 0; +02090 M[14] = 0; +02091 M[15] = 1; +02092 #if defined ( USE_MATRIX_TEST ) +02093 definitelyIdentityMatrix=false; +02094 #endif +02095 return *this; +02096 } +02097 +02098 +02099 // rotate about z axis, center ( 0.5, 0.5 ) +02100 template <class T> +02101 inline CMatrix4<T>& CMatrix4<T>::setTextureRotationCenter( f32 rotateRad ) +02102 { +02103 const f32 c = cosf(rotateRad); +02104 const f32 s = sinf(rotateRad); +02105 M[0] = (T)c; +02106 M[1] = (T)s; +02107 +02108 M[4] = (T)-s; +02109 M[5] = (T)c; +02110 +02111 M[8] = (T)(0.5f * ( s - c) + 0.5f); +02112 M[9] = (T)(-0.5f * ( s + c) + 0.5f); +02113 +02114 #if defined ( USE_MATRIX_TEST ) +02115 definitelyIdentityMatrix = definitelyIdentityMatrix && (rotateRad==0.0f); +02116 #endif +02117 return *this; +02118 } +02119 +02120 +02121 template <class T> +02122 inline CMatrix4<T>& CMatrix4<T>::setTextureTranslate ( f32 x, f32 y ) +02123 { +02124 M[8] = (T)x; +02125 M[9] = (T)y; +02126 +02127 #if defined ( USE_MATRIX_TEST ) +02128 definitelyIdentityMatrix = definitelyIdentityMatrix && (x==0.0f) && (y==0.0f); +02129 #endif +02130 return *this; +02131 } +02132 +02133 +02134 template <class T> +02135 inline CMatrix4<T>& CMatrix4<T>::setTextureTranslateTransposed ( f32 x, f32 y ) +02136 { +02137 M[2] = (T)x; +02138 M[6] = (T)y; +02139 +02140 #if defined ( USE_MATRIX_TEST ) +02141 definitelyIdentityMatrix = definitelyIdentityMatrix && (x==0.0f) && (y==0.0f) ; +02142 #endif +02143 return *this; +02144 } +02145 +02146 template <class T> +02147 inline CMatrix4<T>& CMatrix4<T>::setTextureScale ( f32 sx, f32 sy ) +02148 { +02149 M[0] = (T)sx; +02150 M[5] = (T)sy; +02151 #if defined ( USE_MATRIX_TEST ) +02152 definitelyIdentityMatrix = definitelyIdentityMatrix && (sx==1.0f) && (sy==1.0f); +02153 #endif +02154 return *this; +02155 } +02156 +02157 +02158 template <class T> +02159 inline CMatrix4<T>& CMatrix4<T>::setTextureScaleCenter( f32 sx, f32 sy ) +02160 { +02161 M[0] = (T)sx; +02162 M[5] = (T)sy; +02163 M[8] = (T)(0.5f - 0.5f * sx); +02164 M[9] = (T)(0.5f - 0.5f * sy); +02165 +02166 #if defined ( USE_MATRIX_TEST ) +02167 definitelyIdentityMatrix = definitelyIdentityMatrix && (sx==1.0f) && (sy==1.0f); +02168 #endif +02169 return *this; +02170 } +02171 +02172 +02173 // sets all matrix data members at once +02174 template <class T> +02175 inline CMatrix4<T>& CMatrix4<T>::setM(const T* data) +02176 { +02177 memcpy(M,data, 16*sizeof(T)); +02178 +02179 #if defined ( USE_MATRIX_TEST ) +02180 definitelyIdentityMatrix=false; +02181 #endif +02182 return *this; +02183 } +02184 +02185 +02186 // sets if the matrix is definitely identity matrix +02187 template <class T> +02188 inline void CMatrix4<T>::setDefinitelyIdentityMatrix( bool isDefinitelyIdentityMatrix) +02189 { +02190 #if defined ( USE_MATRIX_TEST ) +02191 definitelyIdentityMatrix = isDefinitelyIdentityMatrix; +02192 #endif +02193 } +02194 +02195 +02196 // gets if the matrix is definitely identity matrix +02197 template <class T> +02198 inline bool CMatrix4<T>::getDefinitelyIdentityMatrix() const +02199 { +02200 #if defined ( USE_MATRIX_TEST ) +02201 return definitelyIdentityMatrix; +02202 #else +02203 return false; +02204 #endif +02205 } +02206 +02207 +02209 template <class T> +02210 inline bool CMatrix4<T>::equals(const core::CMatrix4<T>& other, const T tolerance) const +02211 { +02212 #if defined ( USE_MATRIX_TEST ) +02213 if (definitelyIdentityMatrix && other.definitelyIdentityMatrix) +02214 return true; +02215 #endif +02216 for (s32 i = 0; i < 16; ++i) +02217 if (!core::equals(M[i],other.M[i], tolerance)) +02218 return false; +02219 +02220 return true; +02221 } +02222 +02223 +02224 // Multiply by scalar. +02225 template <class T> +02226 inline CMatrix4<T> operator*(const T scalar, const CMatrix4<T>& mat) +02227 { +02228 return mat*scalar; +02229 } +02230 +02231 +02233 typedef CMatrix4<f32> matrix4; +02234 +02236 IRRLICHT_API extern const matrix4 IdentityMatrix; +02237 +02238 } // end namespace core +02239 } // end namespace irr +02240 +02241 #endif +02242 +