Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

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 
00452         inline Quaternion extractQuaternion() const
00453         {
00454           Matrix3 m3x3;
00455           extract3x3Matrix(m3x3);
00456           return Quaternion(m3x3);
00457         }
00458 
00459         static const Matrix4 ZERO;
00460         static const Matrix4 IDENTITY;
00463         static const Matrix4 CLIPSPACE2DTOIMAGESPACE;
00464 
00465         inline Matrix4 operator*(Real scalar) const
00466         {
00467             return Matrix4(
00468                 scalar*m[0][0], scalar*m[0][1], scalar*m[0][2], scalar*m[0][3],
00469                 scalar*m[1][0], scalar*m[1][1], scalar*m[1][2], scalar*m[1][3],
00470                 scalar*m[2][0], scalar*m[2][1], scalar*m[2][2], scalar*m[2][3],
00471                 scalar*m[3][0], scalar*m[3][1], scalar*m[3][2], scalar*m[3][3]);
00472         }
00473 
00476         inline _OgreExport friend std::ostream& operator <<
00477             ( std::ostream& o, const Matrix4& m )
00478         {
00479             o << "Matrix4(";
00480             for (size_t i = 0; i < 4; ++i)
00481             {
00482                 o << " row" << (unsigned)i << "{";
00483                 for(size_t j = 0; j < 4; ++j)
00484                 {
00485                     o << m[i][j] << " ";
00486                 }
00487                 o << "}";
00488             }
00489             o << ")";
00490             return o;
00491         }
00492         
00493         Matrix4 adjoint() const;
00494         Real determinant() const;
00495         Matrix4 inverse() const;
00496 
00503         void makeTransform(const Vector3& position, const Vector3& scale, const Quaternion& orientation);
00504 
00510         void makeInverseTransform(const Vector3& position, const Vector3& scale, const Quaternion& orientation);
00511 
00517         inline bool isAffine(void) const
00518         {
00519             return m[3][0] == 0 && m[3][1] == 0 && m[3][2] == 0 && m[3][3] == 1;
00520         }
00521 
00526         Matrix4 inverseAffine(void) const;
00527 
00532         inline Matrix4 concatenateAffine(const Matrix4 &m2) const
00533         {
00534             assert(isAffine() && m2.isAffine());
00535 
00536             return Matrix4(
00537                 m[0][0] * m2.m[0][0] + m[0][1] * m2.m[1][0] + m[0][2] * m2.m[2][0],
00538                 m[0][0] * m2.m[0][1] + m[0][1] * m2.m[1][1] + m[0][2] * m2.m[2][1],
00539                 m[0][0] * m2.m[0][2] + m[0][1] * m2.m[1][2] + m[0][2] * m2.m[2][2],
00540                 m[0][0] * m2.m[0][3] + m[0][1] * m2.m[1][3] + m[0][2] * m2.m[2][3] + m[0][3],
00541 
00542                 m[1][0] * m2.m[0][0] + m[1][1] * m2.m[1][0] + m[1][2] * m2.m[2][0],
00543                 m[1][0] * m2.m[0][1] + m[1][1] * m2.m[1][1] + m[1][2] * m2.m[2][1],
00544                 m[1][0] * m2.m[0][2] + m[1][1] * m2.m[1][2] + m[1][2] * m2.m[2][2],
00545                 m[1][0] * m2.m[0][3] + m[1][1] * m2.m[1][3] + m[1][2] * m2.m[2][3] + m[1][3],
00546 
00547                 m[2][0] * m2.m[0][0] + m[2][1] * m2.m[1][0] + m[2][2] * m2.m[2][0],
00548                 m[2][0] * m2.m[0][1] + m[2][1] * m2.m[1][1] + m[2][2] * m2.m[2][1],
00549                 m[2][0] * m2.m[0][2] + m[2][1] * m2.m[1][2] + m[2][2] * m2.m[2][2],
00550                 m[2][0] * m2.m[0][3] + m[2][1] * m2.m[1][3] + m[2][2] * m2.m[2][3] + m[2][3],
00551 
00552                 0, 0, 0, 1);
00553         }
00554 
00562         inline Vector3 transformAffine(const Vector3& v) const
00563         {
00564             assert(isAffine());
00565 
00566             return Vector3(
00567                     m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3], 
00568                     m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3],
00569                     m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3]);
00570         }
00571 
00576         inline Vector4 transformAffine(const Vector4& v) const
00577         {
00578             assert(isAffine());
00579 
00580             return Vector4(
00581                 m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w, 
00582                 m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
00583                 m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
00584                 v.w);
00585         }
00586     };
00587 
00588     /* Removed from Vector4 and made a non-member here because otherwise
00589        OgreMatrix4.h and OgreVector4.h have to try to include and inline each 
00590        other, which frankly doesn't work ;)
00591    */
00592     inline Vector4 operator * (const Vector4& v, const Matrix4& mat)
00593     {
00594         return Vector4(
00595             v.x*mat[0][0] + v.y*mat[1][0] + v.z*mat[2][0] + v.w*mat[3][0],
00596             v.x*mat[0][1] + v.y*mat[1][1] + v.z*mat[2][1] + v.w*mat[3][1],
00597             v.x*mat[0][2] + v.y*mat[1][2] + v.z*mat[2][2] + v.w*mat[3][2],
00598             v.x*mat[0][3] + v.y*mat[1][3] + v.z*mat[2][3] + v.w*mat[3][3]
00599             );
00600     }
00601 
00602 }
00603 #endif

Copyright © 2000-2005 by The OGRE Team
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 25 13:03:15 2007