Matrix4f.h

Go to the documentation of this file.

//    Copyright 2004, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//

#ifndef __MATRIX4F_H__
#define __MATRIX4F_H__

#include "H3DApi.h"
#include "H3DBasicTypes.h"
#include "Vec4f.h"
#include "H3DTemplateOperators.h"
#include "Exception.h"
#include "Matrix3f.h"

namespace H3D {
  namespace ArithmeticTypes {
    class Quaternion;
    class Rotation;
    class Matrix4d;
    
    class H3DAPI_API Matrix4f {
    public:
      H3D_API_EXCEPTION( SingularMatrix4f );

      inline Matrix4f() { setToIdentity(); }
      
      inline Matrix4f( H3DFloat m00, H3DFloat m01, 
                       H3DFloat m02, H3DFloat m03,
                       H3DFloat m10, H3DFloat m11, 
                       H3DFloat m12, H3DFloat m13,
                       H3DFloat m20, H3DFloat m21, 
                       H3DFloat m22, H3DFloat m23,
                       H3DFloat m30, H3DFloat m31, 
                       H3DFloat m32, H3DFloat 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; 
      }
                                
      Matrix4f( const Rotation &r );

      Matrix4f( const Quaternion &q );

      explicit Matrix4f( const Matrix3f &m );

      explicit Matrix4f( const Matrix4d &m );

      inline void setToIdentity() {
        m[0][0] = 1; m[0][1] = 0; m[0][2] = 0; m[0][3] = 0;
        m[1][0] = 0; m[1][1] = 1; m[1][2] = 0; m[1][3] = 0;
        m[2][0] = 0; m[2][1] = 0; m[2][2] = 1; m[2][3] = 0;
        m[3][0] = 0; m[3][1] = 0; m[3][2] = 0; m[3][3] = 1;
      }
                        
      Matrix4f transformInverse() const;
        
      inline Matrix4f transpose() const {
        return Matrix4f( 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] );
      };

      Matrix4f inverse() const;

      inline H3DFloat* operator[]( const int i ) { return m[i]; }
                                
      inline const H3DFloat* operator[]( const int i ) const { return m[i]; }

      inline Vec4f getRow( int i ) const { 
        return Vec4f( m[i][0], m[i][1], m[i][2], m[i][3] ); 
      }

      inline Vec4f getColumn( int i ) const { 
        return Vec4f( m[0][i], m[1][i], m[2][i], m[3][i] ); 
      }

      inline H3DFloat getElement( int i, int j ) const { 
        return m[i][j];
      }

      inline void setElement( int i, int j, H3DFloat v )  { 
        m[i][j] = v;
      }

                        inline Matrix3f getScaleRotationPart() const {
                                return Matrix3f( m[0][0], m[0][1], m[0][2],
                                                                                                 m[1][0], m[1][1], m[1][2],
                                                                                                 m[2][0], m[2][1], m[2][2] );
                        }

      inline Vec3f getScalePart() const {
        return getScaleRotationPart().getScalePart();
      }

                        Matrix3f getRotationPart() const;

    private:
      H3DFloat m[4][4];
    };


    inline Matrix4f operator*( const Matrix4f &m1, const Matrix4f &m2 ) {
      return Matrix4f( 
  m1[0][0]*m2[0][0] + m1[0][1]*m2[1][0] + m1[0][2]*m2[2][0] + m1[0][3]*m2[3][0],
  m1[0][0]*m2[0][1] + m1[0][1]*m2[1][1] + m1[0][2]*m2[2][1] + m1[0][3]*m2[3][1],
  m1[0][0]*m2[0][2] + m1[0][1]*m2[1][2] + m1[0][2]*m2[2][2] + m1[0][3]*m2[3][2],
  m1[0][0]*m2[0][3] + m1[0][1]*m2[1][3] + m1[0][2]*m2[2][3] + m1[0][3]*m2[3][3],
  
  m1[1][0]*m2[0][0] + m1[1][1]*m2[1][0] + m1[1][2]*m2[2][0] + m1[1][3]*m2[3][0],
  m1[1][0]*m2[0][1] + m1[1][1]*m2[1][1] + m1[1][2]*m2[2][1] + m1[1][3]*m2[3][1],
  m1[1][0]*m2[0][2] + m1[1][1]*m2[1][2] + m1[1][2]*m2[2][2] + m1[1][3]*m2[3][2],
  m1[1][0]*m2[0][3] + m1[1][1]*m2[1][3] + m1[1][2]*m2[2][3] + m1[1][3]*m2[3][3],
  
  m1[2][0]*m2[0][0] + m1[2][1]*m2[1][0] + m1[2][2]*m2[2][0] + m1[2][3]*m2[3][0],
  m1[2][0]*m2[0][1] + m1[2][1]*m2[1][1] + m1[2][2]*m2[2][1] + m1[2][3]*m2[3][1],
  m1[2][0]*m2[0][2] + m1[2][1]*m2[1][2] + m1[2][2]*m2[2][2] + m1[2][3]*m2[3][2],
  m1[2][0]*m2[0][3] + m1[2][1]*m2[1][3] + m1[2][2]*m2[2][3] + m1[2][3]*m2[3][3],
  
  m1[3][0]*m2[0][0] + m1[3][1]*m2[1][0] + m1[3][2]*m2[2][0] + m1[3][3]*m2[3][0],
  m1[3][0]*m2[0][1] + m1[3][1]*m2[1][1] + m1[3][2]*m2[2][1] + m1[3][3]*m2[3][1],
  m1[3][0]*m2[0][2] + m1[3][1]*m2[1][2] + m1[3][2]*m2[2][2] + m1[3][3]*m2[3][2],
  m1[3][0]*m2[0][3] + m1[3][1]*m2[1][3] + m1[3][2]*m2[2][3] + m1[3][3]*m2[3][3]
  );
    }

    inline Matrix4f operator+( const Matrix4f &m1, const Matrix4f &m2 ) {
      return Matrix4f( 
  m1[0][0]+m2[0][0], m1[0][1]+m2[0][1], m1[0][2]+m2[0][2], m1[0][3]+m2[0][3],
  m1[1][0]+m2[1][0], m1[1][1]+m2[1][1], m1[1][2]+m2[1][2], m1[1][3]+m2[1][3],
  m1[2][0]+m2[2][0], m1[2][1]+m2[2][1], m1[2][2]+m2[2][2], m1[2][3]+m2[2][3],
  m1[3][0]+m2[3][0], m1[3][1]+m2[3][1], m1[3][2]+m2[3][2], m1[3][3]+m2[3][3] );
    }
    
    inline Matrix4f operator*( const Matrix4f &m, const float &f ) {
      return Matrix4f( m[0][0]*f, m[0][1]*f, m[0][2]*f, m[0][3]*f,
                       m[1][0]*f, m[1][1]*f, m[1][2]*f, m[1][3]*f,
                       m[2][0]*f, m[2][1]*f, m[2][2]*f, m[2][3]*f,
                       m[3][0]*f, m[3][1]*f, m[3][2]*f, m[3][3]*f );
    }
    inline Matrix4f operator*( const Matrix4f &m, const double &d ) {
      return Matrix4f( (H3DFloat)(m[0][0]*d), (H3DFloat)(m[0][1]*d), (H3DFloat)(m[0][2]*d), (H3DFloat)(m[0][3]*d),
                       (H3DFloat)(m[1][0]*d), (H3DFloat)(m[1][1]*d), (H3DFloat)(m[1][2]*d), (H3DFloat)(m[1][3]*d),
                       (H3DFloat)(m[2][0]*d), (H3DFloat)(m[2][1]*d), (H3DFloat)(m[2][2]*d), (H3DFloat)(m[2][3]*d),
                       (H3DFloat)(m[3][0]*d), (H3DFloat)(m[3][1]*d), (H3DFloat)(m[3][2]*d), (H3DFloat)(m[3][3]*d) );
    }

    inline Matrix4f operator*( const Matrix4f &m, const int &f ) {
      return Matrix4f( m[0][0]*f, m[0][1]*f, m[0][2]*f, m[0][3]*f,
                       m[1][0]*f, m[1][1]*f, m[1][2]*f, m[1][3]*f,
                       m[2][0]*f, m[2][1]*f, m[2][2]*f, m[2][3]*f,
                       m[3][0]*f, m[3][1]*f, m[3][2]*f, m[3][3]*f );
    }

    inline Matrix4f operator*( const Matrix4f &m, const long &f ) {
      return Matrix4f( m[0][0]*f, m[0][1]*f, m[0][2]*f, m[0][3]*f,
                       m[1][0]*f, m[1][1]*f, m[1][2]*f, m[1][3]*f,
                       m[2][0]*f, m[2][1]*f, m[2][2]*f, m[2][3]*f,
                       m[3][0]*f, m[3][1]*f, m[3][2]*f, m[3][3]*f );
    }
          
    inline bool operator==( const Matrix4f &m1, const Matrix4f &m2 ) {
       return m1[0][0]==m2[0][0] && m1[0][1]==m2[0][1] && m1[0][2]==m2[0][2] && 
   m1[0][3]==m2[0][3] && m1[1][0]==m2[1][0] && m1[1][1]==m2[1][1] && 
   m1[1][2]==m2[1][2] && m1[1][3]==m2[1][3] && m1[2][0]==m2[2][0] && 
   m1[2][1]==m2[2][1] && m1[2][2]==m2[2][2] && m1[2][3]==m2[2][3] &&
   m1[3][0]==m2[3][0] && m1[3][1]==m2[3][1] && m1[3][2]==m2[3][2] && 
   m1[3][3]==m2[3][3];
     }

    H3DAPI_API ostream& operator<<( ostream &os, const Matrix4f &m );

    inline Matrix4f operator*( const float &a, const Matrix4f &b ) { return b * a; }

    inline Matrix4f operator*( const double &a, const Matrix4f &b ) { return b * a; }

    inline Matrix4f operator*( const int &a, const Matrix4f &b ) { return b * a; }

    inline Matrix4f operator*( const long &a, const Matrix4f &b ) { return b * a; }
    
    inline Matrix4f operator-( const Matrix4f &m ) { return m * -1; }
    
    inline Matrix4f operator-( const Matrix4f &a, const Matrix4f &b ) 
        { return a + (-b); }
    
  }
}

#endif

---