matrix.h

/*
-------------------------------------------------------------------------------
libfob - C++ interface to Ascension Technology Corporation's
         Flock of Birds position and orientation measurement system.
Copyright (C) 2002 Nathan Cournia

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library 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
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-------------------------------------------------------------------------------
*/

//FILE:         matrix.h
//AUTHOR:       Nathan Cournia <nathan@cournia.com>
//NOTE:         Data is stoed in row major format.  OpenGL expects column
//              major data.  Use transpose( ) to set data suitable for
//              sending to OpenGL's glMultMatrix( ).

#ifndef COURNIA_MATRIX4_H
#define COURNIA_MATRIX4_H 1

#include <iostream>
#include <cassert>
#include "fob/vector.h"
#include "fob/mathematics.h"

namespace math {
    class matrix4;
    math::vector3 operator* ( const math::vector3& v, const math::matrix4& m );
    std::ostream& operator<< ( std::ostream& o, const math::matrix4& m );
}


class math::matrix4
{
protected:
    real_t m_data[ 4 ][ 4 ]; 


    friend math::vector3 math::operator* ( const math::vector3& v, const math::matrix4& m );

    friend std::ostream& math::operator<< ( std::ostream& o, const math::matrix4& m );

public:
    matrix4( void );


    matrix4( 
        real_t d00, real_t d01, real_t d02, 
        real_t d10, real_t d11, real_t d12, 
        real_t d20, real_t d21, real_t d22 
    );


    matrix4( 
        real_t d00, real_t d01, real_t d02, real_t d03, 
        real_t d10, real_t d11, real_t d12, real_t d13,
        real_t d20, real_t d21, real_t d22, real_t d23,
        real_t d30, real_t d31, real_t d32, real_t d33
    );

    matrix4( const math::matrix4& m );

    virtual ~matrix4( void ) { }

    math::matrix4& operator= ( const math::matrix4 &m );


    operator const real_t* ( void ) const {
        return static_cast<const real_t*>(m_data[ 0 ]);
    }


    void set( 
        real_t d00, real_t d01, real_t d02, 
        real_t d10, real_t d11, real_t d12, 
        real_t d20, real_t d21, real_t d22 
    );


    void set( 
        real_t d00, real_t d01, real_t d02, real_t d03, 
        real_t d10, real_t d11, real_t d12, real_t d13,
        real_t d20, real_t d21, real_t d22, real_t d23,
        real_t d30, real_t d31, real_t d32, real_t d33
    );


    inline void set( unsigned int row, unsigned int col, real_t x ) {
        assert( (row < 4) && (col < 4) );
        m_data[ row ][ col ] = x;
    }


    inline real_t operator()( unsigned int row, unsigned int col ) const {
        assert( (row < 4) && (col < 4) );
        return m_data[ row ][ col ];
    }


    inline real_t& operator()( unsigned int row, unsigned int col ) {
        assert( (row < 4) && (col < 4) );
        return m_data[ row ][ col ];
    }


    math::vector3 operator* ( const math::vector3& v ) const;

    math::matrix4 operator* ( const math::matrix4& rhs ) const;

    math::matrix4 operator+ ( const math::matrix4& rhs ) const;

    math::matrix4 operator- ( const math::matrix4& rhs ) const;


    void transpose( void );


    inline void set_identity( ) {
        *this = math::matrix4::IDENTITY;
    }


    void from_angle_axis( real_t radians, const math::vector3& axis );
    

    math::matrix4 get_inverted_rotation( void ) const;


    inline void set_translation( const math::vector3& trans ) {
        m_data[ 0 ][ 3 ] = trans.x( );
        m_data[ 1 ][ 3 ] = trans.y( );
        m_data[ 2 ][ 3 ] = trans.z( );
    }

    inline math::vector3 get_translation( void ) const {
        return math::vector3( m_data[ 0 ][ 3 ],
            m_data[ 1 ][ 3 ],
            m_data[ 2 ][ 3 ]
        );
    }

    math::vector3 get_radians( void );

    math::vector3 get_degrees( void );
    

    void from_matrix3( const real_t *mat );


    void from_matrix4( const real_t *mat );


    static const math::matrix4 IDENTITY;


    static const math::matrix4 ZERO;
};

#endif

---