Vector_wocomments.h

#ifndef __vector_h__
#define __vector_h__

#include <math.h>
#include "globals.h"
#ifndef PI
        #define PI 3.1415926535897;
#endif
class Vector                                            // same data-layout as engine's vec3_t,
{                                                               //              which is a vec_t[3]
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); }
        //operator float *()                                                            { return &x; } // Vectors will now automatically convert to float * when needed
        //operator const float *() const                                        { return &x; } // Vectors will now automatically convert to float * when needed
        /*float clampTo(float min, float max, float Val)
        {
                if (Val > max) Val = max;
                else 
                        if(Val < min) Val = min;

                return Val;
        }  ;
        */
        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 rotatePoint(float angle, float x, float y, float z)
        {
                float bg = (angle/180)*PI;
                Vector* vNewView = new Vector();
                
                // Calculate the sine and cosine of the angle once
                float cosTheta = (float)cos(bg);
                float sinTheta = (float)sin(bg);

                // Find the new x position for the new rotated point
                vNewView->x  = (cosTheta + (1 - cosTheta) * x * x)              * this->x;
                vNewView->x += ((1 - cosTheta) * x * y - z * sinTheta)  * this->y;
                vNewView->x += ((1 - cosTheta) * x * z + y * sinTheta)  * this->z;

                // Find the new y position for the new rotated point
                vNewView->y  = ((1 - cosTheta) * x * y + z * sinTheta)  * this->x;
                vNewView->y += (cosTheta + (1 - cosTheta) * y * y)              * this->y;
                vNewView->y += ((1 - cosTheta) * y * z - x * sinTheta)  * this->z;

                // Find the new z position for the new rotated point
                vNewView->z  = ((1 - cosTheta) * x * z - y * sinTheta)  * this->x;
                vNewView->z += ((1 - cosTheta) * y * z + x * sinTheta)  * this->y;
                vNewView->z += (cosTheta + (1 - cosTheta) * z * z)              * this->z;

                // Now we just add the newly rotated vector to our position to set
                // our new rotated view of our camera.
                this->x= vNewView->x;
                this->y= vNewView->y;
                this->z= vNewView->z;
        }       ;
        */
        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();


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

                        return Val;
        };
        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();

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

// 2D Vector
class CVector2 
{
public:
        CVector2(){x=0;y=0;}
        inline CVector2(float X, float Y){x=X;y=Y;}
        //Spitze - Schaft
        CVector2(CVector2 spitze, CVector2 schaft)
        {
                CVector2 v = (spitze - schaft);
                x = v.x; 
                y = v.y;
        }
        // Spitze - Schaft
        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());     
                //cout << "a:"<< a << "\n";
                return acos(a); 
        }


        float x, y;


};



#endif

---