GLVector.h

/***************************************************************************
 *   Copyright (C) 2004 by Jacques Gasselin                                *
 *   jacquesgasselin@hotmail.com                                           *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   This program 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.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef GL_VECTOR_H
#define GL_VECTOR_H

#include "GLFunctions.h"

#ifdef GLVECTOR_IOSTREAM
    #include <iostream>
#endif
#include <valarray>

namespace mathglpp
{

template <typename T>
class GLVector2
{
public:
    enum { D = 2 };

    GLVector2()
    { }

    GLVector2(const T& v)
    {   x = y = v; }

    GLVector2(const T& v1, const T& v2)
    {   x = v1; y = v2; }

    GLVector2(const GLVector2& gv)
    {   memmove(val,gv.val,D*sizeof(T)); }

    GLVector2(const T* f)
    {   memmove(val,f,D*sizeof(T)); }

    ~GLVector2(){}

    inline void set(const T& v1, const T& v2)
    {   x = v1; y = v2; }

    inline T& operator[] (int ind)
    {   return val[ind]; }

    inline operator T* (void)
    {   return val; }

    inline operator const T* (void) const
    {   return val; }

    inline void glScale() const;
    inline void glRotate(const T& ang) const;
    inline void glTranslate() const;
    inline void glVertex() const { mathglpp::glVertexv<D,T>(val); }
    inline void glNormal() const;

    inline void copyTo(T* vec) const
    {   memmove(vec,val,2*sizeof(T)); }

    inline const GLVector2 operator + (const GLVector2& gv) const
    {
        return GLVector2(x+gv.x,y+gv.y);
    }

    inline const GLVector2 operator - (const GLVector2& gv) const
    {
        return GLVector2(x-gv.x,y-gv.y);
    }

    inline const GLVector2 operator * (const GLVector2& gv) const
    {
        return GLVector2(x*gv.x,y*gv.y);
    }

    inline const GLVector2 operator / (const GLVector2& gv) const
    {
        return GLVector2(x/gv.x,y/gv.y);
    }

    inline const GLVector2 operator * (const T& v) const
    {
        return GLVector2(x*v,y*v);
    }

    inline const GLVector2 operator / (const T& v) const
    {
        return GLVector2(x/v,y/v);
    }

    GLVector2& operator += (const GLVector2& gv)
    {
        x += gv.x;
        y += gv.y;
        return *this;
    }

    GLVector2& operator -= (const GLVector2& gv)
    {
        x -= gv.x;
        y -= gv.y;
        return *this;
    }

    GLVector2& operator *= (const T& f)
    {
        x *= f;
        y *= f;
        return *this;
    }

    GLVector2& operator /= (const T& f)
    {
        x /= f;
        y /= f;
        return *this;
    }

    GLVector2& operator = (const GLVector2& v)
    {   memmove(val, v.val, D*sizeof(T)); return *this; }

    inline bool operator == (const GLVector2& v)
    {   return memcmp(val, v.val, D*sizeof(T))==0;  }

    inline const GLVector2 operator - () const
    {
        return GLVector2(-x,-y);
    }

    inline const T dot(const GLVector2& gv) const
    {   return x*gv.x + y*gv.y; }

    inline T length() const
    {   return sqrt(lengthSqr()); }

    inline T lengthSqr() const
    {   return x * x + y * y; }

    const GLVector2 unit() const
    {
        return (*this)/length();
    }

    GLVector2& normalize()
    {
        (*this)/=length();
        return *this;
    }

    inline const T projection(const GLVector2& in) const
    {   return dot(in); }

    inline GLVector2 orthogonalProjection(const GLVector2& in) const
    {   return in - vectorProjection(in); }

    GLVector2 vectorProjection(const GLVector2& in) const
    {   return (*this) * dot(in); }

    #ifdef GLVECTOR_IOSTREAM
    friend std::basic_istream<char, std::char_traits<char> >& operator >>
      ( std::basic_istream<char, std::char_traits<char> >& in, GLVector2& vec)
    { in>>vec.val[0]>>vec.val[1]; return in;};

    friend std::basic_ostream<char, std::char_traits<char> >& operator <<
      ( std::basic_ostream<char, std::char_traits<char> >& out, GLVector2& vec)
    { out<<vec.val[0]<<" "<<vec.val[1]; return out;};
    #endif

    union
    {
        T val[D];
        struct
        {
            T x,y;
        };
    };
};

typedef GLVector2<GLbyte> GLVector2b;
typedef GLVector2<GLshort> GLVector2s;
typedef GLVector2<GLint> GLVector2i;
typedef GLVector2<GLfloat> GLVector2f;
typedef GLVector2<GLdouble> GLVector2d;

template <typename T>
class GLIVector2
{
public:
    enum { D = 2 };

    GLIVector2(const GLIVector2& gv)
    :val(gv.val)
    { }

    GLIVector2(T* f)
    :val(f)
    { }

    ~GLIVector2(){}

    inline void set(const T& v1, const T& v2)
    {   val[0] = v1; val[1] = v2; }

    inline T& operator[] (int ind)
    {   return val[ind]; }

    inline operator T* (void)
    {   return val; }

    inline operator const T* (void) const
    {   return val; }

    inline void glScale() const;
    inline void glRotate(const T& ang) const;
    inline void glTranslate() const;
    inline void glVertex() const { mathglpp::glVertexv<D,T>(val); }
    inline void glNormal() const;

    inline const GLVector2<T> operator + (const GLVector2<T>& gv) const
    {
        return GLVector2<T>(val[0]+gv.x,val[1]+gv.y);
    }
    
    inline const GLVector2<T> operator + (const GLIVector2& gv) const
    {
        return GLVector2<T>(val[0]+gv.val[0],val[1]+gv.val[1]);
    }

    inline const GLVector2<T> operator - (const GLVector2<T>& gv) const
    {
        return GLVector2<T>(val[0]-gv.x,val[1]-gv.y);
    }

    inline const GLVector2<T> operator - (const GLIVector2& gv) const
    {
        return GLVector2<T>(val[0]-gv.val[0],val[1]-gv.val[1]);
    }
    
    inline const GLVector2<T> operator * (const GLVector2<T>& gv) const
    {
        return GLVector2<T>(val[0]*gv.x,val[1]*gv.y);
    }

    inline const GLVector2<T> operator * (const GLIVector2& gv) const
    {
        return GLVector2<T>(val[0]*gv.x,val[1]*gv.y);
    }

    inline const GLVector2<T> operator / (const GLVector2<T>& gv) const
    {
        return GLVector2<T>(val[0]/gv.x,val[1]/gv.y);
    }

    inline const GLVector2<T> operator / (const GLIVector2& gv) const
    {
        return GLVector2<T>(val[0]/gv.val[0],val[1]/gv.val[1]);
    }

    inline const GLVector2<T> operator * (const T& v) const
    {
        return GLVector2<T>(val[0]*v,val[1]*v);
    }

    inline const GLVector2<T> operator / (const T& v) const
    {
        return GLVector2<T>(val[0]/v,val[1]/v);
    }

    GLIVector2& operator += (const GLVector2<T>& gv)
    {
        val[0] += gv.x;
        val[1] += gv.y;
        return *this;
    }

    GLIVector2& operator += (const GLIVector2& gv)
    {
        val[0] += gv.val[0];
        val[1] += gv.val[0];
        return *this;
    }

    GLIVector2& operator -= (const GLVector2<T>& gv)
    {
        val[0] -= gv.x;
        val[1] -= gv.y;
        return *this;
    }

    GLIVector2& operator -= (const GLIVector2<T>& gv)
    {
        val[0] -= gv.val[0];
        val[1] -= gv.val[1];
        return *this;
    }

    GLIVector2& operator *= (const T& f)
    {
        val[0] *= f;
        val[1] *= f;
        return *this;
    }

    GLIVector2& operator /= (const T& f)
    {
        val[0] /= f;
        val[1] /= f;
        return *this;
    }

    GLIVector2& operator = ( const GLVector2<T>& v )
    {   memmove(val, v.val, D*sizeof(T)); return *this; }

    GLIVector2& operator = ( const GLIVector2& v )
    {   memmove(val, v.val, D*sizeof(T)); return *this; }

    inline const GLVector2<T> operator - () const
    {
        return GLVector2<T>(-val[0],-val[1]);
    }

    inline const T dot(const GLVector2<T>& gv) const
    {   return val[0]*gv.x + val[1]*gv.y; }

    inline const T dot(const GLIVector2& gv) const
    {   return val[0]*gv.val[0] + val[1]*gv.val[1]; }
    
    inline T length() const
    {   return sqrt(lengthSqr()); }

    inline T lengthSqr() const
    {   return val[0]*val[0] + val[1]*val[1]; }

    const GLVector2<T> unit() const
    {
        return (*this)/length();
    }

    GLIVector2& normalize()
    {
        (*this)/=length();
        return *this;
    }

    inline const T projection(const GLVector2<T>& in) const
    {   return dot(in); }

    inline const T projection(const GLIVector2& in) const
    {   return dot(in); }

    inline GLVector2<T> orthogonalProjection(const GLVector2<T>& in) const
    {   return in - vectorProjection(in); }

    inline GLVector2<T> orthogonalProjection(const GLIVector2& in) const
    {   return in - vectorProjection(in); }
    
    GLVector2<T> vectorProjection(const GLVector2<T>& in) const
    {   return (*this) * dot(in); }
    
    GLVector2<T> vectorProjection(const GLIVector2& in) const
    {   return (*this) * dot(in); }

    #ifdef GLVECTOR_IOSTREAM
    friend std::basic_istream<char, std::char_traits<char> >& operator >>
      ( std::basic_istream<char, std::char_traits<char> >& in, GLIVector2& vec)
    { in>>vec.val[0]>>vec.val[1]; return in;};

    friend std::basic_ostream<char, std::char_traits<char> >& operator <<
      ( std::basic_ostream<char, std::char_traits<char> >& out, GLIVector2& vec)
    { out<<vec.val[0]<<" "<<vec.val[1]; return out;};
    #endif

    T* val;
};

typedef GLIVector2<GLbyte> GLIVector2b;
typedef GLIVector2<GLshort> GLIVector2s;
typedef GLIVector2<GLint> GLIVector2i;
typedef GLIVector2<GLfloat> GLIVector2f;
typedef GLIVector2<GLdouble> GLIVector2d;

template <typename T>
class GLVector3
{
public:
    enum { D = 3 };
    typedef T value_type;

    GLVector3() { }

    GLVector3(const T& v)
    :x(v), y(v), z(v) { }

    GLVector3(const T& a, const T& b, const T& c)
    :x(a),y(b),z(c){}

    GLVector3(const GLVector3& gv)
    {   memmove(val,gv.val,D*sizeof(T)); }

    GLVector3(const T* f)
    {   memmove(val,f,D*sizeof(T)); }

    ~GLVector3(){}

    inline void set(const T& v1, const T& v2, const T& v3)
    {   x = v1; y = v2; z = v3; }

    inline T& operator[] (int ind)
    {   return val[ind]; }

    inline operator T* (void)
    {   return val; }

    inline operator const T* (void) const
    {   return val; }

    void glScale() const;
    void glRotate(const T& ang) const;
    void glTranslate() const;
    inline void glVertex() const { mathglpp::glVertexv<D,T>(val); }
    void glNormal() const;

    inline void copyTo(T* vec) const
    {   memmove(vec,val,D*sizeof(T)); }

    inline const GLVector3 operator + (const GLVector3& gv) const
    {
        return GLVector3(x+gv.x,y+gv.y,z+gv.z);
    }

    inline const GLVector3 operator - (const GLVector3& gv) const
    {
        return GLVector3(x-gv.x,y-gv.y,z-gv.z);
    }

    inline const GLVector3 operator * (const GLVector3& gv) const
    {
        return GLVector3(x*gv.x,y*gv.y,z*gv.z);
    }

    inline const GLVector3 operator / (const GLVector3& gv) const
    {
        return GLVector3(x/gv.x,y/gv.y,z/gv.z);
    }

    inline const GLVector3 operator * (const T& v) const
    {
        return GLVector3(x*v,y*v,z*v);
    }


    inline const GLVector3 operator / (const T& v) const
    {
        return GLVector3(x/v,y/v,z/v);
    }

    GLVector3& operator += (const GLVector3& gv)
    {
        x += gv.x;
        y += gv.y;
        z += gv.z;
        return *this;
    }

    GLVector3& operator -= (const GLVector3& gv)
    {
        x -= gv.x;
        y -= gv.y;
        z -= gv.z;
        return *this;
    }

    GLVector3& operator *= (const T& f)
    {
        x *= f;
        y *= f;
        z *= f;
        return *this;
    }

    GLVector3& operator /= (const T& f)
    {
        x /= f;
        y /= f;
        z /= f;
        return *this;
    }

    GLVector3& operator = (const GLVector3& gv)
    {   memmove(val, gv.val, D*sizeof(T)); return *this; }
    
    inline bool operator == (const GLVector3& gv)
    {   return memcmp(val, gv.val, D*sizeof(T))==0;  }
    
    inline const GLVector3 operator - () const
    {
        return GLVector3(-x,-y,-z);
    }

    inline const T dot(const GLVector3& gv) const
    {   return x*gv.x + y*gv.y + z*gv.z;  }

    inline T length() const
    {   return sqrt(lengthSqr()); }

    inline T lengthSqr() const
    {   return x*x + y*y + z*z;  }

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

    GLVector3& cross(const GLVector3& gv)
    {
        T temp[] = { x, y, z };

        x = temp[1] * gv.z - temp[2] * gv.y;
        y = temp[2] * gv.x - temp[0] * gv.z;
        z = temp[0] * gv.y - temp[1] * gv.x;

        return *this;
    }

    const GLVector3 unit() const
    {
        return (*this)/length();
    }

    GLVector3& normalize()
    {
        (*this)/=length();
        return *this;
    }

    inline const T projection(const GLVector3& in) const
    {   return dot(in); }

    inline GLVector3 orthogonalProjection(const GLVector3& in) const
    {   return in - (*this) * dot(in); }

    GLVector3 vectorProjection(const GLVector3& in) const
    {   return (*this) * dot(in); }

    #ifdef GLVECTOR_IOSTREAM
    friend std::basic_istream<char, std::char_traits<char> >& operator >>
      ( std::basic_istream<char, std::char_traits<char> >& in, GLVector3& vec)
    { in>>vec.val[0]>>vec.val[1]>>vec.val[2]; return in;};

    friend std::basic_ostream<char, std::char_traits<char> >& operator <<
      ( std::basic_ostream<char, std::char_traits<char> >& out, GLVector3& vec)
    { out<<vec.val[0]<<" "<<vec.val[1]<<" "<<vec.val[2]; return out;};
    #endif

    union
    {
        T val[D];
        struct
        {
            T x,y,z;
        };
    };
};


typedef GLVector3<GLbyte> GLVector3b;
typedef GLVector3<GLshort> GLVector3s;
typedef GLVector3<GLint> GLVector3i;
typedef GLVector3<GLfloat> GLVector3f;
typedef GLVector3<GLdouble> GLVector3d;


template <typename T>
class GLVectorArray3
{
public:
    enum { D = 3 };
    typedef T value_type;
    typedef std::valarray<value_type> vector_type;
    
    GLVectorArray3():vec() { }

    GLVectorArray3(const T& v)
    :vec(v) { }

    GLVectorArray3(const GLVectorArray3& gv)
    :vec(gv.vec)
    { }

    GLVectorArray3(const vector_type& v)
    :vec(v)
    { }

    GLVectorArray3(const T* f, int nVec)
    :vec(f,nVec*D)
    { }

    ~GLVectorArray3(){}

    inline T& operator[] (int ind)
    {   return vec[ind]; }

    inline operator T* (void)
    {   return &vec[0]; }

    inline operator const T* (void) const
    {   return &vec[0]; }

    inline void copyTo(T* v) const
    {   memmove(v,&vec[0],D*sizeof(T)); }

    inline const GLVectorArray3 operator + (const GLVectorArray3& gv) const
    {
        return GLVectorArray3(*this)+=gv;
    }

    inline const GLVectorArray3 operator - (const GLVectorArray3& gv) const
    {
        return GLVectorArray3(*this)-=gv;
    }

    inline const GLVectorArray3 operator * (const GLVectorArray3& gv) const
    {
        return GLVectorArray3(*this)*=gv;
    }

    inline const GLVectorArray3 operator / (const GLVectorArray3& gv) const
    {
        return GLVectorArray3(*this)/=gv;
    }

    inline const GLVectorArray3 operator * (const T& v) const
    {
        return GLVectorArray3(*this)*=v;
    }

    inline const GLVectorArray3 operator / (const T& v) const
    {
        return GLVectorArray3(*this)/=v;
    }

    GLVectorArray3& operator += (const GLVectorArray3& gv)
    {
        vec += gv.vec;
        return *this;
    }

    GLVectorArray3& operator -= (const GLVectorArray3& gv)
    {
        vec -= gv.vec;
        return *this;
    }

    GLVectorArray3& operator *= (const T& f)
    {
        vec *= f;
        return *this;
    }

    GLVectorArray3& operator /= (const T& f)
    {
        vec /= f;
        return *this;
    }

    GLVectorArray3& operator = (const GLVectorArray3& gv)
    {
        vec = gv.vec;
        return *this;
    }

    inline const GLVectorArray3 operator - () const
    {
        return GLVectorArray3(-vec);
    }

    vector_type vec;
};

typedef GLVectorArray3<GLbyte> GLVectorArray3b;
typedef GLVectorArray3<GLshort> GLVectorArray3s;
typedef GLVectorArray3<GLint> GLVectorArray3i;
typedef GLVectorArray3<GLfloat> GLVectorArray3f;
typedef GLVectorArray3<GLdouble> GLVectorArray3d;

template <typename T>
class GLVector4
{
public:
    enum { D = 4 };

    GLVector4()
    { }

    GLVector4(const T& v)
    {   x = y = z = w = v; }

    GLVector4(const T& v1, const T& v2, const T& v3, const T& v4)
    {   x = v1; y = v2; z = v3; w = v4; }

    GLVector4(const GLVector4& gv)
    {   memmove(val,gv.val,D*sizeof(T)); }

    GLVector4(const T* f)
    {   memmove(val,f,D*sizeof(T)); }

    ~GLVector4(){}

    inline void set(const T& v1, const T& v2, const T& v3, const T& v4)
    {   x = v1; y = v2; z = v3; w = v4;}

    inline T& operator[] (int ind)
    {   return val[ind]; }

    inline operator T* (void)
    {   return val; }

    inline operator const T* (void) const
    {   return val; }

    inline void glScale() const;
    inline void glRotate(const T& ang) const;
    inline void glTranslate() const;
    inline void glVertex() const { mathglpp::glVertexv<D,T>(val); }
    inline void glNormal() const;

    inline void copyTo(T* vec) const
    {   memmove(vec,val,D*sizeof(T)); }

    inline const GLVector4 operator + (const GLVector4& gv) const
    {
        return GLVector4(x+gv.x,y+gv.y,z+gv.z,w+gv.w);
    }

    inline const GLVector4 operator - (const GLVector4& gv) const
    {
        return GLVector4(x-gv.x,y-gv.y,z-gv.z,w-gv.w);
    }

    inline const GLVector4 operator * (const GLVector4& gv) const
    {
        return GLVector4(x*gv.x,y*gv.y,z*gv.z,w*gv.w);
    }

    inline const GLVector4 operator / (const GLVector4& gv) const
    {
        return GLVector4(x/gv.x,y/gv.y,z/gv.z,w/gv.w);
    }

    inline const GLVector4 operator * (const T& v) const
    {
        return GLVector4(x*v,y*v,z*v,w*v);
    }


    inline const GLVector4 operator / (const T& v) const
    {
        return GLVector4(x/v,y/v,z/v,w/v);
    }

    GLVector4& operator += (const GLVector4& gv)
    {
        x += gv.x;
        y += gv.y;
        z += gv.z;
        w += gv.w;
        return *this;
    }

    GLVector4& operator -= (const GLVector4& gv)
    {
        x -= gv.x;
        y -= gv.y;
        z -= gv.z;
        w -= gv.w;
        return *this;
    }

    GLVector4& operator *= (const T& f)
    {
        x *= f;
        y *= f;
        z *= f;
        w *= f;
        return *this;
    }

    GLVector4& operator /= (const T& f)
    {
        x /= f;
        y /= f;
        z /= f;
        w /= f;
        return *this;
    }

    GLVector4& operator = (const GLVector4& gv)
    {   memmove(val,gv.val,D*sizeof(T)); return *this; }

    inline bool operator == (const GLVector4& v)
    {   return memcmp(val, v.val, D*sizeof(T))==0;  }

    inline const GLVector4 operator - () const
    {
        return GLVector4(-x,-y,-z,-w);
    }

    inline const T dot(const GLVector4& gv) const
    {   return x*gv.x + y*gv.y + z*gv.z + w*gv.w;  }

    inline T length() const
    {   return sqrt(lengthSqr()); }

    inline T lengthSqr() const
    {   return x*x + y*y + z*z + w*w;  }

    const GLVector4 getCross(const GLVector4& gv) const
    {
        return GLVector4(y*gv.z-z*gv.y,z*gv.w-w*gv.z,w*gv.x-x*gv.w,x*gv.y-y*gv.x);
    }

    GLVector4& cross(const GLVector4& gv)
    {
        T temp[] = { x, y, z, w };

        x = temp[1] * gv.z - temp[2] * gv.y;
        y = temp[2] * gv.w - temp[3] * gv.z;
        z = temp[3] * gv.x - temp[0] * gv.w;
        w = temp[0] * gv.y - temp[1] * gv.x;

        return *this;
    }

    const GLVector4 unit() const
    {
        return (*this)/length();
    }

    GLVector4& normalize()
    {
        (*this)/=length();
        return *this;
    }

    inline const T projection(const GLVector4& in) const
    {   return dot(in); }

    inline GLVector4 orthogonalProjection(const GLVector4& in) const
    {   return in - vectorProjection(in); }

    GLVector4 vectorProjection(const GLVector4& in) const
    {   return (*this) * dot(in); }

    #ifdef GLVECTOR_IOSTREAM
    friend std::basic_istream<char, std::char_traits<char> >& operator >>
      ( std::basic_istream<char, std::char_traits<char> >& in, GLVector4& vec)
    { in>>vec.val[0]>>vec.val[1]>>vec.val[2]>>vec.val[3]; return in;}

    friend std::basic_ostream<char, std::char_traits<char> >& operator <<
      ( std::basic_ostream<char, std::char_traits<char> >& out, GLVector4& vec)
    { out<<vec.val[0]<<" "<<vec.val[1]<<" "<<vec.val[2]<<" "<<vec.val[3]; return out;}
    #endif

    union
    {
        T val[D];
        struct
        {
            T x,y,z,w;
        };
    };
};

typedef GLVector4<GLbyte> GLVector4b;
typedef GLVector4<GLshort> GLVector4s;
typedef GLVector4<GLint> GLVector4i;
typedef GLVector4<GLfloat> GLVector4f;
typedef GLVector4<GLdouble> GLVector4d;

};

#endif

---