mesh.hpp

Go to the documentation of this file.

#ifndef __MESH__
#define __MESH__

#include <tucano/model.hpp>
#include <tucano/shader.hpp>
#include <memory>


namespace Tucano
{

class Mesh;

class VertexAttribute
{
    friend class Mesh;
private:
public:
    string name;
    int size = 0;
    int element_size = 0;
    GLint location = -1;
    GLuint bufferID = 0;
    GLenum type = GL_FLOAT;
    GLenum array_type = GL_ARRAY_BUFFER;

    std::shared_ptr < GLuint > bufferID_sptr;

public:


    //VertexAttribute() = default;

    VertexAttribute(string in_name, int in_num_elements, int in_element_size, GLenum in_type, GLenum in_array_type = GL_ARRAY_BUFFER) :
        name(in_name), size(in_num_elements), element_size(in_element_size), type(in_type), array_type (in_array_type)
    {
        // create new buffer for attribute if it is not yet set (ex copy constructor)
        glGenBuffers(1, &bufferID);

        bufferID_sptr = std::shared_ptr < GLuint > ( 
                    new GLuint (bufferID),
                    [] (GLuint *p) {
                        glDeleteBuffers(1, p);
                        delete p;
                    }
                    );
        #ifdef TUCANODEBUG
        Tucano::Misc::errorCheckFunc(__FILE__, __LINE__, "mesh constructor");
        #endif
    }

    string getName (void) const {return name;}

    int getSize (void) const {return size;}

    int getElementSize (void) const {return element_size;}

    GLenum getType (void) const {return type;}

    GLenum getArrayType (void) const {return array_type;}

    void setArrayType (GLenum at) {array_type = at;}

    GLint getLocation(void) const {return location;}

    void setLocation(GLint loc) {location = loc;}

    GLuint getBufferID (void) {return *bufferID_sptr;}

    void bind(void)
    {
        glBindBuffer(array_type, *bufferID_sptr);
    }

    void enable(GLint loc)
    {
        setLocation(loc);
        enable();
    }

    void enable()
    {
        if (location != -1)
        {
            glBindBuffer(array_type, *bufferID_sptr);
            glVertexAttribPointer(location, element_size, type, GL_FALSE, 0, NULL);
            glEnableVertexAttribArray(location);
        }
    }


    void unbind(void)
    {
        glBindBuffer(array_type, 0);
    }

    void disable(void)
    {
        if (location != -1)
        {
            glDisableVertexAttribArray(location);
        }
    }

};

class Mesh : public Tucano::Model {
protected:

    vector < Tucano::VertexAttribute > vertex_attributes;

    unsigned int numberOfVertices = 0;

    unsigned int numberOfNormals = 0;

    unsigned int numberOfElements = 0;

    unsigned int numberOfTexCoords = 0;

    unsigned int numberOfColors = 0;

    GLuint index_buffer_id = 0;

    GLuint vao_id = 0;

    bool willTessellate = false;

    std::shared_ptr < GLuint > index_buffer_sptr = 0;

    std::shared_ptr < GLuint > vao_sptr = 0;

public:

    Mesh (void)
    {
        radius = 1.0;
        scale = 1.0;

        glGenBuffers(1, &index_buffer_id);
        index_buffer_sptr = std::shared_ptr < GLuint > ( 
                    new GLuint (index_buffer_id),
                    [] (GLuint *p) {
                        glDeleteBuffers(1, p);
                        delete p;
                    }
                    );

        glGenVertexArrays(1, &vao_id);
        vao_sptr = std::shared_ptr < GLuint > ( 
                    new GLuint (vao_id),
                    [] (GLuint *p) {
                        glDeleteVertexArrays(1, p);
                        delete p;
                    }
                    );


        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__);
        #endif
    }


    int getNumberOfElements (void)
    {
        return numberOfElements;
    }

    int getNumberOfVertices (void)
    {
        return numberOfVertices;
    }

    void resetLocations (void)
    {
        for (unsigned int i = 0; i < vertex_attributes.size(); ++i)
        {
            vertex_attributes[i].setLocation(-1);
        }
    }

    void reset (void)
    {
         for (unsigned int i = 0; i < vertex_attributes.size(); ++i)
        {
            vertex_attributes[i].disable();

        }
    
    }



    void loadVertices (vector<Eigen::Vector4f> &vert)
    {

        numberOfVertices = vert.size();

        // creates new attribute and load vertex coordinates
        createAttribute("in_Position", vert);

        // from now on we are just computing some information about the model such as bounding box, centroid ...

        float xMax = 0; float xMin = 0; float yMax = 0; float yMin = 0; float zMax = 0; float zMin = 0;

        int temp = 0;
        for(unsigned int i = 0; i < numberOfVertices*4; i+=4) {

            //X:
            if(vert[temp][0] > xMax) {
                xMax = vert[temp][0];
            }
            if(vert[temp][0] < xMin) {
                xMin = vert[temp][0];
            }

            //Y:
            if(vert[temp][1] > yMax) {
                yMax = vert[temp][1];
            }
            if(vert[temp][1] < yMin) {
                yMin = vert[temp][1];
            }

            //Z:
            if(vert[temp][2] > zMax) {
                zMax = vert[temp][2];
            }
            if(vert[temp][2] < zMin) {
                zMin = vert[temp][2];
            }

            //W:
            temp++;
        }

        scale = 1.0/max(max(xMax-xMin, yMax-yMin), zMax-zMin);

        float centerX = (xMax+xMin)/2.0;
        float centerY = (yMax+yMin)/2.0;
        float centerZ = (zMax+zMin)/2.0;
        objectCenter = Eigen::Vector3f(centerX, centerY, centerZ);

        // compute the centroid (different from the box center)
        centroid = Eigen::Vector3f::Zero();
        for(unsigned int i = 0; i < numberOfVertices; i++) {
            centroid = centroid + vert[i].head(3);//Eigen::Vector3f(vert[i][0], vert[i][1], vert[i][2]);
        }
        centroid = centroid / numberOfVertices;

        // compute the radius of the bounding sphere
        // most distance point from the centroid
        radius = 0.0;
        for(unsigned int i = 0; i < numberOfVertices; i++) {
            radius = max(radius, ( vert[i].head(3) - centroid ).norm());
        }

        scale = 1.0/radius;

    }

    void loadNormals (vector<Eigen::Vector3f> &norm)
    {
        numberOfNormals = norm.size();

        createAttribute("in_Normal", norm);
    }

    void loadTexCoords (vector<Eigen::Vector2f> &tex, bool normalize = false)
    {
        numberOfTexCoords = tex.size();

        if (normalize)
        {
            vector<Eigen::Vector2f> tex_normalized;

            float texXmax = tex[0][0];
            float texXmin = tex[0][0];
            float texYmax = tex[0][1];
            float texYmin = tex[0][1];

            // compute min and max values for x and y
            for(unsigned int i = 0; i < numberOfTexCoords; i++)
            {
                if (tex[i][0] < texXmin) texXmin = tex[i][0];
                if (tex[i][0] > texXmax) texXmax = tex[i][0];
                if (tex[i][1] < texYmin) texYmin = tex[i][1];
                if (tex[i][1] > texYmax) texYmax = tex[i][1];

            }
            for(unsigned int i = 0; i < numberOfTexCoords; i++)
            {
                tex_normalized.push_back ( Eigen::Vector2f(
                                               (tex[i][0] - texXmin) / (texXmax - texXmin),
                                           (tex[i][1] - texYmin) / (texYmax - texYmin) ) );
            }
            createAttribute("in_TexCoords", tex_normalized);
        }
        else
        {
            createAttribute("in_TexCoords", tex);
        }
    }


    void loadColors (vector<Eigen::Vector4f> &clrs)
    {
        createAttribute("in_Color", clrs);
    }


    void loadIndices (vector<GLuint> &ind)
    {
        numberOfElements = ind.size();

        GLuint *indices = new GLuint[ind.size()];

        //Indices:
        for(unsigned int i = 0; i < ind.size(); i++)
        {
            indices[i] = ind[i];
        }

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *index_buffer_sptr);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, ind.size()*sizeof(GLuint), indices, GL_STATIC_DRAW);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

        delete [] indices;
    }

    void setDefaultAttribLocations (void)
    {
                resetLocations();
        for (unsigned int i = 0; i < vertex_attributes.size(); ++i)
        {
            if (!vertex_attributes[i].getName().compare("in_Position"))
            {
                vertex_attributes[i].setLocation(0);
            }
            else if (!vertex_attributes[i].getName().compare("in_Normal"))
            {
                vertex_attributes[i].setLocation(1);
            }
            else if (!vertex_attributes[i].getName().compare("in_Color"))
            {
                vertex_attributes[i].setLocation(2);
            }
            else if (!vertex_attributes[i].getName().compare("in_TexCoord"))
            {
                vertex_attributes[i].setLocation(3);
            }
        }
    }

    bool hasAttribute (const string& name) const
    {
        for (unsigned int i = 0; i < vertex_attributes.size(); ++i)
        {
            if (!vertex_attributes[i].getName().compare(name))
            {
                return true;
            }
        }
        return false;
    }


    VertexAttribute* getAttribute(const string& name)
    {
        for (unsigned int i = 0; i < vertex_attributes.size(); ++i)
        {
            if (!vertex_attributes[i].getName().compare(name))
            {
                return &vertex_attributes[i];
            }
        }
        return NULL;
    }

    void setAttributeLocation (Shader *shader)
    {       
        for (unsigned int i = 0; i < vertex_attributes.size(); ++i)
        {
            GLint loc = shader->getAttributeLocation(vertex_attributes[i].getName().c_str());
            vertex_attributes[i].setLocation(loc);
        }
        if (shader->getTessellationEvaluationShader() != 0)
            willTessellate = true;
        else
            willTessellate = false;
    }

        void setAttributeLocation (const Shader& shader)
        {
                setAttributeLocation((Shader*)(&shader));
        }


    void setAttributeLocation (string name, GLint loc)
    {
        for (unsigned int i = 0; i < vertex_attributes.size(); ++i)
        {
            if (!name.compare(vertex_attributes[i].getName()))
            {
                vertex_attributes[i].setLocation(loc);
            }
        }
    }


    VertexAttribute* createAttribute (string name, vector<Eigen::Vector4f> &attrib)
    {
        // create new vertex attribute
        VertexAttribute va (name, attrib.size(), 4, GL_FLOAT);

        float * attrib_array = new float[va.getSize()*va.getElementSize()];
        int temp = 0;
        for(int i = 0; i < va.getSize()*va.getElementSize(); i+=4) {
            attrib_array[i] = attrib[temp][0];
            attrib_array[i+1] = attrib[temp][1];
            attrib_array[i+2] = attrib[temp][2];
            attrib_array[i+3] = attrib[temp][3];
            temp++;
        }

        // fill buffer with attribute data
        va.bind();
        glBufferData(va.getArrayType(), va.getSize()*va.getElementSize()*sizeof(va.getType()), attrib_array, GL_STATIC_DRAW);
        va.unbind();

        vertex_attributes.push_back(va);
        delete [] attrib_array;
        return &vertex_attributes[vertex_attributes.size()-1];

    }

    VertexAttribute* createAttribute(string name, vector<Eigen::Vector3f> &attrib)
    {
        // create new vertex attribute
        VertexAttribute va (name, attrib.size(), 3, GL_FLOAT);

        float * attrib_array = new float[va.getSize()*va.getElementSize()];

        int temp = 0;
        for(int i = 0; i < va.getSize()*va.getElementSize(); i+=3) {
            attrib_array[i] = attrib[temp][0];
            attrib_array[i+1] = attrib[temp][1];
            attrib_array[i+2] = attrib[temp][2];
            temp++;
        }

        // fill buffer with attribute data
        va.bind();
        glBufferData(va.getArrayType(), va.getSize()*va.getElementSize()*sizeof(va.getType()), attrib_array, GL_STATIC_DRAW);
        va.unbind();

        vertex_attributes.push_back(va);
        delete [] attrib_array;
        return &vertex_attributes[vertex_attributes.size()-1];
    }

    VertexAttribute* createAttribute(string name, vector<Eigen::Vector2f> &attrib)
    {
        // create new vertex attribute
        VertexAttribute va (name, attrib.size(), 2, GL_FLOAT);

        float * attrib_array = new float[va.getSize()*va.getElementSize()];

        int temp = 0;
        for(int i = 0; i < va.getSize()*va.getElementSize(); i+=2) {
            attrib_array[i] = attrib[temp][0];
            attrib_array[i+1] = attrib[temp][1];
            temp++;
        }

        // fill buffer with attribute data
        va.bind();
        glBufferData(va.getArrayType(), va.getSize()*va.getElementSize()*sizeof(va.getType()), attrib_array, GL_STATIC_DRAW);
        va.unbind();

        vertex_attributes.push_back(va);
        delete [] attrib_array;
        return &vertex_attributes[vertex_attributes.size()-1];
    }


    virtual void bindBuffers (void) 
    {
        assert (vao_sptr != 0);

        glBindVertexArray(*vao_sptr); //Vertex Array Object

        if (*index_buffer_sptr)
        {
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *index_buffer_sptr);
        }

        // bind generic attributes
        for (unsigned int i = 0; i < vertex_attributes.size(); ++i)
        {
            vertex_attributes[i].enable();
        }

        #ifdef TUCANODEBUG
        Misc::errorCheckFunc(__FILE__, __LINE__);
        #endif
    }

    virtual void unbindBuffers (void) 
    {
        glBindVertexArray(0);
        glBindBuffer(GL_ARRAY_BUFFER,0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);

        for (unsigned int i = 0; i < vertex_attributes.size(); ++i)
        {
            vertex_attributes[i].disable();
        }
    }

    virtual void renderPoints (void)
    {
        glDrawArrays(GL_POINTS, 0, numberOfVertices);
    }

    virtual void renderElements (void) 
    {

        glDrawElements(GL_TRIANGLES, numberOfElements, GL_UNSIGNED_INT, (GLvoid*)0);
    }

    virtual void renderLineLoop (void)
    {
        glDrawArrays(GL_LINE_LOOP, 0, numberOfVertices);
    }


    virtual void renderPatches(void)
    {
        glPatchParameteri(GL_PATCH_VERTICES, 3);
        glDrawElements(GL_PATCHES, numberOfElements,GL_UNSIGNED_INT, 0);
    }

    virtual void render (void)
    {
        bindBuffers();
        if (numberOfElements == 0)
        {
            renderPoints();
        }
        else
        {
            if (willTessellate)
            {
                renderPatches();
            }
            else
            {
                renderElements();
            }
        }
        unbindBuffers();
    }

    void createParallelepiped(float x, float y, float z)
    {

        numberOfVertices = 32;
        numberOfElements = 36;
        //numberOfColors = 32;

        vector<Eigen::Vector4f> vert;
        vector<GLuint> ind;

        //Normalizing the cube coordinates:
        float scale = x;
        if (y > x) scale = y;
        if (z > scale) scale = z;

        vert.push_back( Eigen::Vector4f (-.5f*x/scale, -.5f*y/scale,  .5f*z/scale, 1) );
        vert.push_back( Eigen::Vector4f (-.5f*x/scale,  .5f*y/scale,  .5f*z/scale, 1) );
        vert.push_back( Eigen::Vector4f (.5f*x/scale,  .5f*y/scale,  .5f*z/scale, 1) );
        vert.push_back( Eigen::Vector4f (.5f*x/scale, -.5f*y/scale,  .5f*z/scale, 1) );
        vert.push_back( Eigen::Vector4f (-.5f*x/scale, -.5f*y/scale, -.5f*z/scale, 1) );
        vert.push_back( Eigen::Vector4f (-.5f*x/scale,  .5f*y/scale, -.5f*z/scale, 1) );
        vert.push_back( Eigen::Vector4f (.5f*x/scale,  .5f*y/scale, -.5f*z/scale, 1) );
        vert.push_back( Eigen::Vector4f (.5f*x/scale, -.5f*y/scale, -.5f*z/scale, 1) );

        GLuint tempIndices[36] = {
            0,2,1,  0,3,2,
            4,3,0,  4,7,3,
            4,1,5,  4,0,1,
            3,6,2,  3,7,6,
            1,6,5,  1,2,6,
            7,5,6,  7,4,5
        };

        for(unsigned int i = 0; i < numberOfElements;i++) {
            ind.push_back( tempIndices[i] );
        }

        /*float colors[32] =
    {
        0, 0, 1, 1,
        1, 0, 0, 1,
        0, 1, 0, 1,
        1, 1, 0, 1,
        1, 1, 1, 1,
        1, 0, 0, 1,
        1, 0, 1, 1,
        0, 0, 1, 1
    };*/

        loadVertices(vert);
        loadIndices(ind);

        setDefaultAttribLocations();
    }

    void createQuad (void)
    {
        vector<Eigen::Vector4f> vert;
        vector<Eigen::Vector2f> texCoord;
        vector<GLuint> elementsVertices;

        vert.push_back ( Eigen::Vector4f(-1.0, -1.0, 0.0, 1.0) );
        vert.push_back ( Eigen::Vector4f( 1.0, -1.0, 0.0, 1.0) );
        vert.push_back ( Eigen::Vector4f( 1.0,  1.0, 0.0, 1.0) );
        vert.push_back ( Eigen::Vector4f(-1.0,  1.0, 0.0, 1.0) );

        elementsVertices.push_back(0);
        elementsVertices.push_back(1);
        elementsVertices.push_back(2);
        elementsVertices.push_back(2);
        elementsVertices.push_back(3);
        elementsVertices.push_back(0);

        texCoord.push_back ( Eigen::Vector2f(0.0, 0.0) );
        texCoord.push_back ( Eigen::Vector2f(1.0, 0.0) );
        texCoord.push_back ( Eigen::Vector2f(1.0, 1.0) );
        texCoord.push_back ( Eigen::Vector2f(0.0, 1.0) );

        loadVertices(vert);
        loadTexCoords(texCoord);
        loadIndices(elementsVertices);

        setDefaultAttribLocations();

    }
};

}
#endif