Vector.h

Go to the documentation of this file.

#ifndef __vector_h__
#define __vector_h__

#include <math.h>
#include "globals.h"
#ifndef PI
        #define PI 3.1415926535897;
#endif

class Vector
{

public:
        // Construction/destruction
        inline Vector(void)                                                             { this->x=0;this->y=0;this->z=0;}
        inline Vector(float X, float Y, float Z)                { this->x = X; this->y = Y; this->z = Z;                                        }
        inline Vector(const Vector& v)                                  { this->x = v.x; this->y = v.y; this->z = v.z;                          }
        inline Vector(float rgfl[3])                                    { this->x = rgfl[0]; this->y = rgfl[1]; this->z = rgfl[2];      }
        inline Vector(Vector spitze, Vector schaft)
        {
                Vector v = (spitze - schaft);
                x = v.x; 
                y = v.y;
                z = v.z;
        } 
        // Operators
        inline Vector operator-(void) const                             { return Vector(-x,-y,-z);                              }
        inline int operator==(const Vector& v) const    { return x==v.x && y==v.y && z==v.z;    }
        inline int operator!=(const Vector& v) const    { return !(*this==v);                                   }
        inline Vector operator+(const Vector& v) const  { 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 Vector operator*(float fl) const                 { return Vector(x*fl, y*fl, z*fl);              }
        inline Vector operator/(float fl) const                 { return Vector(x/fl, y/fl, z/fl);              }
        // Methods
        inline void copyToArray(float* rgfl) const              { rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
        inline float length(void) const                                 { return sqrt(x*x + y*y + z*z); }
        Vector normalize(void) const
        {
                float flLen = this->length();
                if (flLen == 0) return Vector(0,0,0); // ????
                return Vector(x / flLen, y / flLen, z / flLen);
        };  
        inline float dotProduct(const Vector& b) 
        { 
                return(x*b.x + y*b.y + z*b.z); 
        };  
        inline Vector crossProduct(const Vector& b) 
        { 
                return Vector( y*b.z - z*b.y, z*b.x - x*b.z, x*b.y - y*b.x ); 
        };  
        void rotateX(float angle)
        {
                float bg = (angle/180)*PI;
                float x= this->x;
                float y= this->y;
                float z= this->z;

                float cosTheta = (float)cos(bg);
                float sinTheta = (float)sin(bg);
 
                this->x= x;
                this->y= clampTo(-1,1,y*cosTheta - z *sinTheta );
                this->z= clampTo(-1,1,y*sinTheta + z *cosTheta) ;
                this->normalize();


        };  
        void rotateY(float angle)
        {
                float bg = (angle/180)*PI;
                float x= this->x;
                float y= this->y;
                float z= this->z;
                float cosTheta = (float)cos(bg);
                float sinTheta = (float)sin(bg);
 
                this->x= clampTo(-1,1,x*cosTheta + z*sinTheta);
                this->y= y;
                this->z= clampTo(-1,1,-1*x*sinTheta + z *cosTheta) ;
        };  
        void rotateZ(float angle)
        {
        
                float bg = (angle/180)*PI;
                float x= this->x;
                float y= this->y;
                float z= this->z;

                float cosTheta = (float)cos(bg);
                float sinTheta = (float)sin(bg);
 
                this->x= clampTo(-1,1,x*cosTheta - y*sinTheta);
                this->y= clampTo(-1,1,x*sinTheta + y *cosTheta );
                this->z= z;
                this->normalize();

        };  
        static float clampTo(float min, float max, float Val)
        {
                if (Val > max) {Val = max; }
                else {
                        if(Val < min){ Val = min;}
                        }

                        return Val;
        };  
        // Members
        float x 
                , y 
                , z ;
};

// ----------------------------------------------------------------------------------

class CVector2 
{

public:
        CVector2() { x=0; y=0; }
        inline CVector2(float X, float Y) { x=X; y=Y; }
        CVector2(CVector2 spitze, CVector2 schaft)
        {
                CVector2 v = (spitze - schaft);
                x = v.x; 
                y = v.y;
        }  
        CVector2(float x1,float y1,float x2,float y2)
        {
                CVector2 v = (CVector2(x1,y1) - CVector2(x2,y2));
                x = v.x; 
                y = v.y;
        }  
        inline CVector2 operator-(void) const                           { return CVector2(-x,-y);                       }
        inline int operator==(const CVector2& v) const          { return x==v.x && y==v.y;                      }
        inline int operator!=(const CVector2& v) const      { return !(*this==v);                               }
        inline CVector2 operator+(const CVector2& v) const      { return CVector2(x+v.x, y+v.y);        }
        inline CVector2 operator-(const CVector2& v) const      { return CVector2(x-v.x, y-v.y);        }
        inline CVector2 operator*(float fl) const                       { return CVector2(x*fl, y*fl);          }
        inline CVector2 operator/(float fl) const                       { return CVector2(x/fl, y/fl);          }
        inline float length(void) const                                         { return sqrt(x*x + y*y);                       }
        inline CVector2 normalize(void) const                           { float len = length(); return CVector2(x/len,y/len); }
        float angle(CVector2 v1)
        { 
                float a = (x*v1.x + y*v1.y)/(this->length() * v1.length());     
                return acos(a); 
        }  
        // Members
        float x, y;


};


#endif

---