OgreMatrix4.h

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004     (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright (c) 2000-2006 Torus Knot Software Ltd
00008 Also see acknowledgements in Readme.html
00009 
00010 This program is free software; you can redistribute it and/or modify it under
00011 the terms of the GNU Lesser General Public License as published by the Free Software
00012 Foundation; either version 2 of the License, or (at your option) any later
00013 version.
00014 
00015 This program is distributed in the hope that it will be useful, but WITHOUT
00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public License along with
00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00022 http://www.gnu.org/copyleft/lesser.txt.
00023 
00024 You may alternatively use this source under the terms of a specific version of
00025 the OGRE Unrestricted License provided you have obtained such a license from
00026 Torus Knot Software Ltd.
00027 -----------------------------------------------------------------------------
00028 */
00029 #ifndef __Matrix4__
00030 #define __Matrix4__
00031 
00032 // Precompiler options
00033 #include "OgrePrerequisites.h"
00034 
00035 #include "OgreVector3.h"
00036 #include "OgreMatrix3.h"
00037 #include "OgreVector4.h"
00038 #include "OgrePlane.h"
00039 namespace Ogre
00040 {
00073     class _OgreExport Matrix4
00074     {
00075     protected:
00077         union {
00078             Real m[4][4];
00079             Real _m[16];
00080         };
00081     public:
00086         inline Matrix4()
00087         {
00088         }
00089 
00090         inline Matrix4(
00091             Real m00, Real m01, Real m02, Real m03,
00092             Real m10, Real m11, Real m12, Real m13,
00093             Real m20, Real m21, Real m22, Real m23,
00094             Real m30, Real m31, Real m32, Real m33 )
00095         {
00096             m[0][0] = m00;
00097             m[0][1] = m01;
00098             m[0][2] = m02;
00099             m[0][3] = m03;
00100             m[1][0] = m10;
00101             m[1][1] = m11;
00102             m[1][2] = m12;
00103             m[1][3] = m13;
00104             m[2][0] = m20;
00105             m[2][1] = m21;
00106             m[2][2] = m22;
00107             m[2][3] = m23;
00108             m[3][0] = m30;
00109             m[3][1] = m31;
00110             m[3][2] = m32;
00111             m[3][3] = m33;
00112         }
00113 
00117         inline Matrix4(const Matrix3& m3x3)
00118         {
00119           operator=(IDENTITY);
00120           operator=(m3x3);
00121         }
00122 
00126         inline Matrix4(const Quaternion& rot)
00127         {
00128           Matrix3 m3x3;
00129           rot.ToRotationMatrix(m3x3);
00130           operator=(IDENTITY);
00131           operator=(m3x3);
00132         }
00133         
00134 
00135         inline Real* operator [] ( size_t iRow )
00136         {
00137             assert( iRow < 4 );
00138             return m[iRow];
00139         }
00140 
00141         inline const Real *const operator [] ( size_t iRow ) const
00142         {
00143             assert( iRow < 4 );
00144             return m[iRow];
00145         }
00146 
00147         inline Matrix4 concatenate(const Matrix4 &m2) const
00148         {
00149             Matrix4 r;
00150             r.m[0][0] = m[0][0] * m2.m[0][0] + m[0][1] * m2.m[1][0] + m[0][2] * m2.m[2][0] + m[0][3] * m2.m[3][0];
00151             r.m[0][1] = m[0][0] * m2.m[0][1] + m[0][1] * m2.m[1][1] + m[0][2] * m2.m[2][1] + m[0][3] * m2.m[3][1];
00152             r.m[0][2] = m[0][0] * m2.m[0][2] + m[0][1] * m2.m[1][2] + m[0][2] * m2.m[2][2] + m[0][3] * m2.m[3][2];
00153             r.m[0][3] = m[0][0] * m2.m[0][3] + m[0][1] * m2.m[1][3] + m[0][2] * m2.m[2][3] + m[0][3] * m2.m[3][3];
00154 
00155             r.m[1][0] = m[1][0] * m2.m[0][0] + m[1][1] * m2.m[1][0] + m[1][2] * m2.m[2][0] + m[1][3] * m2.m[3][0];
00156             r.m[1][1] = m[1][0] * m2.m[0][1] + m[1][1] * m2.m[1][1] + m[1][2] * m2.m[2][1] + m[1][3] * m2.m[3][1];
00157             r.m[1][2] = m[1][0] * m2.m[0][2] + m[1][1] * m2.m[1][2] + m[1][2] * m2.m[2][2] + m[1][3] * m2.m[3][2];
00158             r.m[1][3] = m[1][0] * m2.m[0][3] + m[1][1] * m2.m[1][3] + m[1][2] * m2.m[2][3] + m[1][3] * m2.m[3][3];
00159 
00160             r.m[2][0] = m[2][0] * m2.m[0][0] + m[2][1] * m2.m[1][0] + m[2][2] * m2.m[2][0] + m[2][3] * m2.m[3][0];
00161             r.m[2][1] = m[2][0] * m2.m[0][1] + m[2][1] * m2.m[1][1] + m[2][2] * m2.m[2][1] + m[2][3] * m2.m[3][1];
00162             r.m[2][2] = m[2][0] * m2.m[0][2] + m[2][1] * m2.m[1][2] + m[2][2] * m2.m[2][2] + m[2][3] * m2.m[3][2];
00163             r.m[2][3] = m[2][0] * m2.m[0][3] + m[2][1] * m2.m[1][3] + m[2][2] * m2.m[2][3] + m[2][3] * m2.m[3][3];
00164 
00165             r.m[3][0] = m[3][0] * m2.m[0][0] + m[3][1] * m2.m[1][0] + m[3][2] * m2.m[2][0] + m[3][3] * m2.m[3][0];
00166             r.m[3][1] = m[3][0] * m2.m[0][1] + m[3][1] * m2.m[1][1] + m[3][2] * m2.m[2][1] + m[3][3] * m2.m[3][1];
00167             r.m[3][2] = m[3][0] * m2.m[0][2] + m[3][1] * m2.m[1][2] + m[3][2] * m2.m[2][2] + m[3][3] * m2.m[3][2];
00168             r.m[3][3] = m[3][0] * m2.m[0][3] + m[3][1] * m2.m[1][3] + m[3][2] * m2.m[2][3] + m[3][3] * m2.m[3][3];
00169 
00170             return r;
00171         }
00172 
00175         inline Matrix4 operator * ( const Matrix4 &m2 ) const
00176         {
00177             return concatenate( m2 );
00178         }
00179 
00189         inline Vector3 operator * ( const Vector3 &v ) const
00190         {
00191             Vector3 r;
00192 
00193             Real fInvW = 1.0 / ( m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3] );
00194 
00195             r.x = ( m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] ) * fInvW;
00196             r.y = ( m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] ) * fInvW;
00197             r.z = ( m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] ) * fInvW;
00198 
00199             return r;
00200         }
00201         inline Vector4 operator * (const Vector4& v) const
00202         {
00203             return Vector4(
00204                 m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w, 
00205                 m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
00206                 m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
00207                 m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3] * v.w
00208                 );
00209         }
00210         inline Plane operator * (const Plane& p) const
00211         {
00212             Plane ret;
00213             Matrix4 invTrans = inverse().transpose();
00214             Vector4 v4( p.normal.x, p.normal.y, p.normal.z, p.d );
00215             v4 = invTrans * v4;
00216             ret.normal.x = v4.x; 
00217             ret.normal.y = v4.y; 
00218             ret.normal.z = v4.z;
00219             ret.d = v4.w / ret.normal.normalise();
00220 
00221             return ret;
00222         }
00223 
00224 
00227         inline Matrix4 operator + ( const Matrix4 &m2 ) const
00228         {
00229             Matrix4 r;
00230 
00231             r.m[0][0] = m[0][0] + m2.m[0][0];
00232             r.m[0][1] = m[0][1] + m2.m[0][1];
00233             r.m[0][2] = m[0][2] + m2.m[0][2];
00234             r.m[0][3] = m[0][3] + m2.m[0][3];
00235 
00236             r.m[1][0] = m[1][0] + m2.m[1][0];
00237             r.m[1][1] = m[1][1] + m2.m[1][1];
00238             r.m[1][2] = m[1][2] + m2.m[1][2];
00239             r.m[1][3] = m[1][3] + m2.m[1][3];
00240 
00241             r.m[2][0] = m[2][0] + m2.m[2][0];
00242             r.m[2][1] = m[2][1] + m2.m[2][1];
00243             r.m[2][2] = m[2][2] + m2.m[2][2];
00244             r.m[2][3] = m[2][3] + m2.m[2][3];
00245 
00246             r.m[3][0] = m[3][0] + m2.m[3][0];
00247             r.m[3][1] = m[3][1] + m2.m[3][1];
00248             r.m[3][2] = m[3][2] + m2.m[3][2];
00249             r.m[3][3] = m[3][3] + m2.m[3][3];
00250 
00251             return r;
00252         }
00253 
00256         inline Matrix4 operator - ( const Matrix4 &m2 ) const
00257         {
00258             Matrix4 r;
00259             r.m[0][0] = m[0][0] - m2.m[0][0];
00260             r.m[0][1] = m[0][1] - m2.m[0][1];
00261             r.m[0][2] = m[0][2] - m2.m[0][2];
00262             r.m[0][3] = m[0][3] - m2.m[0][3];
00263 
00264             r.m[1][0] = m[1][0] - m2.m[1][0];
00265             r.m[1][1] = m[1][1] - m2.m[1][1];
00266             r.m[1][2] = m[1][2] - m2.m[1][2];
00267             r.m[1][3] = m[1][3] - m2.m[1][3];
00268 
00269             r.m[2][0] = m[2][0] - m2.m[2][0];
00270             r.m[2][1] = m[2][1] - m2.m[2][1];
00271             r.m[2][2] = m[2][2] - m2.m[2][2];
00272             r.m[2][3] = m[2][3] - m2.m[2][3];
00273 
00274             r.m[3][0] = m[3][0] - m2.m[3][0];
00275             r.m[3][1] = m[3][1] - m2.m[3][1];
00276             r.m[3][2] = m[3][2] - m2.m[3][2];
00277             r.m[3][3] = m[3][3] - m2.m[3][3];
00278 
00279             return r;
00280         }
00281 
00284         inline bool operator == ( const Matrix4& m2 ) const
00285         {
00286             if( 
00287                 m[0][0] != m2.m[0][0] || m[0][1] != m2.m[0][1] || m[0][2] != m2.m[0][2] || m[0][3] != m2.m[0][3] ||
00288                 m[1][0] != m2.m[1][0] || m[1][1] != m2.m[1][1] || m[1][2] != m2.m[1][2] || m[1][3] != m2.m[1][3] ||
00289                 m[2][0] != m2.m[2][0] || m[2][1] != m2.m[2][1] || m[2][2] != m2.m[2][2] || m[2][3] != m2.m[2][3] ||
00290                 m[3][0] != m2.m[3][0] || m[3][1] != m2.m[3][1] || m[3][2] != m2.m[3][2] || m[3][3] != m2.m[3][3] )
00291                 return false;
00292             return true;
00293         }
00294 
00297         inline bool operator != ( const Matrix4& m2 ) const
00298         {
00299             if( 
00300                 m[0][0] != m2.m[0][0] || m[0][1] != m2.m[0][1] || m[0][2] != m2.m[0][2] || m[0][3] != m2.m[0][3] ||
00301                 m[1][0] != m2.m[1][0] || m[1][1] != m2.m[1][1] || m[1][2] != m2.m[1][2] || m[1][3] != m2.m[1][3] ||
00302                 m[2][0] != m2.m[2][0] || m[2][1] != m2.m[2][1] || m[2][2] != m2.m[2][2] || m[2][3] != m2.m[2][3] ||
00303                 m[3][0] != m2.m[3][0] || m[3][1] != m2.m[3][1] || m[3][2] != m2.m[3][2] || m[3][3] != m2.m[3][3] )
00304                 return true;
00305             return false;
00306         }
00307 
00310         inline void operator = ( const Matrix3& mat3 )
00311         {
00312             m[0][0] = mat3.m[0][0]; m[0][1] = mat3.m[0][1]; m[0][2] = mat3.m[0][2];
00313             m[1][0] = mat3.m[1][0]; m[1][1] = mat3.m[1][1]; m[1][2] = mat3.m[1][2];
00314             m[2][0] = mat3.m[2][0]; m[2][1] = mat3.m[2][1]; m[2][2] = mat3.m[2][2];
00315         }
00316 
00317         inline Matrix4 transpose(void) const
00318         {
00319             return Matrix4(m[0][0], m[1][0], m[2][0], m[3][0],
00320                            m[0][1], m[1][1], m[2][1], m[3][1],
00321                            m[0][2], m[1][2], m[2][2], m[3][2],
00322                            m[0][3], m[1][3], m[2][3], m[3][3]);
00323         }
00324 
00325         /*
00326         -----------------------------------------------------------------------
00327         Translation Transformation
00328         -----------------------------------------------------------------------
00329         */
00332         inline void setTrans( const Vector3& v )
00333         {
00334             m[0][3] = v.x;
00335             m[1][3] = v.y;
00336             m[2][3] = v.z;
00337         }
00338 
00341         inline Vector3 getTrans() const
00342         {
00343           return Vector3(m[0][3], m[1][3], m[2][3]);
00344         }
00345         
00346 
00349         inline void makeTrans( const Vector3& v )
00350         {
00351             m[0][0] = 1.0; m[0][1] = 0.0; m[0][2] = 0.0; m[0][3] = v.x;
00352             m[1][0] = 0.0; m[1][1] = 1.0; m[1][2] = 0.0; m[1][3] = v.y;
00353             m[2][0] = 0.0; m[2][1] = 0.0; m[2][2] = 1.0; m[2][3] = v.z;
00354             m[3][0] = 0.0; m[3][1] = 0.0; m[3][2] = 0.0; m[3][3] = 1.0;
00355         }
00356 
00357         inline void makeTrans( Real tx, Real ty, Real tz )
00358         {
00359             m[0][0] = 1.0; m[0][1] = 0.0; m[0][2] = 0.0; m[0][3] = tx;
00360             m[1][0] = 0.0; m[1][1] = 1.0; m[1][2] = 0.0; m[1][3] = ty;
00361             m[2][0] = 0.0; m[2][1] = 0.0; m[2][2] = 1.0; m[2][3] = tz;
00362             m[3][0] = 0.0; m[3][1] = 0.0; m[3][2] = 0.0; m[3][3] = 1.0;
00363         }
00364 
00367         inline static Matrix4 getTrans( const Vector3& v )
00368         {
00369             Matrix4 r;
00370 
00371             r.m[0][0] = 1.0; r.m[0][1] = 0.0; r.m[0][2] = 0.0; r.m[0][3] = v.x;
00372             r.m[1][0] = 0.0; r.m[1][1] = 1.0; r.m[1][2] = 0.0; r.m[1][3] = v.y;
00373             r.m[2][0] = 0.0; r.m[2][1] = 0.0; r.m[2][2] = 1.0; r.m[2][3] = v.z;
00374             r.m[3][0] = 0.0; r.m[3][1] = 0.0; r.m[3][2] = 0.0; r.m[3][3] = 1.0;
00375 
00376             return r;
00377         }
00378 
00381         inline static Matrix4 getTrans( Real t_x, Real t_y, Real t_z )
00382         {
00383             Matrix4 r;
00384 
00385             r.m[0][0] = 1.0; r.m[0][1] = 0.0; r.m[0][2] = 0.0; r.m[0][3] = t_x;
00386             r.m[1][0] = 0.0; r.m[1][1] = 1.0; r.m[1][2] = 0.0; r.m[1][3] = t_y;
00387             r.m[2][0] = 0.0; r.m[2][1] = 0.0; r.m[2][2] = 1.0; r.m[2][3] = t_z;
00388             r.m[3][0] = 0.0; r.m[3][1] = 0.0; r.m[3][2] = 0.0; r.m[3][3] = 1.0;
00389 
00390             return r;
00391         }
00392 
00393         /*
00394         -----------------------------------------------------------------------
00395         Scale Transformation
00396         -----------------------------------------------------------------------
00397         */
00400         inline void setScale( const Vector3& v )
00401         {
00402             m[0][0] = v.x;
00403             m[1][1] = v.y;
00404             m[2][2] = v.z;
00405         }
00406 
00409         inline static Matrix4 getScale( const Vector3& v )
00410         {
00411             Matrix4 r;
00412             r.m[0][0] = v.x; r.m[0][1] = 0.0; r.m[0][2] = 0.0; r.m[0][3] = 0.0;
00413             r.m[1][0] = 0.0; r.m[1][1] = v.y; r.m[1][2] = 0.0; r.m[1][3] = 0.0;
00414             r.m[2][0] = 0.0; r.m[2][1] = 0.0; r.m[2][2] = v.z; r.m[2][3] = 0.0;
00415             r.m[3][0] = 0.0; r.m[3][1] = 0.0; r.m[3][2] = 0.0; r.m[3][3] = 1.0;
00416 
00417             return r;
00418         }
00419 
00422         inline static Matrix4 getScale( Real s_x, Real s_y, Real s_z )
00423         {
00424             Matrix4 r;
00425             r.m[0][0] = s_x; r.m[0][1] = 0.0; r.m[0][2] = 0.0; r.m[0][3] = 0.0;
00426             r.m[1][0] = 0.0; r.m[1][1] = s_y; r.m[1][2] = 0.0; r.m[1][3] = 0.0;
00427             r.m[2][0] = 0.0; r.m[2][1] = 0.0; r.m[2][2] = s_z; r.m[2][3] = 0.0;
00428             r.m[3][0] = 0.0; r.m[3][1] = 0.0; r.m[3][2] = 0.0; r.m[3][3] = 1.0;
00429 
00430             return r;
00431         }
00432 
00436         inline void extract3x3Matrix(Matrix3& m3x3) const
00437         {
00438             m3x3.m[0][0] = m[0][0];
00439             m3x3.m[0][1] = m[0][1];
00440             m3x3.m[0][2] = m[0][2];
00441             m3x3.m[1][0] = m[1][0];
00442             m3x3.m[1][1] = m[1][1];
00443             m3x3.m[1][2] = m[1][2];
00444             m3x3.m[2][0] = m[2][0];
00445             m3x3.m[2][1] = m[2][1];
00446             m3x3.m[2][2] = m[2][2];
00447 
00448         }
00449 
00451         inline bool hasScale() const
00452         {
00453             // check magnitude of column vectors (==local axes)
00454             Real t = m[0][0] * m[0][0] + m[1][0] * m[1][0] + m[2][0] * m[2][0];
00455             if (!Math::RealEqual(t, 1.0, 1e-04))
00456                 return true;
00457             t = m[0][1] * m[0][1] + m[1][1] * m[1][1] + m[2][1] * m[2][1];
00458             if (!Math::RealEqual(t, 1.0, 1e-04))
00459                 return true;
00460             t = m[0][2] * m[0][2] + m[1][2] * m[1][2] + m[2][2] * m[2][2];
00461             if (!Math::RealEqual(t, 1.0, 1e-04))
00462                 return true;
00463 
00464             return false;
00465         }
00466 
00468         inline bool hasNegativeScale() const
00469         {
00470             return determinant() < 0;
00471         }
00472 
00475         inline Quaternion extractQuaternion() const
00476         {
00477           Matrix3 m3x3;
00478           extract3x3Matrix(m3x3);
00479           return Quaternion(m3x3);
00480         }
00481 
00482         static const Matrix4 ZERO;
00483         static const Matrix4 IDENTITY;
00486         static const Matrix4 CLIPSPACE2DTOIMAGESPACE;
00487 
00488         inline Matrix4 operator*(Real scalar) const
00489         {
00490             return Matrix4(
00491                 scalar*m[0][0], scalar*m[0][1], scalar*m[0][2], scalar*m[0][3],
00492                 scalar*m[1][0], scalar*m[1][1], scalar*m[1][2], scalar*m[1][3],
00493                 scalar*m[2][0], scalar*m[2][1], scalar*m[2][2], scalar*m[2][3],
00494                 scalar*m[3][0], scalar*m[3][1], scalar*m[3][2], scalar*m[3][3]);
00495         }
00496 
00499         inline _OgreExport friend std::ostream& operator <<
00500             ( std::ostream& o, const Matrix4& m )
00501         {
00502             o << "Matrix4(";
00503             for (size_t i = 0; i < 4; ++i)
00504             {
00505                 o << " row" << (unsigned)i << "{";
00506                 for(size_t j = 0; j < 4; ++j)
00507                 {
00508                     o << m[i][j] << " ";
00509                 }
00510                 o << "}";
00511             }
00512             o << ")";
00513             return o;
00514         }
00515         
00516         Matrix4 adjoint() const;
00517         Real determinant() const;
00518         Matrix4 inverse() const;
00519 
00526         void makeTransform(const Vector3& position, const Vector3& scale, const Quaternion& orientation);
00527 
00533         void makeInverseTransform(const Vector3& position, const Vector3& scale, const Quaternion& orientation);
00534 
00540         inline bool isAffine(void) const
00541         {
00542             return m[3][0] == 0 && m[3][1] == 0 && m[3][2] == 0 && m[3][3] == 1;
00543         }
00544 
00549         Matrix4 inverseAffine(void) const;
00550 
00555         inline Matrix4 concatenateAffine(const Matrix4 &m2) const
00556         {
00557             assert(isAffine() && m2.isAffine());
00558 
00559             return Matrix4(
00560                 m[0][0] * m2.m[0][0] + m[0][1] * m2.m[1][0] + m[0][2] * m2.m[2][0],
00561                 m[0][0] * m2.m[0][1] + m[0][1] * m2.m[1][1] + m[0][2] * m2.m[2][1],
00562                 m[0][0] * m2.m[0][2] + m[0][1] * m2.m[1][2] + m[0][2] * m2.m[2][2],
00563                 m[0][0] * m2.m[0][3] + m[0][1] * m2.m[1][3] + m[0][2] * m2.m[2][3] + m[0][3],
00564 
00565                 m[1][0] * m2.m[0][0] + m[1][1] * m2.m[1][0] + m[1][2] * m2.m[2][0],
00566                 m[1][0] * m2.m[0][1] + m[1][1] * m2.m[1][1] + m[1][2] * m2.m[2][1],
00567                 m[1][0] * m2.m[0][2] + m[1][1] * m2.m[1][2] + m[1][2] * m2.m[2][2],
00568                 m[1][0] * m2.m[0][3] + m[1][1] * m2.m[1][3] + m[1][2] * m2.m[2][3] + m[1][3],
00569 
00570                 m[2][0] * m2.m[0][0] + m[2][1] * m2.m[1][0] + m[2][2] * m2.m[2][0],
00571                 m[2][0] * m2.m[0][1] + m[2][1] * m2.m[1][1] + m[2][2] * m2.m[2][1],
00572                 m[2][0] * m2.m[0][2] + m[2][1] * m2.m[1][2] + m[2][2] * m2.m[2][2],
00573                 m[2][0] * m2.m[0][3] + m[2][1] * m2.m[1][3] + m[2][2] * m2.m[2][3] + m[2][3],
00574 
00575                 0, 0, 0, 1);
00576         }
00577 
00585         inline Vector3 transformAffine(const Vector3& v) const
00586         {
00587             assert(isAffine());
00588 
00589             return Vector3(
00590                     m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3], 
00591                     m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3],
00592                     m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3]);
00593         }
00594 
00599         inline Vector4 transformAffine(const Vector4& v) const
00600         {
00601             assert(isAffine());
00602 
00603             return Vector4(
00604                 m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w, 
00605                 m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
00606                 m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
00607                 v.w);
00608         }
00609     };
00610 
00611     /* Removed from Vector4 and made a non-member here because otherwise
00612        OgreMatrix4.h and OgreVector4.h have to try to include and inline each 
00613        other, which frankly doesn't work ;)
00614    */
00615     inline Vector4 operator * (const Vector4& v, const Matrix4& mat)
00616     {
00617         return Vector4(
00618             v.x*mat[0][0] + v.y*mat[1][0] + v.z*mat[2][0] + v.w*mat[3][0],
00619             v.x*mat[0][1] + v.y*mat[1][1] + v.z*mat[2][1] + v.w*mat[3][1],
00620             v.x*mat[0][2] + v.y*mat[1][2] + v.z*mat[2][2] + v.w*mat[3][2],
00621             v.x*mat[0][3] + v.y*mat[1][3] + v.z*mat[2][3] + v.w*mat[3][3]
00622             );
00623     }
00624 
00625 }
00626 #endif

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Sep 27 22:02:24 2009