source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/leaves/Vector.h @ 985

/*
---------------------------------------------------------------------
This file is part of Sandra Engine (real-time 3D engine)
 Copyright (C) 2004 Jesus Gumbau Portales

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

This library 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
 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, 
 USA, or go to http://www.gnu.org/copyleft/lesser.txt.
---------------------------------------------------------------------
*/

// 21-02-2001
// Jesus Gumbau Portales

#ifndef __VECTOR_H__
#define __VECTOR_H__

#include <math.h>

#ifndef PI
#define PI      3.14159f
#endif
#define GradToRad(x) x*PI/180.0f

class Vector
{
public:
        Vector(double vx=0.0f, double vy=0.0f, double vz=0.0f, double vw=1.0f){ x=vx; y=vy; z=vz; w=vw; }
        double x,y,z,w;
        inline Vector operator*(double f) const { return Vector(x*f,y*f,z*f); }
        inline void operator+=(const Vector &v){ x+=v.x; y+=v.y; z+=v.z; }
        inline void operator+=(double f){ x+=f; y+=f; z+=f; }
        inline void operator-=(const Vector &v){ x-=v.x; y-=v.y; z-=v.z; }
        inline void operator-=(double f){ x-=f; y-=f; z-=f; }
        inline Vector operator+(const Vector &v) const { return Vector(x+v.x,y+v.y,z+v.z); }
//      Vector operator-(Vector &v){ return Vector(x-v.x,y-v.y,z-v.z); }
        inline Vector operator-(const Vector &v) const { return Vector(x-v.x,y-v.y,z-v.z); }
        inline double Module(void) const { return sqrtf(float(x*x) + float(y*y) + float(z*z)); }
        inline bool operator==(const Vector &v) const { return (x==v.x && y==v.y && z==v.z); }
        inline bool operator!=(const Vector &v) const { return (x!=v.x || y!=v.y || z!=v.z); }
        inline Vector operator-(void) const { return Vector(-x,-y,-z); }
        inline Vector operator/(double f) const { return (*this)*(1/f); }
        inline Vector operator/=(double f) { x/=f; y/=f; z/=f; return (*this); }
        inline Vector operator=(const Vector &v) { x=v.x; y=v.y; z=v.z; w=v.w; return Vector(x,y,z,w); }
        inline Vector operator=(double f) { x=f; y=f; z=f; return Vector(x,y,z); }
        inline bool operator<(const Vector &v) const { return (x<v.x && y<v.y && z<v.z && w<v.w); }
        inline void Normalize(void){
                double module=sqrtf(float(x*x) + float(y*y) + float(z*z));
                x=x/module;
                y=y/module;
                z=z/module;
        }


        static const Vector UNITY;
                
        const double &operator[](unsigned int i) const { return (&x)[i]; }
        double &operator[](unsigned int i){ return (&x)[i]; }
};

#endif