TriangleMesh.cpp

Go to the documentation of this file.

/**
 *\file         TriangleMesh.cpp
 *
 *\brief        
 *
 *\author       Xianming Chen
 *
 *\date         11 Jul 2004
 */


#include "TriangleMesh.h"
#include <fstream>
#include <iostream>
#include <cassert>
#include <string>
#include <GL/gl.h>


using namespace std;


namespace columbia
{

  static void skip_line(istream& is)
  {
    char next;
    while( is >> noskipws >> next && next != '\n' );
  }
  
  static bool skip_comment_line(istream& is, char comment_tag)
  {
    char next;
    while( is >> skipws >> next ) 
    {
      is.putback(next);
      if(next == comment_tag) skip_line(is);
      else
        return true;
    }
    return false;
  }


  TriangleMesh :: TriangleMesh(const char* obj_fname) : has_normal(false), has_texture(false), texImage(0)
  {
    ifstream is(obj_fname);

    if(is)
    {
      bool no_normal = true;
      bool no_tex = true;

      while( skip_comment_line(is, '#') ) 
      {
        string ele_id;
        float x, y, z;    

        if( ! (is >> ele_id) ) break;

        if(ele_id == "v")
        {
          is >> x >> y >> z;
          V.push_back( Vertex(x, y, z) );
        }
        else if(ele_id == "vt")
        {
          no_tex = false;
          is >> x >> y >> z;
          is.clear();                           // is z(i.e. w) is not available, have to clear error flag.
          T.push_back( Vector(x, y, z) );
        }
        else if(ele_id == "vn")
        {
          no_normal = false;
          is >> x >> y >> z;
          if(! is.good())                      // in case it is -1#IND00
          {
            x = y = z = 0.0;
            is.clear();
            skip_line(is);
          }
          N.push_back( Vector(x, y, z) );
        }
        else if(ele_id == "f")
        {
          int vi[10];                               // vertex indices.
          int ni[10] = { -1, -1, -1, -1, };         // normal indices.
          int ti[10] = { -1, -1, -1, -1, };         // tex indices.
          int i = 0;
          for(char c; i<10; ++i)
          {
            if(no_tex && no_normal) is >> vi[i];
            else if(no_tex)         is >> vi[i] >> c >> c >> ni[i];
            else if(no_normal)      is >> vi[i] >> c >> ti[i];
            else                    is >> vi[i] >> c >> ti[i] >> c >>  ni[i];

            if( ! is.good() )       break;
          }
          for(int k=0; k<=i-3; k++)
          {
            F.push_back( TriangleFace(vi[0]-1, vi[k+1]-1, vi[k+2]-1, ti[0]-1, ti[k+1]-1, ti[k+2]-1, ni[0]-1, ni[k+1]-1, ni[k+2]-1) );
          }
          is.clear();
        }
        else 
          skip_line(is);
      }
      is.close();
      init();
    }
    else 
      cerr << "Can't open input file " << obj_fname << endl;
  }

  void TriangleMesh :: init()
  {
    has_normal = N.size();
    has_texture = T.size();
    total_triangles = F.size();
    cout << "total vertices " << V.size() << endl;
    cout << "total normals " << N.size() << endl;
    cout << "total texture coordinates " << T.size() << endl;
    cout << "total triangles " << F.size() << endl;


    bbox = BBox(*this);
    cout << "bounding box is " << bbox << endl;
  }
  
  void TriangleMesh :: initTexture()
  {
    if(has_texture && texImage)
    {
      glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

      glGenTextures(1, &texName);
      glBindTexture(GL_TEXTURE_2D, texName);

      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texImage->hReso, texImage->vReso, 
                   0, GL_RGB, GL_FLOAT, texImage->data);
    }
  }


  void TriangleMesh :: glDraw() const
  {
    if(has_normal) 
    {
      glEnable(GL_LIGHTING);
      glEnable(GL_LIGHT0);
    }
    else
      glDisable(GL_LIGHTING);
    
    if(has_texture && texImage)
    {
      glEnable(GL_TEXTURE_2D);
      glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, has_normal? GL_MODULATE : GL_DECAL);
      glBindTexture(GL_TEXTURE_2D, texName);
      glEnable(GL_TEXTURE_2D);

      if(has_normal) 
      {
        glBegin(GL_TRIANGLES);
        {
          for(int f = 0; f < total_triangles; ++f)
          {
            int i = F[f].i, j = F[f].j, k = F[f].k;
            int ni = F[f].ni, nj = F[f].nj, nk = F[f].nk;
            int ti = F[f].ti, tj = F[f].tj, tk = F[f].tk;

            glTexCoord2f(T[ti].x, T[ti].y); glNormal3f( N[ni].x, N[ni].y, N[ni].z ); glVertex3f( V[i].x, V[i].y, V[i].z );
            glTexCoord2f(T[tj].x, T[tj].y); glNormal3f( N[nj].x, N[nj].y, N[nj].z ); glVertex3f( V[j].x, V[j].y, V[j].z );
            glTexCoord2f(T[tk].x, T[tk].y); glNormal3f( N[nk].x, N[nk].y, N[nk].z ); glVertex3f( V[k].x, V[k].y, V[k].z );
          }
        }
        glEnd();
      }
      else
      {
        glBegin(GL_TRIANGLES);
        {
          for(int f = 0; f < total_triangles; ++f)
          {
            int i = F[f].i, j = F[f].j, k = F[f].k;
            int ti = F[f].ti, tj = F[f].tj, tk = F[f].tk;

            glTexCoord2f(T[ti].x, T[ti].y); glVertex3f( V[i].x, V[i].y, V[i].z );
            glTexCoord2f(T[tj].x, T[tj].y); glVertex3f( V[j].x, V[j].y, V[j].z );
            glTexCoord2f(T[tk].x, T[tk].y); glVertex3f( V[k].x, V[k].y, V[k].z );
          }
        }
        glEnd();
      }
      glDisable(GL_TEXTURE_2D);
    }
    else
    {
      if(has_normal) 
      {
        glBegin(GL_TRIANGLES);
        {
          for(int f = 0; f < total_triangles; ++f)
          {
            int i = F[f].i, j = F[f].j, k = F[f].k;
            int ni = F[f].ni, nj = F[f].nj, nk = F[f].nk;

            glNormal3f( N[ni].x, N[ni].y, N[ni].z ); glVertex3f( V[i].x, V[i].y, V[i].z );
            glNormal3f( N[nj].x, N[nj].y, N[nj].z ); glVertex3f( V[j].x, V[j].y, V[j].z );
            glNormal3f( N[nk].x, N[nk].y, N[nk].z ); glVertex3f( V[k].x, V[k].y, V[k].z );
          }
        }
        glEnd();
      }
      else
      {
        glBegin(GL_TRIANGLES);
        {
          for(int f = 0; f < total_triangles; ++f)
          {
            int i = F[f].i, j = F[f].j, k = F[f].k;

            glVertex3f( V[i].x, V[i].y, V[i].z );
            glVertex3f( V[j].x, V[j].y, V[j].z );
            glVertex3f( V[k].x, V[k].y, V[k].z );
          }
        }
        glEnd();
      }
    }
  }
  


};

---