MC_opengl_drawer.cpp

Go to the documentation of this file.

#include <MC_opengl_drawer.hpp>

#include <MC_string_helper.hpp>
#include <MC_mesh_index_vector.hpp>
#include <MC_mesh_index_vector_draw.hpp>
#include <MC_mesh_fast_draw.hpp>
#include <MC_polygon.hpp>
#include <MC_v3d.hpp>
#include <MC_segment.hpp>
#include <MC_polygon.hpp>




namespace mesh_conv
{
    MC_opengl_drawer::MC_opengl_drawer(){}

    void MC_opengl_drawer::draw_per_polygon_color(const MC_mesh_index_vector& mesh,const MC_v3d_vector& color_per_polygon)
    {
        if(color_per_polygon.size()!=mesh.polygon_number())
        {std::cout<<"Error in MC_opengl_drawer::draw_per_polygon_color(), size of color="<<color_per_polygon.size()<<" while polygon number="<<mesh.polygon_number()<<std::endl;exit(-1);}

        // alpha channel
        glEnable(GL_BLEND);
        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        int N_polygon=mesh.polygon_number();
        for(int k_polygon=0;k_polygon<N_polygon;k_polygon++)
        {
            int poly_size=mesh.polygon_size(k_polygon);
            MC_polygon p=mesh.get_polygon(k_polygon);


            //normal
            MC_v3d n=p.normal();
            glNormal3d(n[0],n[1],n[2]);

            const MC_v3d& col=color_per_polygon[k_polygon];
            glColor3dv(col.pointer());

            glBegin(GL_POLYGON);
            for(int k_vertex=0;k_vertex<poly_size;k_vertex++)
            {
                const MC_v3d& x=p[k_vertex];
                glVertex3d(x[0],x[1],x[2]);
            }
            glEnd();
        }


        glDisable(GL_BLEND);
    }
  const MC_mesh_index_vector& MC_opengl_drawer::draw(const MC_mesh_index_vector& mesh)
    {

        // alpha channel
        glEnable(GL_BLEND);
        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        int N_polygon=mesh.polygon_number();
        for(int k_polygon=0;k_polygon<N_polygon;k_polygon++)
        {
            int poly_size=mesh.polygon_size(k_polygon);
            MC_polygon p=mesh.get_polygon(k_polygon);


            //normal
            MC_v3d n=p.normal();
            glNormal3d(n[0],n[1],n[2]);

            glBegin(GL_POLYGON);
            for(int k_vertex=0;k_vertex<poly_size;k_vertex++)
            {
                MC_v3d x=p[k_vertex];
                glVertex3d(x[0],x[1],x[2]);
            }
            glEnd();
        }


        glDisable(GL_BLEND);

        return mesh;
    }


    const MC_mesh_fast_draw& MC_opengl_drawer::draw(const MC_mesh_fast_draw& mesh)
    {
        const MC_double_vector& vertex=mesh.point_set();
        const MC_double_vector& color=mesh.color();
        const MC_double_vector& texture=mesh.texture();
        const MC_double_vector& normal=mesh.normal();
        const std::map <int,MC_int_vector>& connectivity=mesh.connectivity();

        const double* p_vertex=vertex.pointer();
        const double* p_color=color.pointer();
        const double* p_texture=texture.pointer();
        const double* p_normal=normal.pointer();

        glEnable(GL_LIGHTING);
        glEnable(GL_BLEND);
        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_COLOR_MATERIAL);



        bool is_color=(color.size()==vertex.size());
        bool is_texture=(texture.size()!=0);


        std::map <int,MC_int_vector>:: const_iterator it;
        for(it=connectivity.begin();it!=connectivity.end();++it)
        {
            int current_size=it->first;
            const MC_int_vector& current_connectivity=it->second;
            const int* p_connectivity=current_connectivity.pointer();

            if(current_size==3 || current_size==4)
            {
                glEnableClientState(GL_VERTEX_ARRAY);
                glEnableClientState(GL_NORMAL_ARRAY);
                if(is_color)
                    glEnableClientState(GL_COLOR_ARRAY);
                if(is_texture)
                {
                    //glEnable(GL_TEXTURE_2D);
                    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
                }

                glVertexPointer(3,GL_DOUBLE,0,p_vertex);
                glNormalPointer(GL_DOUBLE,0,p_normal);
                if(is_color)
                    glColorPointer(3,GL_DOUBLE,0,p_color);
                if(is_texture)
                    glTexCoordPointer(2,GL_DOUBLE,0,p_texture);



                if(current_size==3)
                    glDrawElements(GL_TRIANGLES,current_connectivity.size(),GL_UNSIGNED_INT,p_connectivity);
                else
                    glDrawElements(GL_QUADS,current_connectivity.size(),GL_UNSIGNED_INT,p_connectivity);

                glDisableClientState(GL_VERTEX_ARRAY);
                glDisableClientState(GL_NORMAL_ARRAY);
                glDisableClientState(GL_COLOR_ARRAY);
                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
            }
            else
            {
                for(int k_polygon=0;k_polygon<current_connectivity.size();k_polygon+=current_size)
                {
                    glBegin(GL_POLYGON);
                    for(int k_size=0;k_size<current_size;++k_size)
                    {
                        if(is_color==true)
                            glColor3dv( p_color+3*current_connectivity[k_polygon+k_size] );
                        if(is_texture==true)
                            glTexCoord2dv( p_texture+2*current_connectivity[k_polygon+k_size] );
                        glNormal3dv( p_normal+3*current_connectivity[k_polygon+k_size] );
                        glVertex3dv( p_vertex+3*current_connectivity[k_polygon+k_size] );

                    }
                    glEnd();
                }

            }
        }


        glDisable(GL_LIGHTING);
        glDisable(GL_BLEND);

        return mesh;
    }


    const MC_mesh_index_vector_draw& MC_opengl_drawer::draw(const MC_mesh_index_vector_draw& mesh)
    {

        bool is_vertex_normal = (mesh.normal().size()==mesh.point_set().size());
        bool is_vertex_color = (mesh.color().size()==mesh.point_set().size());
        bool is_texture = (mesh.texture().size()!=0 && mesh.texture_connectivity().size()==mesh.polygon_number());
//        if(is_texture)
//        {
//            //glEnable(GL_TEXTURE_2D);
//            //glBindTexture(GL_TEXTURE_2D,1);
//            glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//        }

        //std::cout<<is_texture<<std::endl;

        // alpha channel
        glEnable(GL_BLEND);
        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_COLOR_MATERIAL);
        glEnable(GL_LIGHTING);

        int N_polygon=mesh.polygon_number();
        for(int k_polygon=0;k_polygon<N_polygon;k_polygon++)
        {
            MC_int_vector index=mesh.connectivity()(k_polygon);

            MC_int_vector index_texture;
            if(is_texture==true)
                index_texture=mesh.texture_connectivity()(k_polygon);

            int poly_size=index.size();

            glBegin(GL_POLYGON);
            for(int k_vertex=0;k_vertex<poly_size;++k_vertex)
            {
                int u=index(k_vertex);

                MC_v3d x=mesh.point_set()[u];
                if(is_vertex_normal)
                {MC_v3d n=mesh.normal()[u];glNormal3dv(n.pointer());}
                if(is_vertex_color)
                {MC_v3d c=mesh.color()[u];glColor3dv(c.pointer());}
                if(is_texture)
                {
                    int utex=index_texture(k_vertex);
                    MC_v3d t=mesh.texture()[utex];

                    glTexCoord2dv(t.pointer());

                }

                glVertex3dv(x.pointer());
            }
            glEnd();
        }


        glDisable(GL_BLEND);

        return mesh;
    }
    
    GLuint MC_opengl_drawer::send_gpu(const MC_mesh_fast_draw& mesh)
    {
        GLuint new_draw_list=glGenLists(1);
        glNewList(new_draw_list,GL_COMPILE);
        MC_opengl_drawer::draw(mesh);
        glEndList();
//
//
//
//        const MC_double_vector& vertex=mesh.point_set();
//        const MC_double_vector& color=mesh.color();
//        const MC_double_vector& texture=mesh.texture();
//        const MC_double_vector& normal=mesh.normal();
//        const std::map <int,MC_int_vector>& connectivity=mesh.connectivity();
//
//        const double* p_vertex=vertex.pointer();
//        const double* p_color=color.pointer();
//        const double* p_texture=texture.pointer();
//        const double* p_normal=normal.pointer();
//
//        GLuint vboId=0;
//        glGenBuffersARB(1, &vboId);
//        glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboId);
//        glBufferDataARB(GL_ARRAY_BUFFER_ARB, vertex.size(), p_vertex, GL_STATIC_DRAW_ARB);
//        glEnableClientState (GL_VERTEX_ARRAY);
//
//
//        vboId2 = createVBO(teapotIndices, sizeof(teapotIndices), GL_ELEMENT_ARRAY_BUFFER_ARB, GL_STATIC_DRAW_ARB);
//


        return new_draw_list;
    }

    const MC_segment& MC_opengl_drawer::draw(const MC_segment& segment)
    {
        glBegin(GL_LINES);
        glVertex3dv(segment[0].pointer());
        glVertex3dv(segment[1].pointer());
        glEnd();
        return segment;
    }
    const std::vector<MC_segment>& MC_opengl_drawer::draw(const std::vector<MC_segment>& segments)
    {
        glBegin(GL_LINES);
        for(int k=0,N=segments.size();k<N;++k)
        {
            glVertex3dv(segments[k][0].pointer());
            glVertex3dv(segments[k][1].pointer());
        }
        glEnd();
        return segments;
    }

    const MC_curve& MC_opengl_drawer::draw(const MC_curve& curve)
    {
        int N=curve.size();
        glBegin(GL_LINE_STRIP);
        for(int k=0;k<N;++k)
            glVertex3dv(curve[k].pointer());
        glEnd();

        return curve;
    }


    void MC_opengl_drawer::draw_sphere(const MC_v3d& position,const double& radius,const int& N_subdiv)
    {
        draw(MC_mesh_fast_draw(MC_mesh_index_vector::build_sphere(N_subdiv)*radius+position));
    }
    void MC_opengl_drawer::draw_points(const MC_v3d_vector& position)
    {
        glBegin(GL_POINTS);
        for(int k=0,N=position.size();k<N;++k)
            glVertex3dv(position[k].pointer());
        glEnd();
    }
    void MC_opengl_drawer::draw_sphere(const MC_v3d_vector& position,const double& radius,const int& N_subdiv)
    {
        MC_mesh_fast_draw sph=MC_mesh_fast_draw(MC_mesh_index_vector::build_sphere(N_subdiv)*radius);
        int N=position.size();
        glMatrixMode(GL_MODELVIEW);

        for(int k=0;k<N;++k)
        {
            glPushMatrix();
            glTranslated(position[k][0],position[k][1],position[k][2]);
            draw(sph);
            glPopMatrix();
        }
    }


    GLuint MC_opengl_drawer::send_gpu_grid(const MC_mesh_index_vector& mesh)
    {
        GLuint new_draw_list=glGenLists(1);
        glNewList(new_draw_list,GL_COMPILE);
        MC_opengl_drawer::draw_grid(mesh);
        glEndList();
        return new_draw_list;
    }
    const MC_mesh_index_vector& MC_opengl_drawer::draw_grid(const MC_mesh_index_vector& mesh)
    {
        int N=mesh.polygon_number();
        for(int k=0;k<N;++k)
        {
            glBegin(GL_LINE_STRIP);
            MC_int_vector index=mesh.connectivity()(k);
            int N_size=index.size();
            for(int k_poly=0;k_poly<=N_size;++k_poly)
                glVertex3dv(mesh.point_set()(index(k_poly%N_size)).pointer());
            glEnd();
        }

        return mesh;
    }
    const MC_mesh_fast_draw& MC_opengl_drawer::draw_grid(const MC_mesh_fast_draw& mesh)
    {
        std::map<int,MC_int_vector> connec=mesh.connectivity();
        std::map<int,MC_int_vector> ::const_iterator it_connec=connec.begin();
        std::map<int,MC_int_vector> ::const_iterator it_connec_end=connec.end();

        const double* v=mesh.point_set().pointer();

        for(;it_connec!=it_connec_end;it_connec++)
        {

            int N_size=it_connec->first;
            int N_poly=it_connec->second.size()/N_size;

            for(int k_poly=0;k_poly<N_poly;++k_poly)
            {
                glBegin(GL_LINE_STRIP);
                for(int k_vertex=0;k_vertex<=N_size;++k_vertex)
                {
                    int index=it_connec->second(k_poly*N_size+k_vertex%N_size);
                    glVertex3dv(v+3*index);
                }
                glEnd();
            }



        }


        return mesh;
    }
    const std::vector <MC_curve>& MC_opengl_drawer::draw(const std::vector <MC_curve>& curves)
    {
        int N=curves.size();
        for(int k=0;k<N;++k)
            draw(curves[k]);
        return curves;
    }
    const MC_polygon& MC_opengl_drawer::draw(const MC_polygon& polygon)
    {
        int N=polygon.size();
        MC_v3d n=polygon.normal();

        glBegin(GL_POLYGON);
        glNormal3dv(n.pointer());
        for(int k=0;k<N;++k)
            glVertex3dv(polygon[k].pointer());
        glEnd();

        return polygon;
    }

    const MC_mesh_index_vector& MC_opengl_drawer::draw_normal_per_polygon(const MC_mesh_index_vector& mesh,const double& L)
    {
        MC_v3d_vector nn=mesh.normal_polygon();
        MC_v3d_vector bar=MC_v3d_vector::zeros(nn.size());
        for(int k=0,N=nn.size();k<N;++k)
            bar[k]=mesh.get_polygon(k).barycenter();
        for(int k=0,N=nn.size();k<N;++k)
            draw(MC_segment(bar[k],bar[k]+L*nn[k]));
        return mesh;
    }

    MC_opengl_drawer MC_opengl_drawer::draw_triangular(const mesh::cgal::MC_mesh_cgal& mesh)
    {
        std::cout<<"Warning MC_opengl_drawer::draw_triangular not implemented"<<std::endl;
        exit(-1);
        //mesh::cgal::MC_mesh_cgal_drawer::draw_triangular(mesh);
        return MC_opengl_drawer();
    }


}