---

matrix.h

//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 "vector.h"
#include "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 operator* ( const math::vector3& v, const math::matrix4& m );

        friend std::ostream& 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 ]
                );
        }


        static const math::matrix4 IDENTITY;


        static const math::matrix4 ZERO;
};

#endif

---