glvector.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_VECTOR_INCLUDED
#define GRINLIZ_VECTOR_INCLUDED

#include <math.h>
#include "gldebug.h"
#include "glmath.h"
#include "glutil.h"


namespace grinliz {

template< class T >
struct Vector2
{
        T x;
        T y;

        T X( int i ) const              {       GLASSERT( InRange( i, 0, 1 ));
                                                                return *( &x + i ); }
        T* pX( int i )                  {       GLASSERT( InRange( i, 0, 1 ));
                                                                return &x + i; }

        void Add( const Vector2<T>& vec ) {
                x += vec.x;
                y += vec.y;
        }
        void Subtract( const Vector2<T>& vec ) {
                x -= vec.x;
                y -= vec.y;
        }

        friend void Subtract( const Vector2<T>& head, const Vector2<T>& tail, Vector2<T>* vec ) {
                vec->x = head.x - tail.x;
                vec->y = head.y - tail.y;
        }
        
        void operator+=( const Vector2<T>& vec )                { x += vec.x; y += vec.y; }
        bool operator==( const Vector2<T>& rhs ) const  { return x == rhs.x && y == rhs.y; }

        void Set( T x, T y ) {
                this->x = x;
                this->y = y;
        }
        void Zero() {
                x = (T)0;
                y = (T)0;
        }

        T Length() const { return grinliz::Length( x, y ); };

        void Normalize()        
        { 
                T lenInv = static_cast<T>(1) / Length( x, y );
                x *= lenInv; y *= lenInv;
                #ifdef DEBUG
                float len = x*x + y*y;
                GLASSERT( len > .9999f && len < 1.0001f );
                #endif
        }

        void RotatePos90()
        {
                T a = x;
                T b = y;
                x = -b;
                y = a;
        }
        void RotateNeg90()
        {
                T a = x;
                T b = y;
                x = b;
                y = -a;
        }
};

typedef Vector2< int > Vector2I;
typedef Vector2< float > Vector2F;


template< class T >
struct Line2
{
        Vector2<T>      n;      // normal
        T                       d;              // offset

        T EvaluateX( T y )              { return ( -d - y*n.y ) / n.x; }
        T EvaluateY( T x )              { return ( -d - x*n.x ) / n.y; }
};

typedef Line2< float > Line2F;



template< class T >
struct Vector3
{
        T x;
        T y;
        T z;

        T X( int i ) const              {       GLASSERT( InRange( i, 0, 2 ));
                                                                return *( &x + i ); }
        T* pX( int i )                  {       GLASSERT( InRange( i, 0, 2 ));
                                                                return &x + i; }

        void Add( const Vector3<T>& vec ) {
                x += vec.x;
                y += vec.y;
                z += vec.z;
        }
        void Subtract( const Vector3<T>& vec ) {
                x -= vec.x;
                y -= vec.y;
                z -= vec.z;
        }

        friend void Subtract( const Vector3<T>& head, const Vector3<T>& tail, Vector3<T>* vec ) {
                vec->x = head.x - tail.x;
                vec->y = head.y - tail.y;
                vec->z = head.z - tail.z;
        }
        
        friend Vector3<T> operator-( const Vector3<T>& head, const Vector3<T>& tail ) {
                Vector3<T> vec;
                vec.x = head.x - tail.x;
                vec.y = head.y - tail.y;
                vec.z = head.z - tail.z;
                return vec;
        }

        friend Vector3<T> operator+( const Vector3<T>& head, const Vector3<T>& tail ) {
                Vector3<T> vec;
                vec.x = head.x + tail.x;
                vec.y = head.y + tail.y;
                vec.z = head.z + tail.z;
                return vec;
        }
        
        friend Vector3<T> operator*( const Vector3<T>& head, float scalar ) {
                Vector3<T> vec = head;
                vec.x *= scalar;
                vec.y *= scalar;
                vec.z *= scalar;
                return vec;
        }

        void operator+=( const Vector3<T>& vec )                { x += vec.x; y += vec.y; z += vec.z; }
        bool operator==( const Vector3<T>& rhs ) const  { return x == rhs.x && y == rhs.y && z == rhs.z; }

        void Set( T x, T y, T z ) {
                this->x = x;
                this->y = y;
                this->z = z;
        }

        void Zero() {
                x = (T)0;
                y = (T)0;
                z = (T)0;
        }

        void Normalize()        
        { 
                GLASSERT( grinliz::Length( x, y, z ) > 0.001f );
                T lenInv = static_cast<T>(1) / grinliz::Length( x, y, z );
                x *= lenInv; 
                y *= lenInv;
                z *= lenInv;
                #ifdef DEBUG
                float len = x*x + y*y + z*z;
                GLASSERT( len > .9999f && len < 1.0001f );
                #endif
        }

        T Length() const { return grinliz::Length( x, y, z ); };
};

typedef Vector3< int > Vector3I;
typedef Vector3< float > Vector3F;


struct Vector4F
{
        float x, y, z, w;

        void operator+=( const Vector4F& rhs )  { x += rhs.x; y += rhs.y; z += rhs.z; w += rhs.w; }
};

};      // namespace grinliz


#endif

---