VBOVertex.h

Go to the documentation of this file.

#ifndef GlobeEngine_VBOVertex_h
#define GlobeEngine_VBOVertex_h

#include "OpenGL_Includes.h"
#include <vmmlib/vmmlib.hpp>
#include <iostream>

namespace ge {
    template <int D, class T> class VBOVertex
    {
    public:
        VBOVertex(){
            for (int i=0;i<D;i++) {
                this->data[i] = 0.0;
            }
        }
        ~VBOVertex() { }
        
        T getArray(){
            return data;
        }
        
        friend std::ostream& operator<< (std::ostream &out, const VBOVertex< D, T> &vert) {
            out << "("<< vert.data[0];
            for (int i=1;i<D;i++) {
                out << ", " << vert.data[i];
            }
            out << ")";
            return out;
        }
        
        /* is equal is coordinates are equal */
        //bool operator==(const VBOVertex  &other)const{
        //  memcmp(this->data, other->getArray(), sizeof(T) * D);
        //}
        
        
        
    protected:
        T data[D];
    };
    
    template <class T> class Vertex2 :  public VBOVertex< 2, T>
    {
    public:
        Vertex2(){}
        Vertex2(T _u, T _v){
            this->data[0] = _u;
            this->data[1] = _v;
        }
        
        void set(T _u, T _v){
            this->data[0] = _u;
            this->data[1] = _v;
        }
        
        /* smaller with x coordinate priority. */
        bool operator<(const Vertex2 &other)const{
            if(this->data[0] != other.x())
                return this->data[0] < other.x();
            return this->data[1] < other.y();
        }
        
        /* is equal is coordinates are equal */
        bool operator==(const Vertex2 &other)const{
            return this->data[0] == other.x() && this->data[1] == other.y();
        }
        
        T u() const { return this->data[0]; }
        T v() const { return this->data[1]; }
        T x() const { return this->data[0]; }
        T y() const { return this->data[1]; }
        
        void u(T _u){ this->data[0] = _u; }
        void x(T _x){ this->data[0] = _x; }
        void v(T _v){ this->data[1] = _v; }
        void y(T _y){ this->data[1] = _y; }
    };
    
    typedef Vertex2<GLbyte> Vertex2b;
    typedef Vertex2<GLubyte> Vertex2ub;
    typedef Vertex2<GLshort> Vertex2s;
    typedef Vertex2<GLushort> Vertex2us;
    typedef Vertex2<GLint>  Vertex2i;
    typedef Vertex2<GLuint>  Vertex2ui;
    typedef Vertex2<GLfloat>  Vertex2f;
    typedef Vertex2<GLdouble> Vertex2d;
    
    typedef Vertex2<GLbyte> Color2b;
    typedef Vertex2<GLubyte> Color2ub;
    typedef Vertex2<GLshort> Color2s;
    typedef Vertex2<GLushort> Color2us;
    typedef Vertex2<GLint>  Color2i;
    typedef Vertex2<GLuint>  Color2ui;
    typedef Vertex2<GLfloat>  Color2f;
    typedef Vertex2<GLdouble> Color2d;
    
    typedef Vertex2<GLbyte> TexCoord2b;
    typedef Vertex2<GLubyte> TexCoord2ub;
    typedef Vertex2<GLshort> TexCoord2s;
    typedef Vertex2<GLushort> TexCoord2us;
    typedef Vertex2<GLint>  TexCoord2i;
    typedef Vertex2<GLuint>  TexCoord2ui;
    typedef Vertex2<GLfloat>  TexCoord2f;
    typedef Vertex2<GLdouble> TexCoord2d;
    
    template <class T> class VBOVertex3 : public VBOVertex< 3, T>
    {
    public:
        VBOVertex3(){}
        VBOVertex3(T _x, T _y, T _z){
            this->data[0] = _x;
            this->data[1] = _y;
            this->data[2] = _z;
        }
        
        void set(T _x, T _y, T _z){
            this->data[0] = _x;
            this->data[1] = _y;
            this->data[2] = _z;
        }
        
        T x() const { return this->data[0]; }
        T y() const { return this->data[1]; }
        T z() const { return this->data[2]; }
        T r() const { return this->data[0]; }
        T g() const { return this->data[1]; }
        T b() const { return this->data[2]; }
        
        Vertex2<T> xy() const { return Vertex2<T>(this->data[0], this->data[1]); }
        Vertex2<T> xz() const { return Vertex2<T>(this->data[0], this->data[2]); }
        Vertex2<T> yz() const { return Vertex2<T>(this->data[1], this->data[2]); }

        void x(T _x){ this->data[0] = _x; }
        void y(T _y){ this->data[1] = _y; }
        void z(T _z){ this->data[2] = _z; }
        void r(T _r){ this->data[0] = _r; }
        void g(T _g){ this->data[1] = _g; }
        void b(T _b){ this->data[2] = _b; }
        
        /* smaller with x coordinate priority. */
        bool operator<(const VBOVertex3 &other)const{
            if(this->data[0] != other.x())
                return this->data[0] < other.x();
            if(this->data[1] != other.y())
                return this->data[1] < other.y();
            return this->data[2] < other.z();
        }
        
        /* is equal is coordinates are equal */
        bool operator==(const VBOVertex3 &other) const{
            return this->data[0] == other.x() && this->data[1] == other.y() && this->data[2] == other.z();
        }
        
        /* convert vmml vector 3f ot VBOVertex 3f seems to not work */
        VBOVertex3<T>& operator=(const vmml::Vector3f& other) const {
            this->data[0] = other.x();
            this->data[1] = other.y();
            this->data[2] = other.z();
            return this;
        }

        /* is equal when coordinates are equal */
        bool isAlmostEqual(const VBOVertex3 &other)const{
            return (this->data[0] - other.x() <= 0.00001) && (this->data[1] - other.y() <= 0.00001) && (this->data[2] - other.z() <= 0.00001);
        }
        
        struct Vec3IsAlmostEqual
        {
            bool operator()(const VBOVertex3 &a, const VBOVertex3 &b)
            {
                return (a.x() - b.x() <= 0.00001) && (a.y() - b.y() <= 0.00001) && (a.z() - b.z() <= 0.00001);
            }
        };
    };
    
    typedef VBOVertex3<GLboolean> VBOVertex3boolean;
    typedef VBOVertex3<GLbyte> VBOVertex3b;
    typedef VBOVertex3<GLubyte> VBOVertex3ub;
    typedef VBOVertex3<GLshort> VBOVertex3s;
    typedef VBOVertex3<GLushort> VBOVertex3us;
    typedef VBOVertex3<GLint>  VBOVertex3i;
    typedef VBOVertex3<GLuint>  VBOVertex3ui;
    typedef VBOVertex3<GLfloat>  VBOVertex3f;
    typedef VBOVertex3<GLdouble> VBOVertex3d;
    
    typedef VBOVertex3<GLboolean> Vertex3boolean;
    typedef VBOVertex3<GLbyte> Vertex3b;
    typedef VBOVertex3<GLubyte> Vertex3ub;
    typedef VBOVertex3<GLshort> Vertex3s;
    typedef VBOVertex3<GLushort> Vertex3us;
    typedef VBOVertex3<GLint>  Vertex3i;
    typedef VBOVertex3<GLuint>  Vertex3ui;
    typedef VBOVertex3<GLfloat>  Vertex3f;
    typedef VBOVertex3<GLdouble> Vertex3d;
    
    typedef VBOVertex3<GLfloat>  Vertexf;
    typedef VBOVertex3<GLdouble> Vertexd;
    
    typedef VBOVertex3<GLboolean> Color3boolean;
    typedef VBOVertex3<GLbyte> Color3b;
    typedef VBOVertex3<GLubyte> Color3ub;
    typedef VBOVertex3<GLshort> Color3s;
    typedef VBOVertex3<GLushort> Color3us;
    typedef VBOVertex3<GLint>  Color3i;
    typedef VBOVertex3<GLuint>  Color3ui;
    typedef VBOVertex3<GLfloat>  Color3f;
    typedef VBOVertex3<GLdouble> Color3d;
    
    typedef VBOVertex3<GLboolean> TexCoord3boolean;
    typedef VBOVertex3<GLbyte> TexCoord3b;
    typedef VBOVertex3<GLubyte> TexCoord3ub;
    typedef VBOVertex3<GLshort> TexCoord3s;
    typedef VBOVertex3<GLushort> TexCoord3us;
    typedef VBOVertex3<GLint>  TexCoord3i;
    typedef VBOVertex3<GLuint>  TexCoord3ui;
    typedef VBOVertex3<GLfloat>  TexCoord3f;
    typedef VBOVertex3<GLdouble> TexCoord3d;
    
    template <class T> class VBOVertex4 : public VBOVertex< 4, T>
    {
    public:
        VBOVertex4(){}
        VBOVertex4(T _x, T _y, T _z, T _w){
            this->data[0] = _x;
            this->data[1] = _y;
            this->data[2] = _z;
            this->data[3] = _w;
        }
        
        void set(T _x, T _y, T _z, T _w){
            this->data[0] = _x;
            this->data[1] = _y;
            this->data[2] = _z;
            this->data[3] = _w;
        }
        
        T x() const { return this->data[0]; }
        T y() const { return this->data[1]; }
        T z() const { return this->data[2]; }
        T w() const { return this->data[3]; }
        T r() const { return this->data[0]; }
        T g() const { return this->data[1]; }
        T b() const { return this->data[2]; }
        T a() const { return this->data[3]; }
        
        void x(T _x){ this->data[0] = _x; }
        void y(T _y){ this->data[1] = _y; }
        void z(T _z){ this->data[2] = _z; }
        void w(T _w){ this->data[3] = _w; }
        void r(T _r){ this->data[0] = _r; }
        void g(T _g){ this->data[1] = _g; }
        void b(T _b){ this->data[2] = _b; }
        void a(T _a){ this->data[3] = _a; }
        
        /* smaller with x coordinate priority. */
        bool operator<(const VBOVertex4 &other)const{
            if(this->data[0] != other.x())
                return this->data[0] < other.x();
            if(this->data[1] != other.y())
                return this->data[1] < other.y();
            if(this->data[2] != other.z())
                return this->data[1] < other.z();
            return this->data[3] < other.w();
        }
        
        /* is equal is coordinates are equal */
        bool operator==(const VBOVertex4 &other)const{
            return this->data[0] == other.x() && this->data[1] == other.y() && this->data[2] == other.z()&& this->data[3] == other.w();
        }
        
    };
    
    typedef VBOVertex4<GLboolean> VBOVertex4boolean;
    typedef VBOVertex4<GLbyte> VBOVertex4b;
    typedef VBOVertex4<GLubyte> VBOVertex4ub;
    typedef VBOVertex4<GLshort> VBOVertex4s;
    typedef VBOVertex4<GLushort> VBOVertex4us;
    typedef VBOVertex4<GLint>  VBOVertex4i;
    typedef VBOVertex4<GLuint>  VBOVertex4ui;
    typedef VBOVertex4<GLfloat>  VBOVertex4f;
    typedef VBOVertex4<GLdouble> VBOVertex4d;
    
    typedef VBOVertex4<GLboolean> Vertex4boolean;
    typedef VBOVertex4<GLbyte> Vertex4b;
    typedef VBOVertex4<GLubyte> Vertex4ub;
    typedef VBOVertex4<GLshort> Vertex4s;
    typedef VBOVertex4<GLushort> Vertex4us;
    typedef VBOVertex4<GLint>  Vertex4i;
    typedef VBOVertex4<GLuint>  Vertex4ui;
    typedef VBOVertex4<GLfloat>  Vertex4f;
    typedef VBOVertex4<GLdouble> Vertex4d;

    typedef VBOVertex4<GLbyte> Color4b;
    typedef VBOVertex4<GLubyte> Color4ub;
    typedef VBOVertex4<GLshort> Color4s;
    typedef VBOVertex4<GLushort> Color4us;
    typedef VBOVertex4<GLint>  Color4i;
    typedef VBOVertex4<GLuint>  Color4ui;
    typedef VBOVertex4<GLfloat>  Color4f;
    typedef VBOVertex4<GLdouble> Color4d;
}
#endif