ArrayTriangle.h

Go to the documentation of this file.

//
//  VBOVertex.h
//  GlobeEngine
//
//  Created by Mathias Thöny on 27.12.11.
//  Copyright (c) 2011 University of Zurich. All rights reserved.
//

#ifndef GlobeEngine_ArrayTriangle_h
#define GlobeEngine_ArrayTriangle_h

#include "VBOVertex.h"
#include "OpenGL_Includes.h"
#include <iostream>

namespace geData {
    // D = Dimension of point vector, T = precission type of coordinates
    template <int D, class T> class ArrayTriangle
    {
    public:
        ArrayTriangle(){}
        
        ArrayTriangle(const T* _data){
            memcpy ( this->data, _data, 3 * D * sizeof(T) );
        }
        
        ~ArrayTriangle() { }
        
        void setArray(const T* _data){
            memcpy ( this->data, _data, 3 * D * sizeof(T) );
        }
        
        const T* getArray(){
            return data;
        }
        
        friend std::ostream& operator<< (std::ostream &out, const ArrayTriangle<D,T> &triangle) {
            int l = 3*D;
            out << "Array: " << triangle.data[0];
            for (int i=1; i < l; i++)
            {
                out  << ", " << triangle.data[i];
            }
            return out;
        }
        
    protected:
        T data[3*D];
    };
    
    template <class T> class ArrayTriangle2D : public ArrayTriangle<2,T>
    {
    public:
        ArrayTriangle2D(){}
        ArrayTriangle2D(const ge::Vertex2<T> _p1, const ge::Vertex2<T> _p2,const ge::Vertex2<T> _p3){
            set(_p1, _p2, _p3);
        }
        
        ArrayTriangle2D(const ge::Vertex2<T>* _data){
            set(_data);
        }
        
        void set(const ge::Vertex2<T> _p1, const ge::Vertex2<T> _p2,const ge::Vertex2<T> _p3){
            this->data[0] = _p1.x();
            this->data[1] = _p1.y();
            this->data[2] = _p2.x();
            this->data[3] = _p2.y();
            this->data[4] = _p3.x();
            this->data[5] = _p3.y();
        }
        
        void set(const ge::Vertex2<T>* _data){
            for(short i=0; i < 2; i++)
            {
                this->data[i*2] = _data[i].x();
                this->data[i*2+1] = _data[i].y();
            }
        }
    };
    
    typedef ArrayTriangle2D<GLbyte> ArrayTriangle2Db;
    typedef ArrayTriangle2D<GLubyte> ArrayTriangle2Dub;
    typedef ArrayTriangle2D<GLshort> ArrayTriangle2Ds;
    typedef ArrayTriangle2D<GLushort> ArrayTriangle2Dus;
    typedef ArrayTriangle2D<GLint>  ArrayTriangle2Di;
    typedef ArrayTriangle2D<GLuint>  ArrayTriangle2Dui;
    typedef ArrayTriangle2D<GLfloat>  ArrayTriangle2Df;
    typedef ArrayTriangle2D<GLdouble> ArrayTriangle2Dd;
    
    template <class T> class ArrayTriangle3D : public ArrayTriangle<3,T>
    {
    public:
        ArrayTriangle3D(){}
        ArrayTriangle3D(const ge::VBOVertex3<T> _p1, const ge::VBOVertex3<T> _p2,const ge::VBOVertex3<T> _p3){
            set(_p1, _p2, _p3);
        }
        
        ArrayTriangle3D(const ge::VBOVertex3<T>* _data){
            set(_data);
        }
        
        void set(const ge::VBOVertex3<T> _p1, const ge::VBOVertex3<T> _p2,const ge::VBOVertex3<T> _p3){
            this->data[0] = _p1.x();
            this->data[1] = _p1.y();
            this->data[2] = _p1.z();
            this->data[3] = _p2.x();
            this->data[4] = _p2.y();
            this->data[5] = _p2.z();
            this->data[6] = _p3.x();
            this->data[7] = _p3.y();
            this->data[8] = _p3.z();
        }
        
        void set(const ge::VBOVertex3<T>* _data){
            for(short i=0; i < 3; i++)
            {
                this->data[i*3] = _data[i].x();
                this->data[i*3+1] = _data[i].y();
                this->data[i*3+2] = _data[i].z();
            }
        }
    };
    
    typedef ArrayTriangle3D<GLbyte> ArrayTriangle3Db;
    typedef ArrayTriangle3D<GLubyte> ArrayTriangle3Dub;
    typedef ArrayTriangle3D<GLshort> ArrayTriangle3Ds;
    typedef ArrayTriangle3D<GLushort> ArrayTriangle3Dus;
    typedef ArrayTriangle3D<GLint>  ArrayTriangle3Di;
    typedef ArrayTriangle3D<GLuint>  ArrayTriangle3Dui;
    typedef ArrayTriangle3D<GLfloat>  ArrayTriangle3Df;
    typedef ArrayTriangle3D<GLdouble> ArrayTriangle3Dd;
    
    template <class T> class ArrayTriangle4D : public ArrayTriangle<4,T>
    {
    public:
        ArrayTriangle4D(){}
        ArrayTriangle4D(const ge::VBOVertex4<T> _p1, const ge::VBOVertex4<T> _p2,const ge::VBOVertex4<T> _p3){
            set(_p1, _p2, _p3);
        }
        
        ArrayTriangle4D(const ge::VBOVertex4<T>* _data){
            set(_data);
        }
        
        void set(const ge::VBOVertex4<T> _p1, const ge::VBOVertex4<T> _p2,const ge::VBOVertex4<T> _p3){
            this->data[0] = _p1.x();
            this->data[1] = _p1.y();
            this->data[2] = _p1.z();
            this->data[3] = _p1.w();
            this->data[4] = _p2.x();
            this->data[5] = _p2.y();
            this->data[6] = _p2.z();
            this->data[7] = _p2.w();
            this->data[8] = _p3.x();
            this->data[9] = _p3.y();
            this->data[10] = _p3.z();
            this->data[11] = _p3.w();
        }
        
        void set(const ge::VBOVertex4<T>* _data){
            for(short i=0; i < 4; i++)
            {
                this->data[i*4] = _data[i].x();
                this->data[i*4+1] = _data[i].y();
                this->data[i*4+2] = _data[i].z();
                this->data[i*4+3] = _data[i].z();
            }
        }
    };
    
    typedef ArrayTriangle4D<GLbyte> ArrayTriangle4Db;
    typedef ArrayTriangle4D<GLubyte> ArrayTriangle4Dub;
    typedef ArrayTriangle4D<GLshort> ArrayTriangle4Ds;
    typedef ArrayTriangle4D<GLushort> ArrayTriangle4Dus;
    typedef ArrayTriangle4D<GLint>  ArrayTriangle4Di;
    typedef ArrayTriangle4D<GLuint>  ArrayTriangle4Dui;
    typedef ArrayTriangle4D<GLfloat>  ArrayTriangle4Df;
    typedef ArrayTriangle4D<GLdouble> ArrayTriangle4Dd;
    
    
    // D = Dimension of point vector, T = precision type of coordinates
    template <int D, class T> class TriangleArray
    {
    public:
        TriangleArray( ){
            data = NULL;
        }
        
        TriangleArray(int _triangleCount, const T* _data){
            allocateMemory(_triangleCount);
            memcpy ( this->data, _data, _triangleCount * 3 * D * sizeof(T) );
        }
        
        ~TriangleArray() {
            clear();
        }
        
        void create(int _triangleCount){
            allocateMemory(_triangleCount);
        }
        
        void setAt(int _idx, const T _data){
            this->data[_idx] = _data;
        }
        
        void setRangeArray(int _startIndex, int _pointCount, const T* _data){
            memcpy(this->data[_startIndex], _data, _pointCount * 3 * D * sizeof(T));
        }
        
        void setArray(int _triangleCount, const T* _data){
            allocateMemory(_triangleCount);
            memcpy(this->data, _data, _triangleCount * 3 * D * sizeof(T) );
        }
        
        const T* getArray(){
            return data;
        }
        
        const int getTriangleCount(){
            return triangleCount;
        }
        
        friend std::ostream& operator<< (std::ostream &out, const TriangleArray<D,T> &triangle) {
            int l = triangle.getTriangleCount() * 3 * D;
            out << "Array: " << triangle.data[0];
            for (int i=1; i < l; i++)
            {
                out  << ", " << triangle.data[i];
            }
            return out;
        }
        
    private: 
        void allocateMemory(int _triangleCount){
            clear();
            triangleCount = _triangleCount;
            data = new T(_triangleCount * 3 * D);
        }
        
        void clear(){
            if (data != NULL)
            {
                delete [] data;
            }
            data = NULL;
            triangleCount = 0;
        }
        
    protected:
        int triangleCount;
        T* data;
    };
    
    typedef TriangleArray<3, GLdouble> TriangleArray3Dd;
}
#endif