glmatrix.h

/*
Copyright (c) 2000-2003 Lee Thomason (www.grinninglizard.com)
Grinning Lizard Utilities.

This software is provided 'as-is', without any express or implied 
warranty. In no event will the authors be held liable for any 
damages arising from the use of this software.

Permission is granted to anyone to use this software for any 
purpose, including commercial applications, and to alter it and 
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must 
not claim that you wrote the original software. If you use this 
software in a product, an acknowledgment in the product documentation 
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and 
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source 
distribution.
*/


#ifndef GRINLIZ_MATRIX_DEFINED
#define GRINLIZ_MATRIX_DEFINED

#include "gldebug.h"
#include "glvector.h"

namespace grinliz {

class Matrix4
{
  public:
        Matrix4()                               {       SetIdentity();  }
        void SetIdentity()              {       x[0] = x[5] = x[10] = x[15] = 1.0f;
                                                                x[1] = x[2] = x[3] = x[4] = x[6] = x[7] = x[8] = x[9] = x[11] = x[12] = x[13] = x[14] = 0.0f; 
                                                        }
        void SetTranslation( float _x, float _y, float _z )
                                                        {       x[12] = _x;     x[13] = _y;     x[14] = _z;     }

        void SetXRotation( float thetaDegree );
        void SetYRotation( float thetaDegree );
        void SetZRotation( float thetaDegree );

        void SetXRotationNeg90();
        void SetZRotationNeg90();

        void SetScale( float scale )    { x[0] = x[5] = x[10] = scale; }

        void SetAxisAngle( const Vector3F& axis, float angle );

        void StripTrans()               {       x[12] = x[13] = x[14] = 0.0f;
                                                                x[15] = 1.0f;
                                                        }

        float* Base()                   {       return x; }

        // Is this probably a rotation matrix?
        bool IsRotation() const;

        friend void MultMatrix4( const Matrix4& a, const Matrix4& b, Matrix4* c );
        friend void MultMatrix4( const Matrix4& a, const Vector4F& b, Vector4F* c );
        
        #ifdef DEBUG
        void Dump( const char* name ) const
        {
                GLOUTPUT(("Matrix %s:\n"
                          "         %6.2f %6.2f %6.2f %6.2f\n"
                                  "         %6.2f %6.2f %6.2f %6.2f\n"                  
                                  "         %6.2f %6.2f %6.2f %6.2f\n"                  
                                  "         %6.2f %6.2f %6.2f %6.2f\n",
                                  name,
                                  x[0], x[4], x[8], x[12], 
                                  x[1], x[5], x[9], x[13],                      
                                  x[2], x[6], x[10], x[14], 
                                  x[3], x[7], x[11], x[15] ));
        }
        #endif
        
        // Row-Column notation is backwards from x,y regrettably. Very
        // confusing. Just uses array. Increment by one moves down to the next
        // row, so that the next columnt is at +4.
        union
        {
                float x[16];
                struct
                {
                        float m11, m21, m31, m41, m12, m22, m32, m42, m13, m23, m33, m43, m14, m24, m34, m44;
                };
        };

        friend Matrix4 operator*( const Matrix4& a, const Matrix4& b )
        {       
                Matrix4 result;
                MultMatrix4( a, b, &result );
                return result;
        }
};


inline void MultMatrix4( const Matrix4& a, const Matrix4& b, Matrix4* c )
{
        // This does not support the target being one of the sources.
        GLASSERT( c != &a && c != &b && &a != &b );

        for( int i=0; i<4; ++i )                        // target row
        {
                for( int j=0; j<4; ++j )                // target column
                {
                        *( c->x + i +4*j )      =   a.x[i+0]  * b.x[j*4+0] 
                                                                  + a.x[i+4]  * b.x[j*4+1] 
                                                                  + a.x[i+8]  * b.x[j*4+2] 
                                                                  + a.x[i+12] * b.x[j*4+3];
                }
        }
}


inline void MultMatrix4( const Matrix4& a, const Vector3F& b, Vector3F* c )
{
        GLASSERT( c != &b );
        for( int i=0; i<3; ++i )                        // target row
        {
                *( &c->x + i )  =               a.x[i+0]  * b.x 
                                                          + a.x[i+4]  * b.y 
                                                          + a.x[i+8]  * b.z
                                                          + a.x[i+12];                  // assume 1.0
        }
}


inline void MultMatrix4( const Vector3F& b, const Matrix4& a, Vector3F* c )
{
        GLASSERT( c != &b );

        for( int i=0; i<3; ++i )                        // target row
        {
                *( &c->x + i )  =               a.x[i*4+0]  * b.x 
                                                          + a.x[i*4+1]  * b.y 
                                                          + a.x[i*4+2]  * b.z
                                                          + a.x[i*4+3];                 // assume 1.0
        }
}


};      // namespace grinliz

#endif

---