GMatrix44.h

/***************************************************************************
 *   Copyright (C) 2003-2004 by Raphael Langerhorst                        *
 *   raphael-langerhorst@gmx.at                                            *
 *                                                                         *
 *   Copyright (C) 2004 Gerald Degeneve <gerald.degeneve@gmx.at>           *
 *                                                                         *
 *   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 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 GMATRIX44H
#define GMATRIX44H

#include "GVector3.h"

namespace GCS

{

class GVector3;

class GMatrix44
{

  public:
    union
    {
        struct
        {
             double m11, m12, m13, m14,
                    m21, m22, m23, m24,
                    m31, m32, m33, m34,
                    m41, m42, m43, m44;
        };
    
        double m[4][4];

        double n[16];
    };

  public:

    GMatrix44() : 
              m11(1), m12(0), m13(0), m14(0),
              m21(0), m22(1), m23(0), m24(0),
              m31(0), m32(0), m33(1), m34(0),
              m41(0), m42(0), m43(0), m44(1) 
    {
    }

    GMatrix44(double _m11, double _m12, double _m13, double _m14,
              double _m21, double _m22, double _m23, double _m24,
              double _m31, double _m32, double _m33, double _m34,
              double _m41, double _m42, double _m43, double _m44) : 
              m11(_m11), m12(_m12), m13(_m13), m14(_m14),
              m21(_m21), m22(_m22), m23(_m23), m24(_m24),
              m31(_m31), m32(_m32), m33(_m33), m34(_m34),
              m41(_m41), m42(_m42), m43(_m43), m44(_m44)
    {
    }
    
    GMatrix44(const GMatrix44& original) :
              m11(original.m11), m12(original.m12), m13(original.m13), m14(original.m14),
              m21(original.m21), m22(original.m22), m23(original.m23), m24(original.m24),
              m31(original.m31), m32(original.m32), m33(original.m33), m34(original.m34),
              m41(original.m41), m42(original.m42), m43(original.m43), m44(original.m44)
    {
    }
    
    
    operator double* ();


    GMatrix44& loadIdentity();
     

    GMatrix44 multiply(double scalar);


    GMatrix44 multiply(const GMatrix44& m) const;
    

    GVector3 transform(const GVector3& v) const;
    
    
    GMatrix44 operator + (const GMatrix44& m) const;
    
    
    GMatrix44 operator - (const GMatrix44& m) const;
    
    
    GMatrix44 operator * (const GMatrix44& m) const;

    
    GMatrix44 operator * (const double scalar) const;
    
    
    inline bool operator == (const GMatrix44& m) const;

    
    inline bool operator != (const GMatrix44& m) const;

};


inline GMatrix44::operator double* ()
{
    return (double*)(n);
}

 
 
inline GMatrix44& GMatrix44::loadIdentity()
{
    m11 = 1; m12 = 0; m13 = 0; m14 = 0;
    m21 = 0; m22 = 1; m23 = 0; m24 = 0;
    m31 = 0; m32 = 0; m33 = 1; m34 = 0;
    m41 = 0; m42 = 0; m43 = 0; m44 = 1;
        
    return *this;
}


inline GMatrix44 GMatrix44::multiply(double scalar)
{
    return GMatrix44(m11 * scalar, m12 * scalar, m13 * scalar, m14 * scalar,
                     m21 * scalar, m22 * scalar, m23 * scalar, m24 * scalar,
                     m31 * scalar, m32 * scalar, m33 * scalar, m34 * scalar,
                     m41 * scalar, m42 * scalar, m43 * scalar, m44 * scalar);
}


inline GMatrix44 GMatrix44::multiply(const GMatrix44& m) const
{
    return GMatrix44(m.m11 * m11 + m.m21 * m12 + m.m31 * m13 + m.m41 * m14,
                     m.m12 * m11 + m.m22 * m12 + m.m32 * m13 + m.m42 * m14,
                     m.m13 * m11 + m.m23 * m12 + m.m33 * m13 + m.m43 * m14,
                     m.m14 * m11 + m.m24 * m12 + m.m34 * m13 + m.m44 * m14,
                     m.m11 * m21 + m.m21 * m22 + m.m31 * m23 + m.m41 * m24,
                     m.m12 * m21 + m.m22 * m22 + m.m32 * m23 + m.m42 * m24,
                     m.m13 * m21 + m.m23 * m22 + m.m33 * m23 + m.m43 * m24,
                     m.m14 * m21 + m.m24 * m22 + m.m34 * m23 + m.m44 * m24,
                     m.m11 * m31 + m.m21 * m32 + m.m31 * m33 + m.m41 * m34,
                     m.m12 * m31 + m.m22 * m32 + m.m32 * m33 + m.m42 * m34,
                     m.m13 * m31 + m.m23 * m32 + m.m33 * m33 + m.m43 * m34,
                     m.m14 * m31 + m.m24 * m32 + m.m34 * m33 + m.m44 * m34,
                     m.m11 * m41 + m.m21 * m42 + m.m31 * m43 + m.m41 * m44,
                     m.m12 * m41 + m.m22 * m42 + m.m32 * m43 + m.m42 * m44,
                     m.m13 * m41 + m.m23 * m42 + m.m33 * m43 + m.m43 * m44,
                     m.m14 * m41 + m.m24 * m42 + m.m34 * m43 + m.m44 * m44);
}
    


inline GVector3 GMatrix44::transform(const GVector3& v) const
{
    return GVector3(m[0][0]*v.x + m[0][1]*v.y + m[0][2]*v.z,
                    m[1][0]*v.x + m[1][1]*v.y + m[1][2]*v.z,
                    m[2][0]*v.x + m[2][1]*v.y + m[2][2]*v.z);
}



inline GMatrix44 GMatrix44::operator + (const GMatrix44& m) const
{
    return GMatrix44(m11 + m.m11, m12 + m.m12, m13 + m.m13, m14 + m.m14, 
                    m21 + m.m21, m22 + m.m22, m23 + m.m23, m24 + m.m24, 
                    m31 + m.m31, m32 + m.m32, m33 + m.m33, m34 + m.m34, 
                    m41 + m.m41, m42 + m.m42, m43 + m.m43, m44 + m.m44);
}


inline GMatrix44 GMatrix44::operator - (const GMatrix44& m) const
{
    return GMatrix44(m11 - m.m11, m12 - m.m12, m13 - m.m13, m14 - m.m14,
                    m21 - m.m21, m22 - m.m22, m23 - m.m23, m24 - m.m24,
                    m31 - m.m31, m32 - m.m32, m33 - m.m33, m34 - m.m34,
                    m41 - m.m41, m42 - m.m42, m43 - m.m43, m44 - m.m44);
}    
    
    
inline GMatrix44 GMatrix44::operator * (const GMatrix44& m) const
{
    return GMatrix44(m.m11 * m11 + m.m21 * m12 + m.m31 * m13 + m.m41 * m14,
                     m.m12 * m11 + m.m22 * m12 + m.m32 * m13 + m.m42 * m14,
                     m.m13 * m11 + m.m23 * m12 + m.m33 * m13 + m.m43 * m14,
                     m.m14 * m11 + m.m24 * m12 + m.m34 * m13 + m.m44 * m14,
                     m.m11 * m21 + m.m21 * m22 + m.m31 * m23 + m.m41 * m24,
                     m.m12 * m21 + m.m22 * m22 + m.m32 * m23 + m.m42 * m24,
                     m.m13 * m21 + m.m23 * m22 + m.m33 * m23 + m.m43 * m24,
                     m.m14 * m21 + m.m24 * m22 + m.m34 * m23 + m.m44 * m24,
                     m.m11 * m31 + m.m21 * m32 + m.m31 * m33 + m.m41 * m34,
                     m.m12 * m31 + m.m22 * m32 + m.m32 * m33 + m.m42 * m34,
                     m.m13 * m31 + m.m23 * m32 + m.m33 * m33 + m.m43 * m34,
                     m.m14 * m31 + m.m24 * m32 + m.m34 * m33 + m.m44 * m34,
                     m.m11 * m41 + m.m21 * m42 + m.m31 * m43 + m.m41 * m44,
                     m.m12 * m41 + m.m22 * m42 + m.m32 * m43 + m.m42 * m44,
                     m.m13 * m41 + m.m23 * m42 + m.m33 * m43 + m.m43 * m44,
                     m.m14 * m41 + m.m24 * m42 + m.m34 * m43 + m.m44 * m44);
}

    
    
inline GMatrix44 GMatrix44::operator * (const double scalar) const
{
    return GMatrix44(m11 * scalar, m12 * scalar, m13 * scalar, m14 * scalar,
                     m21 * scalar, m22 * scalar, m23 * scalar, m24 * scalar,
                     m31 * scalar, m32 * scalar, m33 * scalar, m34 * scalar,
                     m41 * scalar, m42 * scalar, m43 * scalar, m44 * scalar);
}
    
    
    
inline bool GMatrix44::operator == (const GMatrix44& m) const
{
    if(m11 != m.m11) return false;
    if(m12 != m.m12) return false;
    if(m13 != m.m13) return false;
    if(m14 != m.m14) return false;
    if(m21 != m.m21) return false;
    if(m22 != m.m22) return false;
    if(m23 != m.m23) return false;
    if(m24 != m.m24) return false;
    if(m31 != m.m31) return false;
    if(m32 != m.m32) return false;
    if(m33 != m.m33) return false;
    if(m34 != m.m34) return false;
    if(m41 != m.m41) return false;
    if(m42 != m.m42) return false;
    if(m43 != m.m43) return false;
    return m44 == m.m44;
}

    
    
inline bool GMatrix44::operator != (const GMatrix44& m) const
{
    if(m11 != m.m11) return true;
    if(m12 != m.m12) return true;
    if(m13 != m.m13) return true;
    if(m14 != m.m14) return true;
    if(m21 != m.m21) return true;
    if(m22 != m.m22) return true;
    if(m23 != m.m23) return true;
    if(m24 != m.m24) return true;
    if(m31 != m.m31) return true;
    if(m32 != m.m32) return true;
    if(m33 != m.m33) return true;
    if(m34 != m.m34) return true;
    if(m41 != m.m41) return true;
    if(m42 != m.m42) return true;
    if(m43 != m.m43) return true;
    return m44 != m.m44;
}


  
  
}

#endif

---