OpenGL_drawer.cpp

Go to the documentation of this file.

#include <OpenGL_drawer.h>

OpenGL_drawer::OpenGL_drawer():draw_list()
{
  current_color.resize(3);
  draw_list.resize(0);
}

OpenGL_drawer::~OpenGL_drawer()
{
  unsigned int k=0;
  for(k=0;k<draw_list.size();k++)
    {
      if(glIsList(draw_list[k]))
        {
          glDeleteLists(draw_list[k],1);

          #ifdef DEBUG
          printf("[draw_list %d deleted]\n",k);
          #endif 
        }
    }

}

int OpenGL_drawer::init_opengl(int argc,char **argv,const Navigator_tool& navigator)
{
  //init window
  glutInit (&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  glutInitWindowPosition(0,0);
  glutInitWindowSize(navigator.get_X_screen(),navigator.get_Y_screen());
  glutCreateWindow("win_1");


  //OpenGL set
  glClearColor(1.0f,1.0f,1.0f,1.0f);
  glPointSize(5);
  glLineWidth(2);

  glEnable(GL_COLOR_MATERIAL);
  //glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
  glEnable(GL_DEPTH_TEST);
  glDepthMask(GL_TRUE);


  glFrontFace(GL_CCW);//clockwise CW or CCW
  glDisable(GL_CULL_FACE);
  //glEnable(GL_CULL_FACE);

  glDisable(GL_LIGHTING);
  glDisable(GL_BLEND);
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_FOG);



  //light
  float light_ambient[4]={0.4,0.4,0.4,1.0};
  float light_diffuse[4]={0.4,0.4,0.4,1.0};
  float light_specular[4]={1.0,1.0,1.0,1.0};
  float light_position [4] = {0.0,100.0,1000.0,1.0};

  float material_ambient [4] = {1.0,1.0,1.0,1.0};
  float material_diffuse [4] = {1.0,1.0,1.0,1.0};
  float material_specular [4] = {1.0,1.0,1.0,1.0};
  float material_exponent [1] = {60.0};


  glShadeModel(GL_SMOOTH);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);

  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material_ambient);
  glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material_diffuse);  
  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material_specular);  
  glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, material_exponent);
  glEnable(GL_DEPTH_TEST);


  glEnable(GL_LINE_SMOOTH);
  glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);

  return 0;
}





int OpenGL_drawer::draw_local_basis(Navigator_tool& navigator)
{
  
  glDisable(GL_LIGHTING);
  //glDisable(GL_DEPTH_TEST);

  glLoadIdentity();
  glTranslatef(0,0,navigator.get_dist_obs());
  glRotatef(navigator.get_theta_1(),1.0,0.0,0.0);
  glRotatef(navigator.get_theta_2(),0.0,1.0,0.0);

  glColor4f(1.0,0.0,0.0,1.0);
  glBegin(GL_LINES);
  glColor3f(1.0,0.0,0.0);
  glVertex3f(0.0,0.0,0.0);
  glVertex3f(0.01,0.0,0.0);

  glColor3f(0.0,1.0,0.0);
  glVertex3f(0.0,0.0,0.0);
  glVertex3f(0.0,0.01,0.0);

  glColor3f(0.0,0.0,1.0);
  glVertex3f(0.0,0.0,0.0);
  glVertex3f(0.0,0.0,0.01);
  glEnd();
  glTranslatef(0,0,navigator.get_dist_obs());

  //glEnable(GL_DEPTH_TEST);
  glEnable(GL_LIGHTING);

  return 0;
}






int OpenGL_drawer::draw_mesh_slow(Mesh_object& mesh)
{

  int N_polygons=0;
  int k_polygon=0;
  int N_vertex=0;
  int k_vertex=0;








  glEnable(GL_BLEND);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
  glColor4d(0.5,0.0,0.2,1.0);
  
  double r=0.0,g=0.0,b=0.0,t=0.0;

  double t0=0.0,t1=0.0;

  //texture
  if(mesh.texture_type()==0)
    {
      glEnable(GL_TEXTURE_2D);
      glBindTexture(GL_TEXTURE_2D,mesh.get_texture_number());
      glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    }

  N_polygons=mesh.polygon_number();
  V_3D x;
  V_3D n;
  for(k_polygon=0;k_polygon<N_polygons;k_polygon++)
    {
      N_vertex=mesh.polygon_size(k_polygon);
      glBegin(GL_POLYGON);
      for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
        {


          x = mesh.get_vertex_v3d(k_polygon,k_vertex);

          //NORMAL
          if(mesh.normal_type()==1)//per polygon
            n = mesh.get_polygon_normal(k_polygon);
          else if(mesh.normal_type()==2)//per vertex
            n = mesh.get_vertex_normal(k_polygon,k_vertex);
          else if(mesh.normal_type()==3)//per vertex and polygon
            n = mesh.get_polygon_and_vertex_normal(k_polygon,k_vertex);

          //COLOR
          if(mesh.color_type()==-1) //no color
            glColor4d(0.5,0.0,0.2,1.0);
          else if(mesh.color_type()==1) //per vertex
            {
              mesh.get_per_vertex_color(k_polygon,k_vertex,&r,&g,&b,&t);
              glColor4d(r,g,b,t);
            }
          else if(mesh.color_type()==2) //per polygon
            {
              mesh.get_per_polygon_color(k_polygon,&r,&g,&b,&t);
              glColor4d(r,g,b,t);
            }       
          else if(mesh.color_type()==3) //per polygon_and_vertex
            {
              mesh.get_per_polygon_and_vertex_color(k_polygon,k_vertex,&r,&g,&b,&t);
              glColor4d(r,g,b,t);
            }     
          //TEXTURE
          if(mesh.texture_type()==0)
            {
              mesh.get_intermediate_texture(k_polygon,k_vertex,&t0,&t1);
              glTexCoord2f(t0,1.0-t1);
            }


          glNormal3d(n[0],n[1],n[2]);
          glVertex3d(x[0],x[1],x[2]);
          
        }
      glEnd();      
    }
  
  glDisable(GL_BLEND);
  


      
  return 0;
}

int OpenGL_drawer::draw_mesh_grid(Mesh_object& mesh)
{
  int N_polygons=0;
  int k_polygon=0;
  int N_vertex=0;
  int k_vertex=0;



  glDisable(GL_LIGHTING);
  glEnable(GL_BLEND);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
  //glColor4d(0.5,0.8,0.2,1.0);
  
  N_polygons=mesh.polygon_number();
  V_3D x;
  for(k_polygon=0;k_polygon<N_polygons;k_polygon++)
    {
      N_vertex=mesh.polygon_size(k_polygon);
      glBegin(GL_LINE_STRIP);
      for(k_vertex=0;k_vertex<=N_vertex;k_vertex++)
        {
          x = mesh.get_vertex_v3d(k_polygon,(k_vertex%N_vertex));
          glVertex3d(x[0],x[1],x[2]);
        }
      glEnd();      
    }
      
  glDisable(GL_BLEND);
  glEnable(GL_LIGHTING);


  return 0;
}

int OpenGL_drawer::draw_segment(const Segment& s) const
{
  V_3D x0=s.get_start(),x1=s.get_last();
  glBegin(GL_LINES);
  glVertex3f(x0[0],x0[1],x0[2]);
  glVertex3f(x1[0],x1[1],x1[2]);
  glEnd();

  return 0;
}

int OpenGL_drawer::draw_triangle(const Triangle& t) const
{
  V_3D normal = t.normal();
  glBegin(GL_TRIANGLES);
  glNormal3d(normal[0],normal[1],normal[2]);
  glVertex3d(t[0][0],t[0][1],t[0][2]);
  glVertex3d(t[1][0],t[1][1],t[1][2]);
  glVertex3d(t[2][0],t[2][1],t[2][2]);
  glEnd();

  return 0;
}

int OpenGL_drawer::draw_polygon(const Polygon& p)const
{
  V_3D normal = p.normal();

  glNormal3d(normal[0],normal[1],normal[2]);

  glBegin(GL_POLYGON);
  for(int k=0;k<p.size();k++)
    glVertex3d(p[k][0],p[k][1],p[k][2]);
  glEnd();

  return 0;
}

int OpenGL_drawer::draw_curve(const Curve_3D& c) const
{
  int k_line=0,N_line=c.size();
  glDisable(GL_LIGHTING);
  glBegin(GL_LINE_STRIP);
  for(k_line=0;k_line<N_line;k_line++)
    glVertex3d(c[k_line][0],c[k_line][1],c[k_line][2]);
  glEnd();
  glEnable(GL_LIGHTING);
  
  return 0;
}

int OpenGL_drawer::draw_skeleton(Skeleton &skeleton)
{
  int k_joint;
  V_3D p0,p1;

  Joint *current=NULL;
  Joint *son=NULL;

  int k_son=0;
  int N_son=0;

  glDisable(GL_LIGHTING);
  glDisable(GL_DEPTH_TEST);

  glLineWidth(4.0);
  glBegin(GL_LINES);
  for(k_joint=0;k_joint<skeleton.get_N_joint()-1;k_joint++)
    {
      current = skeleton.get_joint(k_joint);
      p0 = skeleton.get_world_position_of_bone(current->get_access_number());

      N_son = current->get_N_son();

      set_current_color(current->get_access_number());
      glColor4d(current_color[0],current_color[1],current_color[2],1.0);
      for(k_son=0;k_son<N_son;k_son++)
        {
          son = current->get_son(N_son-k_son-1);
          p1 = skeleton.get_world_position_of_bone(son->get_access_number());

          set_current_color(k_son);

          glVertex3f(p0[0],p0[1],p0[2]);
          glVertex3f(p1[0],p1[1],p1[2]);
        }
    }
  glEnd();

  glEnable(GL_LIGHTING);
  glEnable(GL_DEPTH_TEST);
          
  return 0;

}

int OpenGL_drawer::set_current_color(int k_bone)
{

  double c1=abs(cos(double(k_bone*43252345.323+24)));
  double c2=abs(cos(double(k_bone*26252345.73+24)));
  double c3=abs(cos(double(k_bone*1214345.923+24)));
  current_color[0]=(c1+0.5)/2.0;
  current_color[1]=(c2+0.5)/2.0;
  current_color[2]=(c3+0.5)/2.0;

  return 0;
}


GLuint OpenGL_drawer::load_texture(const char* filename)
{
  GLuint texture_number;
  Texture tex;

  tex.load_picture(filename);


  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
  glGenTextures (1, &texture_number);
  glBindTexture (GL_TEXTURE_2D, texture_number);

  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);//GL_REPEAT
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  if(tex.get_depth()==4)
    gluBuild2DMipmaps (GL_TEXTURE_2D, tex.get_depth(), tex.get_Nx(), tex.get_Ny(), GL_RGBA,GL_UNSIGNED_BYTE, tex.get_data());
  if(tex.get_depth()==3)
    gluBuild2DMipmaps (GL_TEXTURE_2D, tex.get_depth(), tex.get_Nx(), tex.get_Ny(), GL_RGB,GL_UNSIGNED_BYTE, tex.get_data());

  return texture_number;
}