gelVector.h

Go to the documentation of this file.

/*
Gel2D Game Engine - Cross-platform 2D gaming middleware
Copyright (C) 2010-2011 Mark D. Procarione

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

Gel2D 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 General Public License for more details.
*/

#ifndef __GELVECTOR_H__
#define __GELVECTOR_H__

#include <cmath>

namespace gel
{


    class Gel2dVec
    {
        public:
            Gel2dVec() : x(0.0f), y(0.0f) {}


            Gel2dVec( const Gel2dVec &vec ) : x(vec.x), y(vec.y) {}


            Gel2dVec( float n ) : x(n), y(n) {}


            Gel2dVec( float _x, float _y ) : x(_x), y(_y) {}


            float getLength() const
            {
                return sqrt(x*x + y*y);
            }


            float getSqrLength() const
            {
                return x*x + y*y;
            }


            float getDistanceTo( const Gel2dVec &vec ) const
            {
                return sqrt( (x - vec.x)*(x - vec.x) + (y - vec.y)*(y - vec.y) );
            }


            float getDot( const Gel2dVec &vec ) const
            {
                return x*vec.x + y*vec.y;
            }

            void normalize()
            {
                float len = getLength();
                x /= len;
                y /= len;
            }

            Gel2dVec operator+ ( const Gel2dVec &v ) const { return Gel2dVec( x+v.x, y+v.y ); }
            Gel2dVec operator- ( const Gel2dVec &v ) const { return Gel2dVec( x-v.x, y-v.y ); }
            Gel2dVec operator* ( const Gel2dVec &v ) const { return Gel2dVec( x*v.x, y*v.y ); }
            Gel2dVec operator/ ( const Gel2dVec &v ) const { return Gel2dVec( x/v.x, y/v.y ); }
            Gel2dVec operator= ( const Gel2dVec &v ) { x=v.x; y=v.y; return *this; }
            Gel2dVec operator+=( const Gel2dVec &v ) { x+=v.x; y+=v.y; return *this; }
            Gel2dVec operator-=( const Gel2dVec &v ) { x-=v.x; y-=v.y; return *this; }
            Gel2dVec operator*=( const Gel2dVec &v ) { x*=v.x; y*=v.y; return *this; }
            Gel2dVec operator/=( const Gel2dVec &v ) { x/=v.x; y/=v.y; return *this; }

            bool operator==( const Gel2dVec &v ) const { return ( x==v.x && y==v.y ); }
            bool operator!=( const Gel2dVec &v ) const { return ( x!=v.x || y!=v.y ); }
            bool operator< ( const Gel2dVec &v ) const { return ( x<v.x || (x==v.x && y<v.y) ); }
            bool operator> ( const Gel2dVec &v ) const { return ( x>v.x || (x==v.x && y>v.y) ); }
            bool operator<=( const Gel2dVec &v ) const
            {
                                return ( (x<v.x || x==v.x) || ( x==v.x && (y<v.y || y==v.y) ) );
                        }
            bool operator>=( const Gel2dVec &v ) const
                        {
                                return ( (x>v.x || x==v.x) || ( x==v.x && (y>v.y || y==v.y) ) );
                        }

            float x;
            float y;
    };


    class Gel3dVec
    {
        public:
            Gel3dVec() : x(0.0f), y(0.0f), z(0.0f) {}


            Gel3dVec( const Gel3dVec &vec ) : x(vec.x), y(vec.y), z(vec.z) {}


            Gel3dVec( float n ) : x(n), y(n), z(n) {}


            Gel3dVec( float _x, float _y, float _z ) : x(_x), y(_y), z(_z) {}


            float getLength() const
            {
                return sqrt(x*x + y*y + z*z);
            }


            float getSqrLength() const
            {
                return x*x + y*y + z*z;
            }


            float getDistanceTo( const Gel3dVec &vec ) const
            {
                return sqrtf((x - vec.x)*(x - vec.x) +
                             (y - vec.y)*(y - vec.y) +
                             (z - vec.z)*(z - vec.z));
            }


            float getDot( const Gel3dVec &vec ) const
            {
                return x*vec.x + y*vec.y + z*vec.z;
            }


            Gel3dVec getCross( const Gel3dVec &vec ) const
            {
                return Gel3dVec((y*vec.z) - (z*vec.y),
                                (z*vec.x) - (x*vec.z),
                                (x*vec.y) - (y*vec.x));
            }

            void normalize()
            {
                float len = getLength();
                x /= len;
                y /= len;
                z /= len;
            }

            Gel3dVec operator+  ( const Gel3dVec &v ) { return Gel3dVec( x+v.x, y+v.y, z+v.z ); }
            Gel3dVec operator-  ( const Gel3dVec &v ) { return Gel3dVec( x-v.x, y-v.y, z-v.z ); }
            Gel3dVec operator*  ( const Gel3dVec &v ) { return Gel3dVec( x*v.x, y*v.y, z*v.z ); }
            Gel3dVec operator/  ( const Gel3dVec &v ) { return Gel3dVec( x/v.x, y/v.y, z/v.z ); }
            Gel3dVec operator=  ( const Gel3dVec &v ) { x=v.x; y=v.y; z=v.z; return *this; }
            Gel3dVec operator+= ( const Gel3dVec &v ) { x+=v.x; y+=v.y; z+=v.z; return *this; }
            Gel3dVec operator-= ( const Gel3dVec &v ) { x-=v.x; y-=v.y; z-=v.z; return *this; }
            Gel3dVec operator*= ( const Gel3dVec &v ) { x*=v.x; y*=v.y; z*=v.z; return *this; }
            Gel3dVec operator/= ( const Gel3dVec &v ) { x/=v.x; y/=v.y; z/=v.z; return *this; }

            bool operator== ( const Gel3dVec &v ) const { return ( x==v.x && y==v.y && z==v.z ); }
            bool operator!= ( const Gel3dVec &v ) const { return ( x!=v.x || y!=v.y || z!=v.z ); }

            float x;
            float y;
            float z;
    };
}

#endif // __GELVECTOR_H__