Matrix4d.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 __MATRIX4D_H__
#define __MATRIX4D_H__

#include "H3DApi.h"
#include "H3DBasicTypes.h"
#include "Vec4d.h"
#include "H3DTemplateOperators.h"
#include "Exception.h"
#include "Matrix3d.h"

namespace H3D {
  namespace ArithmeticTypes {
    class Quaternion;
    class Rotation;
    class Matrix4f;

    class H3DAPI_API Matrix4d {
    public:
      H3D_API_EXCEPTION( SingularMatrix4d );

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

      Matrix4d( const Quaternion &q );

      explicit Matrix4d( const Matrix3d &m );

      Matrix4d( const Matrix4f &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;
      }
                        
      Matrix4d transformInverse() const;
        
      Matrix4d inverse() const;

      inline Matrix4d transpose() const {
        return Matrix4d( 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] );
      };
      
      inline H3DDouble* operator[]( const int i ) { return m[i]; }
                                
      inline const H3DDouble* operator[]( const int i ) const { return m[i]; }

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

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

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

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

                        inline Matrix3d getScaleRotationPart() const {
                                return Matrix3d( 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] );
                        }

                        Matrix3d getRotationPart() const;

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

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


    inline Matrix4d operator*( const Matrix4d &m1, const Matrix4d &m2 ) {
      return Matrix4d( 
  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 Matrix4d operator+( const Matrix4d &m1, const Matrix4d &m2 ) {
      return Matrix4d( 
  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 Matrix4d operator*( const Matrix4d &m, const float &f ) {
      return Matrix4d( 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 Matrix4d operator*( const Matrix4d &m, const double &d ) {
      return Matrix4d( (H3DDouble)(m[0][0]*d), (H3DDouble)(m[0][1]*d), (H3DDouble)(m[0][2]*d), (H3DDouble)(m[0][3]*d),
                       (H3DDouble)(m[1][0]*d), (H3DDouble)(m[1][1]*d), (H3DDouble)(m[1][2]*d), (H3DDouble)(m[1][3]*d),
                       (H3DDouble)(m[2][0]*d), (H3DDouble)(m[2][1]*d), (H3DDouble)(m[2][2]*d), (H3DDouble)(m[2][3]*d),
                       (H3DDouble)(m[3][0]*d), (H3DDouble)(m[3][1]*d), (H3DDouble)(m[3][2]*d), (H3DDouble)(m[3][3]*d) );
    }

    inline Matrix4d operator*( const Matrix4d &m, const int &f ) {
      return Matrix4d( 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 Matrix4d operator*( const Matrix4d &m, const long &f ) {
      return Matrix4d( 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 Matrix4d &m1, const Matrix4d &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 Matrix4d &m );

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

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

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

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

#endif

---