ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/OgreMatrix3.h

@@ -1,286 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef __Matrix3_H__
-#define __Matrix3_H__
-
-#include "OgrePrerequisites.h"
-
-#include "OgreVector3.h"
-
-// NB All code adapted from Wild Magic 0.2 Matrix math (free source code)
-// http://www.geometrictools.com/
-
-// NOTE.  The (x,y,z) coordinate system is assumed to be right-handed.
-// Coordinate axis rotation matrices are of the form
-//   RX =    1       0       0
-//           0     cos(t) -sin(t)
-//           0     sin(t)  cos(t)
-// where t > 0 indicates a counterclockwise rotation in the yz-plane
-//   RY =  cos(t)    0     sin(t)
-//           0       1       0
-//        -sin(t)    0     cos(t)
-// where t > 0 indicates a counterclockwise rotation in the zx-plane
-//   RZ =  cos(t) -sin(t)    0
-//         sin(t)  cos(t)    0
-//           0       0       1
-// where t > 0 indicates a counterclockwise rotation in the xy-plane.
-
-namespace Ogre
-{
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-	/** A 3x3 matrix which can represent rotations around axes.
-        @note
-            <b>All the code is adapted from the Wild Magic 0.2 Matrix
-            library (http://www.geometrictools.com/).</b>
-        @par
-            The coordinate system is assumed to be <b>right-handed</b>.
-    */
-    class _OgreExport Matrix3
-    {
-    public:
-        /** Default constructor.
-            @note
-                It does <b>NOT</b> initialize the matrix for efficiency.
-        */
-		inline Matrix3 () {}
-        inline explicit Matrix3 (const Real arr[3][3])
-		{
-			memcpy(m,arr,9*sizeof(Real));
-		}
-        inline Matrix3 (const Matrix3& rkMatrix)
-		{
-			memcpy(m,rkMatrix.m,9*sizeof(Real));
-		}
-        Matrix3 (Real fEntry00, Real fEntry01, Real fEntry02,
-                    Real fEntry10, Real fEntry11, Real fEntry12,
-                    Real fEntry20, Real fEntry21, Real fEntry22)
-		{
-			m[0][0] = fEntry00;
-			m[0][1] = fEntry01;
-			m[0][2] = fEntry02;
-			m[1][0] = fEntry10;
-			m[1][1] = fEntry11;
-			m[1][2] = fEntry12;
-			m[2][0] = fEntry20;
-			m[2][1] = fEntry21;
-			m[2][2] = fEntry22;
-		}
-
-		/** Exchange the contents of this matrix with another. 
-		*/
-		inline void swap(Matrix3& other)
-		{
-			std::swap(m[0][0], other.m[0][0]);
-			std::swap(m[0][1], other.m[0][1]);
-			std::swap(m[0][2], other.m[0][2]);
-			std::swap(m[1][0], other.m[1][0]);
-			std::swap(m[1][1], other.m[1][1]);
-			std::swap(m[1][2], other.m[1][2]);
-			std::swap(m[2][0], other.m[2][0]);
-			std::swap(m[2][1], other.m[2][1]);
-			std::swap(m[2][2], other.m[2][2]);
-		}
-
-        // member access, allows use of construct mat[r][c]
-        inline Real* operator[] (size_t iRow) const
-		{
-			return (Real*)m[iRow];
-		}
-        /*inline operator Real* ()
-		{
-			return (Real*)m[0];
-		}*/
-        Vector3 GetColumn (size_t iCol) const;
-        void SetColumn(size_t iCol, const Vector3& vec);
-        void FromAxes(const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis);
-
-        // assignment and comparison
-        inline Matrix3& operator= (const Matrix3& rkMatrix)
-		{
-			memcpy(m,rkMatrix.m,9*sizeof(Real));
-			return *this;
-		}
-
-        /** Tests 2 matrices for equality.
-         */
-        bool operator== (const Matrix3& rkMatrix) const;
-
-        /** Tests 2 matrices for inequality.
-         */
-        inline bool operator!= (const Matrix3& rkMatrix) const
-		{
-			return !operator==(rkMatrix);
-		}
-
-        // arithmetic operations
-        /** Matrix addition.
-         */
-        Matrix3 operator+ (const Matrix3& rkMatrix) const;
-
-        /** Matrix subtraction.
-         */
-        Matrix3 operator- (const Matrix3& rkMatrix) const;
-
-        /** Matrix concatenation using '*'.
-         */
-        Matrix3 operator* (const Matrix3& rkMatrix) const;
-        Matrix3 operator- () const;
-
-        /// Matrix * vector [3x3 * 3x1 = 3x1]
-        Vector3 operator* (const Vector3& rkVector) const;
-
-        /// Vector * matrix [1x3 * 3x3 = 1x3]
-        _OgreExport friend Vector3 operator* (const Vector3& rkVector,
-            const Matrix3& rkMatrix);
-
-        /// Matrix * scalar
-        Matrix3 operator* (Real fScalar) const;
-
-        /// Scalar * matrix
-        _OgreExport friend Matrix3 operator* (Real fScalar, const Matrix3& rkMatrix);
-
-        // utilities
-        Matrix3 Transpose () const;
-        bool Inverse (Matrix3& rkInverse, Real fTolerance = 1e-06) const;
-        Matrix3 Inverse (Real fTolerance = 1e-06) const;
-        Real Determinant () const;
-
-        // singular value decomposition
-        void SingularValueDecomposition (Matrix3& rkL, Vector3& rkS,
-            Matrix3& rkR) const;
-        void SingularValueComposition (const Matrix3& rkL,
-            const Vector3& rkS, const Matrix3& rkR);
-
-        /// Gram-Schmidt orthonormalization (applied to columns of rotation matrix)
-        void Orthonormalize ();
-
-        /// Orthogonal Q, diagonal D, upper triangular U stored as (u01,u02,u12)
-        void QDUDecomposition (Matrix3& rkQ, Vector3& rkD,
-            Vector3& rkU) const;
-
-        Real SpectralNorm () const;
-
-        // matrix must be orthonormal
-        void ToAngleAxis (Vector3& rkAxis, Radian& rfAngle) const;
-		inline void ToAngleAxis (Vector3& rkAxis, Degree& rfAngle) const {
-			Radian r;
-			ToAngleAxis ( rkAxis, r );
-			rfAngle = r;
-		}
-        void FromAngleAxis (const Vector3& rkAxis, const Radian& fRadians);
-
-        // The matrix must be orthonormal.  The decomposition is yaw*pitch*roll
-        // where yaw is rotation about the Up vector, pitch is rotation about the
-        // Right axis, and roll is rotation about the Direction axis.
-        bool ToEulerAnglesXYZ (Radian& rfYAngle, Radian& rfPAngle,
-            Radian& rfRAngle) const;
-        bool ToEulerAnglesXZY (Radian& rfYAngle, Radian& rfPAngle,
-            Radian& rfRAngle) const;
-        bool ToEulerAnglesYXZ (Radian& rfYAngle, Radian& rfPAngle,
-            Radian& rfRAngle) const;
-        bool ToEulerAnglesYZX (Radian& rfYAngle, Radian& rfPAngle,
-            Radian& rfRAngle) const;
-        bool ToEulerAnglesZXY (Radian& rfYAngle, Radian& rfPAngle,
-            Radian& rfRAngle) const;
-        bool ToEulerAnglesZYX (Radian& rfYAngle, Radian& rfPAngle,
-            Radian& rfRAngle) const;
-        void FromEulerAnglesXYZ (const Radian& fYAngle, const Radian& fPAngle, const Radian& fRAngle);
-        void FromEulerAnglesXZY (const Radian& fYAngle, const Radian& fPAngle, const Radian& fRAngle);
-        void FromEulerAnglesYXZ (const Radian& fYAngle, const Radian& fPAngle, const Radian& fRAngle);
-        void FromEulerAnglesYZX (const Radian& fYAngle, const Radian& fPAngle, const Radian& fRAngle);
-        void FromEulerAnglesZXY (const Radian& fYAngle, const Radian& fPAngle, const Radian& fRAngle);
-        void FromEulerAnglesZYX (const Radian& fYAngle, const Radian& fPAngle, const Radian& fRAngle);
-        /// Eigensolver, matrix must be symmetric
-        void EigenSolveSymmetric (Real afEigenvalue[3],
-            Vector3 akEigenvector[3]) const;
-
-        static void TensorProduct (const Vector3& rkU, const Vector3& rkV,
-            Matrix3& rkProduct);
-
-		/** Determines if this matrix involves a scaling. */
-		inline bool hasScale() const
-		{
-			// check magnitude of column vectors (==local axes)
-			Real t = m[0][0] * m[0][0] + m[1][0] * m[1][0] + m[2][0] * m[2][0];
-			if (!Math::RealEqual(t, 1.0, (Real)1e-04))
-				return true;
-			t = m[0][1] * m[0][1] + m[1][1] * m[1][1] + m[2][1] * m[2][1];
-			if (!Math::RealEqual(t, 1.0, (Real)1e-04))
-				return true;
-			t = m[0][2] * m[0][2] + m[1][2] * m[1][2] + m[2][2] * m[2][2];
-			if (!Math::RealEqual(t, 1.0, (Real)1e-04))
-				return true;
-
-			return false;
-		}
-
-		/** Function for writing to a stream.
-		*/
-		inline _OgreExport friend std::ostream& operator <<
-			( std::ostream& o, const Matrix3& mat )
-		{
-			o << "Matrix3(" << mat[0][0] << ", " << mat[0][1] << ", " << mat[0][2] << ", " 
-                            << mat[1][0] << ", " << mat[1][1] << ", " << mat[1][2] << ", " 
-                            << mat[2][0] << ", " << mat[2][1] << ", " << mat[2][2] << ")";
-			return o;
-		}
-
-        static const Real EPSILON;
-        static const Matrix3 ZERO;
-        static const Matrix3 IDENTITY;
-
-    protected:
-        // support for eigensolver
-        void Tridiagonal (Real afDiag[3], Real afSubDiag[3]);
-        bool QLAlgorithm (Real afDiag[3], Real afSubDiag[3]);
-
-        // support for singular value decomposition
-        static const Real msSvdEpsilon;
-        static const unsigned int msSvdMaxIterations;
-        static void Bidiagonalize (Matrix3& kA, Matrix3& kL,
-            Matrix3& kR);
-        static void GolubKahanStep (Matrix3& kA, Matrix3& kL,
-            Matrix3& kR);
-
-        // support for spectral norm
-        static Real MaxCubicRoot (Real afCoeff[3]);
-
-        Real m[3][3];
-
-        // for faster access
-        friend class Matrix4;
-    };
-	/** @} */
-	/** @} */
-}
-#endif

data/deps/include/OGRE/OgreMatrix4.h

@@ -1,660 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef __Matrix4__
-#define __Matrix4__
-
-// Precompiler options
-#include "OgrePrerequisites.h"
-
-#include "OgreVector3.h"
-#include "OgreMatrix3.h"
-#include "OgreVector4.h"
-#include "OgrePlane.h"
-namespace Ogre
-{
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-	/** Class encapsulating a standard 4x4 homogeneous matrix.
-        @remarks
-            OGRE uses column vectors when applying matrix multiplications,
-            This means a vector is represented as a single column, 4-row
-            matrix. This has the effect that the transformations implemented
-            by the matrices happens right-to-left e.g. if vector V is to be
-            transformed by M1 then M2 then M3, the calculation would be
-            M3 * M2 * M1 * V. The order that matrices are concatenated is
-            vital since matrix multiplication is not commutative, i.e. you
-            can get a different result if you concatenate in the wrong order.
-        @par
-            The use of column vectors and right-to-left ordering is the
-            standard in most mathematical texts, and is the same as used in
-            OpenGL. It is, however, the opposite of Direct3D, which has
-            inexplicably chosen to differ from the accepted standard and uses
-            row vectors and left-to-right matrix multiplication.
-        @par
-            OGRE deals with the differences between D3D and OpenGL etc.
-            internally when operating through different render systems. OGRE
-            users only need to conform to standard maths conventions, i.e.
-            right-to-left matrix multiplication, (OGRE transposes matrices it
-            passes to D3D to compensate).
-        @par
-            The generic form M * V which shows the layout of the matrix 
-            entries is shown below:
-            <pre>
-                [ m[0][0]  m[0][1]  m[0][2]  m[0][3] ]   {x}
-                | m[1][0]  m[1][1]  m[1][2]  m[1][3] | * {y}
-                | m[2][0]  m[2][1]  m[2][2]  m[2][3] |   {z}
-                [ m[3][0]  m[3][1]  m[3][2]  m[3][3] ]   {1}
-            </pre>
-    */
-    class _OgreExport Matrix4
-    {
-    protected:
-        /// The matrix entries, indexed by [row][col].
-        union {
-            Real m[4][4];
-            Real _m[16];
-        };
-    public:
-        /** Default constructor.
-            @note
-                It does <b>NOT</b> initialize the matrix for efficiency.
-        */
-        inline Matrix4()
-        {
-        }
-
-        inline Matrix4(
-            Real m00, Real m01, Real m02, Real m03,
-            Real m10, Real m11, Real m12, Real m13,
-            Real m20, Real m21, Real m22, Real m23,
-            Real m30, Real m31, Real m32, Real m33 )
-        {
-            m[0][0] = m00;
-            m[0][1] = m01;
-            m[0][2] = m02;
-            m[0][3] = m03;
-            m[1][0] = m10;
-            m[1][1] = m11;
-            m[1][2] = m12;
-            m[1][3] = m13;
-            m[2][0] = m20;
-            m[2][1] = m21;
-            m[2][2] = m22;
-            m[2][3] = m23;
-            m[3][0] = m30;
-            m[3][1] = m31;
-            m[3][2] = m32;
-            m[3][3] = m33;
-        }
-
-        /** Creates a standard 4x4 transformation matrix with a zero translation part from a rotation/scaling 3x3 matrix.
-         */
-
-        inline Matrix4(const Matrix3& m3x3)
-        {
-          operator=(IDENTITY);
-          operator=(m3x3);
-        }
-
-        /** Creates a standard 4x4 transformation matrix with a zero translation part from a rotation/scaling Quaternion.
-         */
-        
-        inline Matrix4(const Quaternion& rot)
-        {
-          Matrix3 m3x3;
-          rot.ToRotationMatrix(m3x3);
-          operator=(IDENTITY);
-          operator=(m3x3);
-        }
-        
-
-		/** Exchange the contents of this matrix with another. 
-		*/
-		inline void swap(Matrix4& other)
-		{
-			std::swap(m[0][0], other.m[0][0]);
-			std::swap(m[0][1], other.m[0][1]);
-			std::swap(m[0][2], other.m[0][2]);
-			std::swap(m[0][3], other.m[0][3]);
-			std::swap(m[1][0], other.m[1][0]);
-			std::swap(m[1][1], other.m[1][1]);
-			std::swap(m[1][2], other.m[1][2]);
-			std::swap(m[1][3], other.m[1][3]);
-			std::swap(m[2][0], other.m[2][0]);
-			std::swap(m[2][1], other.m[2][1]);
-			std::swap(m[2][2], other.m[2][2]);
-			std::swap(m[2][3], other.m[2][3]);
-			std::swap(m[3][0], other.m[3][0]);
-			std::swap(m[3][1], other.m[3][1]);
-			std::swap(m[3][2], other.m[3][2]);
-			std::swap(m[3][3], other.m[3][3]);
-		}
-
-		inline Real* operator [] ( size_t iRow )
-        {
-            assert( iRow < 4 );
-            return m[iRow];
-        }
-
-        inline const Real *operator [] ( size_t iRow ) const
-        {
-            assert( iRow < 4 );
-            return m[iRow];
-        }
-
-        inline Matrix4 concatenate(const Matrix4 &m2) const
-        {
-            Matrix4 r;
-            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];
-            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];
-            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];
-            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];
-
-            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];
-            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];
-            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];
-            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];
-
-            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];
-            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];
-            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];
-            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];
-
-            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];
-            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];
-            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];
-            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];
-
-            return r;
-        }
-
-        /** Matrix concatenation using '*'.
-        */
-        inline Matrix4 operator * ( const Matrix4 &m2 ) const
-        {
-            return concatenate( m2 );
-        }
-
-        /** Vector transformation using '*'.
-            @remarks
-                Transforms the given 3-D vector by the matrix, projecting the 
-                result back into <i>w</i> = 1.
-            @note
-                This means that the initial <i>w</i> is considered to be 1.0,
-                and then all the tree elements of the resulting 3-D vector are
-                divided by the resulting <i>w</i>.
-        */
-        inline Vector3 operator * ( const Vector3 &v ) const
-        {
-            Vector3 r;
-
-            Real fInvW = 1.0f / ( m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3] );
-
-            r.x = ( m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] ) * fInvW;
-            r.y = ( m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] ) * fInvW;
-            r.z = ( m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] ) * fInvW;
-
-            return r;
-        }
-        inline Vector4 operator * (const Vector4& v) const
-        {
-            return Vector4(
-                m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w, 
-                m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
-                m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
-                m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3] * v.w
-                );
-        }
-        inline Plane operator * (const Plane& p) const
-        {
-            Plane ret;
-			Matrix4 invTrans = inverse().transpose();
-			Vector4 v4( p.normal.x, p.normal.y, p.normal.z, p.d );
-			v4 = invTrans * v4;
-			ret.normal.x = v4.x; 
-			ret.normal.y = v4.y; 
-			ret.normal.z = v4.z;
-			ret.d = v4.w / ret.normal.normalise();
-
-            return ret;
-        }
-
-
-        /** Matrix addition.
-        */
-        inline Matrix4 operator + ( const Matrix4 &m2 ) const
-        {
-            Matrix4 r;
-
-            r.m[0][0] = m[0][0] + m2.m[0][0];
-            r.m[0][1] = m[0][1] + m2.m[0][1];
-            r.m[0][2] = m[0][2] + m2.m[0][2];
-            r.m[0][3] = m[0][3] + m2.m[0][3];
-
-            r.m[1][0] = m[1][0] + m2.m[1][0];
-            r.m[1][1] = m[1][1] + m2.m[1][1];
-            r.m[1][2] = m[1][2] + m2.m[1][2];
-            r.m[1][3] = m[1][3] + m2.m[1][3];
-
-            r.m[2][0] = m[2][0] + m2.m[2][0];
-            r.m[2][1] = m[2][1] + m2.m[2][1];
-            r.m[2][2] = m[2][2] + m2.m[2][2];
-            r.m[2][3] = m[2][3] + m2.m[2][3];
-
-            r.m[3][0] = m[3][0] + m2.m[3][0];
-            r.m[3][1] = m[3][1] + m2.m[3][1];
-            r.m[3][2] = m[3][2] + m2.m[3][2];
-            r.m[3][3] = m[3][3] + m2.m[3][3];
-
-            return r;
-        }
-
-        /** Matrix subtraction.
-        */
-        inline Matrix4 operator - ( const Matrix4 &m2 ) const
-        {
-            Matrix4 r;
-            r.m[0][0] = m[0][0] - m2.m[0][0];
-            r.m[0][1] = m[0][1] - m2.m[0][1];
-            r.m[0][2] = m[0][2] - m2.m[0][2];
-            r.m[0][3] = m[0][3] - m2.m[0][3];
-
-            r.m[1][0] = m[1][0] - m2.m[1][0];
-            r.m[1][1] = m[1][1] - m2.m[1][1];
-            r.m[1][2] = m[1][2] - m2.m[1][2];
-            r.m[1][3] = m[1][3] - m2.m[1][3];
-
-            r.m[2][0] = m[2][0] - m2.m[2][0];
-            r.m[2][1] = m[2][1] - m2.m[2][1];
-            r.m[2][2] = m[2][2] - m2.m[2][2];
-            r.m[2][3] = m[2][3] - m2.m[2][3];
-
-            r.m[3][0] = m[3][0] - m2.m[3][0];
-            r.m[3][1] = m[3][1] - m2.m[3][1];
-            r.m[3][2] = m[3][2] - m2.m[3][2];
-            r.m[3][3] = m[3][3] - m2.m[3][3];
-
-            return r;
-        }
-
-        /** Tests 2 matrices for equality.
-        */
-        inline bool operator == ( const Matrix4& m2 ) const
-        {
-            if( 
-                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] ||
-                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] ||
-                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] ||
-                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] )
-                return false;
-            return true;
-        }
-
-        /** Tests 2 matrices for inequality.
-        */
-        inline bool operator != ( const Matrix4& m2 ) const
-        {
-            if( 
-                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] ||
-                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] ||
-                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] ||
-                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] )
-                return true;
-            return false;
-        }
-
-        /** Assignment from 3x3 matrix.
-        */
-        inline void operator = ( const Matrix3& mat3 )
-        {
-            m[0][0] = mat3.m[0][0]; m[0][1] = mat3.m[0][1]; m[0][2] = mat3.m[0][2];
-            m[1][0] = mat3.m[1][0]; m[1][1] = mat3.m[1][1]; m[1][2] = mat3.m[1][2];
-            m[2][0] = mat3.m[2][0]; m[2][1] = mat3.m[2][1]; m[2][2] = mat3.m[2][2];
-        }
-
-        inline Matrix4 transpose(void) const
-        {
-            return Matrix4(m[0][0], m[1][0], m[2][0], m[3][0],
-                           m[0][1], m[1][1], m[2][1], m[3][1],
-                           m[0][2], m[1][2], m[2][2], m[3][2],
-                           m[0][3], m[1][3], m[2][3], m[3][3]);
-        }
-
-        /*
-        -----------------------------------------------------------------------
-        Translation Transformation
-        -----------------------------------------------------------------------
-        */
-        /** Sets the translation transformation part of the matrix.
-        */
-        inline void setTrans( const Vector3& v )
-        {
-            m[0][3] = v.x;
-            m[1][3] = v.y;
-            m[2][3] = v.z;
-        }
-
-        /** Extracts the translation transformation part of the matrix.
-         */
-        inline Vector3 getTrans() const
-        {
-          return Vector3(m[0][3], m[1][3], m[2][3]);
-        }
-        
-
-        /** Builds a translation matrix
-        */
-        inline void makeTrans( const Vector3& v )
-        {
-            m[0][0] = 1.0; m[0][1] = 0.0; m[0][2] = 0.0; m[0][3] = v.x;
-            m[1][0] = 0.0; m[1][1] = 1.0; m[1][2] = 0.0; m[1][3] = v.y;
-            m[2][0] = 0.0; m[2][1] = 0.0; m[2][2] = 1.0; m[2][3] = v.z;
-            m[3][0] = 0.0; m[3][1] = 0.0; m[3][2] = 0.0; m[3][3] = 1.0;
-        }
-
-        inline void makeTrans( Real tx, Real ty, Real tz )
-        {
-            m[0][0] = 1.0; m[0][1] = 0.0; m[0][2] = 0.0; m[0][3] = tx;
-            m[1][0] = 0.0; m[1][1] = 1.0; m[1][2] = 0.0; m[1][3] = ty;
-            m[2][0] = 0.0; m[2][1] = 0.0; m[2][2] = 1.0; m[2][3] = tz;
-            m[3][0] = 0.0; m[3][1] = 0.0; m[3][2] = 0.0; m[3][3] = 1.0;
-        }
-
-        /** Gets a translation matrix.
-        */
-        inline static Matrix4 getTrans( const Vector3& v )
-        {
-            Matrix4 r;
-
-            r.m[0][0] = 1.0; r.m[0][1] = 0.0; r.m[0][2] = 0.0; r.m[0][3] = v.x;
-            r.m[1][0] = 0.0; r.m[1][1] = 1.0; r.m[1][2] = 0.0; r.m[1][3] = v.y;
-            r.m[2][0] = 0.0; r.m[2][1] = 0.0; r.m[2][2] = 1.0; r.m[2][3] = v.z;
-            r.m[3][0] = 0.0; r.m[3][1] = 0.0; r.m[3][2] = 0.0; r.m[3][3] = 1.0;
-
-            return r;
-        }
-
-        /** Gets a translation matrix - variation for not using a vector.
-        */
-        inline static Matrix4 getTrans( Real t_x, Real t_y, Real t_z )
-        {
-            Matrix4 r;
-
-            r.m[0][0] = 1.0; r.m[0][1] = 0.0; r.m[0][2] = 0.0; r.m[0][3] = t_x;
-            r.m[1][0] = 0.0; r.m[1][1] = 1.0; r.m[1][2] = 0.0; r.m[1][3] = t_y;
-            r.m[2][0] = 0.0; r.m[2][1] = 0.0; r.m[2][2] = 1.0; r.m[2][3] = t_z;
-            r.m[3][0] = 0.0; r.m[3][1] = 0.0; r.m[3][2] = 0.0; r.m[3][3] = 1.0;
-
-            return r;
-        }
-
-        /*
-        -----------------------------------------------------------------------
-        Scale Transformation
-        -----------------------------------------------------------------------
-        */
-        /** Sets the scale part of the matrix.
-        */
-        inline void setScale( const Vector3& v )
-        {
-            m[0][0] = v.x;
-            m[1][1] = v.y;
-            m[2][2] = v.z;
-        }
-
-        /** Gets a scale matrix.
-        */
-        inline static Matrix4 getScale( const Vector3& v )
-        {
-            Matrix4 r;
-            r.m[0][0] = v.x; r.m[0][1] = 0.0; r.m[0][2] = 0.0; r.m[0][3] = 0.0;
-            r.m[1][0] = 0.0; r.m[1][1] = v.y; r.m[1][2] = 0.0; r.m[1][3] = 0.0;
-            r.m[2][0] = 0.0; r.m[2][1] = 0.0; r.m[2][2] = v.z; r.m[2][3] = 0.0;
-            r.m[3][0] = 0.0; r.m[3][1] = 0.0; r.m[3][2] = 0.0; r.m[3][3] = 1.0;
-
-            return r;
-        }
-
-        /** Gets a scale matrix - variation for not using a vector.
-        */
-        inline static Matrix4 getScale( Real s_x, Real s_y, Real s_z )
-        {
-            Matrix4 r;
-            r.m[0][0] = s_x; r.m[0][1] = 0.0; r.m[0][2] = 0.0; r.m[0][3] = 0.0;
-            r.m[1][0] = 0.0; r.m[1][1] = s_y; r.m[1][2] = 0.0; r.m[1][3] = 0.0;
-            r.m[2][0] = 0.0; r.m[2][1] = 0.0; r.m[2][2] = s_z; r.m[2][3] = 0.0;
-            r.m[3][0] = 0.0; r.m[3][1] = 0.0; r.m[3][2] = 0.0; r.m[3][3] = 1.0;
-
-            return r;
-        }
-
-        /** Extracts the rotation / scaling part of the Matrix as a 3x3 matrix. 
-        @param m3x3 Destination Matrix3
-        */
-        inline void extract3x3Matrix(Matrix3& m3x3) const
-        {
-            m3x3.m[0][0] = m[0][0];
-            m3x3.m[0][1] = m[0][1];
-            m3x3.m[0][2] = m[0][2];
-            m3x3.m[1][0] = m[1][0];
-            m3x3.m[1][1] = m[1][1];
-            m3x3.m[1][2] = m[1][2];
-            m3x3.m[2][0] = m[2][0];
-            m3x3.m[2][1] = m[2][1];
-            m3x3.m[2][2] = m[2][2];
-
-        }
-
-		/** Determines if this matrix involves a scaling. */
-		inline bool hasScale() const
-		{
-			// check magnitude of column vectors (==local axes)
-			Real t = m[0][0] * m[0][0] + m[1][0] * m[1][0] + m[2][0] * m[2][0];
-			if (!Math::RealEqual(t, 1.0, (Real)1e-04))
-				return true;
-			t = m[0][1] * m[0][1] + m[1][1] * m[1][1] + m[2][1] * m[2][1];
-			if (!Math::RealEqual(t, 1.0, (Real)1e-04))
-				return true;
-			t = m[0][2] * m[0][2] + m[1][2] * m[1][2] + m[2][2] * m[2][2];
-			if (!Math::RealEqual(t, 1.0, (Real)1e-04))
-				return true;
-
-			return false;
-		}
-
-		/** Determines if this matrix involves a negative scaling. */
-		inline bool hasNegativeScale() const
-		{
-			return determinant() < 0;
-		}
-
-		/** Extracts the rotation / scaling part as a quaternion from the Matrix.
-         */
-        inline Quaternion extractQuaternion() const
-        {
-          Matrix3 m3x3;
-          extract3x3Matrix(m3x3);
-          return Quaternion(m3x3);
-        }
-
-	static const Matrix4 ZERO;
-	static const Matrix4 ZEROAFFINE;
-	static const Matrix4 IDENTITY;
-        /** Useful little matrix which takes 2D clipspace {-1, 1} to {0,1}
-            and inverts the Y. */
-        static const Matrix4 CLIPSPACE2DTOIMAGESPACE;
-
-        inline Matrix4 operator*(Real scalar) const
-        {
-            return Matrix4(
-                scalar*m[0][0], scalar*m[0][1], scalar*m[0][2], scalar*m[0][3],
-                scalar*m[1][0], scalar*m[1][1], scalar*m[1][2], scalar*m[1][3],
-                scalar*m[2][0], scalar*m[2][1], scalar*m[2][2], scalar*m[2][3],
-                scalar*m[3][0], scalar*m[3][1], scalar*m[3][2], scalar*m[3][3]);
-        }
-
-        /** Function for writing to a stream.
-        */
-        inline _OgreExport friend std::ostream& operator <<
-            ( std::ostream& o, const Matrix4& mat )
-        {
-            o << "Matrix4(";
-			for (size_t i = 0; i < 4; ++i)
-            {
-                o << " row" << (unsigned)i << "{";
-                for(size_t j = 0; j < 4; ++j)
-                {
-                    o << mat[i][j] << " ";
-                }
-                o << "}";
-            }
-            o << ")";
-            return o;
-        }
-		
-		Matrix4 adjoint() const;
-		Real determinant() const;
-		Matrix4 inverse() const;
-
-        /** Building a Matrix4 from orientation / scale / position.
-        @remarks
-            Transform is performed in the order scale, rotate, translation, i.e. translation is independent
-            of orientation axes, scale does not affect size of translation, rotation and scaling are always
-            centered on the origin.
-        */
-        void makeTransform(const Vector3& position, const Vector3& scale, const Quaternion& orientation);
-
-        /** Building an inverse Matrix4 from orientation / scale / position.
-        @remarks
-            As makeTransform except it build the inverse given the same data as makeTransform, so
-            performing -translation, -rotate, 1/scale in that order.
-        */
-        void makeInverseTransform(const Vector3& position, const Vector3& scale, const Quaternion& orientation);
-
-        /** Decompose a Matrix4 to orientation / scale / position.
-        */
-        void decomposition(Vector3& position, Vector3& scale, Quaternion& orientation) const;
-
-        /** Check whether or not the matrix is affine matrix.
-            @remarks
-                An affine matrix is a 4x4 matrix with row 3 equal to (0, 0, 0, 1),
-                e.g. no projective coefficients.
-        */
-        inline bool isAffine(void) const
-        {
-            return m[3][0] == 0 && m[3][1] == 0 && m[3][2] == 0 && m[3][3] == 1;
-        }
-
-        /** Returns the inverse of the affine matrix.
-            @note
-                The matrix must be an affine matrix. @see Matrix4::isAffine.
-        */
-        Matrix4 inverseAffine(void) const;
-
-        /** Concatenate two affine matrices.
-            @note
-                The matrices must be affine matrix. @see Matrix4::isAffine.
-        */
-        inline Matrix4 concatenateAffine(const Matrix4 &m2) const
-        {
-            assert(isAffine() && m2.isAffine());
-
-            return Matrix4(
-                m[0][0] * m2.m[0][0] + m[0][1] * m2.m[1][0] + m[0][2] * m2.m[2][0],
-                m[0][0] * m2.m[0][1] + m[0][1] * m2.m[1][1] + m[0][2] * m2.m[2][1],
-                m[0][0] * m2.m[0][2] + m[0][1] * m2.m[1][2] + m[0][2] * m2.m[2][2],
-                m[0][0] * m2.m[0][3] + m[0][1] * m2.m[1][3] + m[0][2] * m2.m[2][3] + m[0][3],
-
-                m[1][0] * m2.m[0][0] + m[1][1] * m2.m[1][0] + m[1][2] * m2.m[2][0],
-                m[1][0] * m2.m[0][1] + m[1][1] * m2.m[1][1] + m[1][2] * m2.m[2][1],
-                m[1][0] * m2.m[0][2] + m[1][1] * m2.m[1][2] + m[1][2] * m2.m[2][2],
-                m[1][0] * m2.m[0][3] + m[1][1] * m2.m[1][3] + m[1][2] * m2.m[2][3] + m[1][3],
-
-                m[2][0] * m2.m[0][0] + m[2][1] * m2.m[1][0] + m[2][2] * m2.m[2][0],
-                m[2][0] * m2.m[0][1] + m[2][1] * m2.m[1][1] + m[2][2] * m2.m[2][1],
-                m[2][0] * m2.m[0][2] + m[2][1] * m2.m[1][2] + m[2][2] * m2.m[2][2],
-                m[2][0] * m2.m[0][3] + m[2][1] * m2.m[1][3] + m[2][2] * m2.m[2][3] + m[2][3],
-
-                0, 0, 0, 1);
-        }
-
-        /** 3-D Vector transformation specially for an affine matrix.
-            @remarks
-                Transforms the given 3-D vector by the matrix, projecting the 
-                result back into <i>w</i> = 1.
-            @note
-                The matrix must be an affine matrix. @see Matrix4::isAffine.
-        */
-        inline Vector3 transformAffine(const Vector3& v) const
-        {
-            assert(isAffine());
-
-            return Vector3(
-                    m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3], 
-                    m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3],
-                    m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3]);
-        }
-
-        /** 4-D Vector transformation specially for an affine matrix.
-            @note
-                The matrix must be an affine matrix. @see Matrix4::isAffine.
-        */
-        inline Vector4 transformAffine(const Vector4& v) const
-        {
-            assert(isAffine());
-
-            return Vector4(
-                m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w, 
-                m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
-                m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
-                v.w);
-        }
-    };
-
-    /* Removed from Vector4 and made a non-member here because otherwise
-       OgreMatrix4.h and OgreVector4.h have to try to include and inline each 
-       other, which frankly doesn't work ;)
-   */
-    inline Vector4 operator * (const Vector4& v, const Matrix4& mat)
-    {
-        return Vector4(
-            v.x*mat[0][0] + v.y*mat[1][0] + v.z*mat[2][0] + v.w*mat[3][0],
-            v.x*mat[0][1] + v.y*mat[1][1] + v.z*mat[2][1] + v.w*mat[3][1],
-            v.x*mat[0][2] + v.y*mat[1][2] + v.z*mat[2][2] + v.w*mat[3][2],
-            v.x*mat[0][3] + v.y*mat[1][3] + v.z*mat[2][3] + v.w*mat[3][3]
-            );
-    }
-	/** @} */
-	/** @} */
-
-}
-#endif