main.cpp

Go to the documentation of this file.

#include "LOD_decimation.h"
#include "ply/ply.h"
#include "MEM_SmartPtr.h"
#include "common/GlutDrawer.h"
#include "GlutMeshDrawer.h"
#include "MyGlutKeyHandler.h"
#include "MyGlutMouseHandler.h"
#include "MT_Vector3.h"
#include "LOD_GhostTestApp.h"

#include <memory>

#define DEBUG_PRINT 0

struct LoadVertex {
  float x,y,z;             /* the usual 3-space position of a vertex */
};

struct LoadFace {
  unsigned char intensity; /* this user attaches intensity to faces */
  unsigned char nverts;    /* number of vertex indices in list */
  int *verts;              /* vertex index list */
};

 
     LOD_Decimation_InfoPtr 
NewVertsFromFile(
    char * file_name,
    MT_Vector3 &min,
    MT_Vector3 &max
) {

    min = MT_Vector3(MT_INFINITY,MT_INFINITY,MT_INFINITY);
    max = MT_Vector3(-MT_INFINITY,-MT_INFINITY,-MT_INFINITY);

    
    PlyProperty vert_props[] = { /* list of property information for a vertex */
      {"x", PLY_FLOAT, PLY_FLOAT, offsetof(LoadVertex,x), 0, 0, 0, 0},
      {"y", PLY_FLOAT, PLY_FLOAT, offsetof(LoadVertex,y), 0, 0, 0, 0},
      {"z", PLY_FLOAT, PLY_FLOAT, offsetof(LoadVertex,z), 0, 0, 0, 0},
    };

    PlyProperty face_props[] = { /* list of property information for a vertex */
      {"intensity", PLY_UCHAR, PLY_UCHAR, offsetof(LoadFace,intensity), 0, 0, 0, 0},
      {"vertex_indices", PLY_INT, PLY_INT, offsetof(LoadFace,verts),
       1, PLY_UCHAR, PLY_UCHAR, offsetof(LoadFace,nverts)},
    };
#if 0
    MEM_SmartPtr<std::vector<float> > verts = new std::vector<float>;
    MEM_SmartPtr<std::vector<float> > vertex_normals = new std::vector<float>;

    MEM_SmartPtr<std::vector<int> > faces = new std::vector<int>;
#else
    std::vector<float>* verts = new std::vector<float>;
    std::vector<float>*  vertex_normals = new std::vector<float>;

    std::vector<int> * faces = new std::vector<int>;
#endif

  int i,j;
  PlyFile *ply;
  int nelems;
  char **elist;
  int file_type;
  float version;
  int nprops;
  int num_elems;
  PlyProperty **plist;

  char *elem_name;

    LoadVertex load_vertex;
    LoadFace load_face;

  /* open a PLY file for reading */
  ply = ply_open_for_reading(file_name, &nelems, &elist, &file_type, &version);

 if (ply == NULL) return NULL;
  /* go through each kind of element that we learned is in the file */
  /* and read them */

  for (i = 0; i < nelems; i++) {

    /* get the description of the first element */

    elem_name = elist[i];
    plist = ply_get_element_description (ply, elem_name, &num_elems, &nprops);

    /* print the name of the element, for debugging */

    /* if we're on vertex elements, read them in */
    if (equal_strings ("vertex", elem_name)) {

      /* set up for getting vertex elements */

      ply_get_property (ply, elem_name, &vert_props[0]);
      ply_get_property (ply, elem_name, &vert_props[1]);
      ply_get_property (ply, elem_name, &vert_props[2]);

        // make some memory for the vertices        
        verts->reserve(num_elems);

      /* grab all the vertex elements */
      for (j = 0; j < num_elems; j++) {

        /* grab and element from the file */
        ply_get_element (ply, (void *)&load_vertex);
        // pass the vertex into the mesh builder.
            
    
        if (load_vertex.x < min.x()) {
            min.x() = load_vertex.x;
        } else
        if (load_vertex.x > max.x()) {
            max.x()= load_vertex.x;
        }

        if (load_vertex.y < min.y()) {
            min.y() = load_vertex.y;
        } else
        if (load_vertex.y > max.y()) {
            max.y()= load_vertex.y;
        }

        if (load_vertex.z < min.z()) {
            min.z() = load_vertex.z;
        } else
        if (load_vertex.z > max.z()) {
            max.z()= load_vertex.z;
        }

        verts->push_back(load_vertex.x);
        verts->push_back(load_vertex.y);
        verts->push_back(load_vertex.z);

        vertex_normals->push_back(1.0f);
        vertex_normals->push_back(0.0f);
        vertex_normals->push_back(0.0f);


      }
    }

    /* if we're on face elements, read them in */
    if (equal_strings ("face", elem_name)) {

      /* set up for getting face elements */

 //     ply_get_property (ply, elem_name, &face_props[0]);
      ply_get_property (ply, elem_name, &face_props[1]);

      /* grab all the face elements */
      for (j = 0; j < num_elems; j++) {

        ply_get_element (ply, (void *)&load_face);

        faces->push_back(load_face.verts[0]);
        faces->push_back(load_face.verts[1]);
        faces->push_back(load_face.verts[2]);

        // free up the memory this pile of shit used to allocate the polygon's vertices

        free (load_face.verts);
      }

    }
  }
  /* close the PLY file */
  ply_close (ply);

  LOD_Decimation_InfoPtr output = new LOD_Decimation_Info;

  output->vertex_buffer = verts->begin();
  output->vertex_num = verts->size()/3;

  output->triangle_index_buffer = faces->begin();
  output->face_num = faces->size()/3;
  output->intern = NULL;
  output->vertex_normal_buffer = vertex_normals->begin();

  // memory leaks 'r' us    
#if 0
  verts.Release();
  vertex_normals.Release();
  faces.Release();
#endif
  return output;
}
    

void
init(MT_Vector3 min,MT_Vector3 max)
{
 
    GLfloat light_diffuse0[] = {1.0, 0.0, 0.0, 0.5};  /* Red diffuse light. */
    GLfloat light_position0[] = {1.0, 1.0, 1.0, 0.0};  /* Infinite light location. */

    GLfloat light_diffuse1[] = {1.0, 1.0, 1.0, 0.5};  /* Red diffuse light. */
    GLfloat light_position1[] = {1.0, 0, 0, 0.0};  /* Infinite light location. */

  /* Enable a single OpenGL light. */
  glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse0);
  glLightfv(GL_LIGHT0, GL_POSITION, light_position0);

  glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse1);
  glLightfv(GL_LIGHT1, GL_POSITION, light_position1);

  glEnable(GL_LIGHT0);
//  glEnable(GL_LIGHT1);
  glEnable(GL_LIGHTING);

    // use two sided lighting model
    
    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);

  /* Use depth buffering for hidden surface elimination. */
  glEnable(GL_DEPTH_TEST);

  /* Setup the view of the cube. */
  glMatrixMode(GL_PROJECTION);

    // center of the box + 3* depth of box

  MT_Vector3 center = (min + max) * 0.5;
  MT_Vector3 diag = max - min;

    float depth = diag.length();
    float distance = 2;

  gluPerspective( 
    /* field of view in degree */ 40.0,
    /* aspect ratio */ 1.0,
    /* Z near */ 1.0, 
    /* Z far */ distance * depth * 2
  );
  glMatrixMode(GL_MODELVIEW);   


  gluLookAt(
    center.x(), center.y(), center.z() + distance*depth,  /* eye is at (0,0,5) */
    center.x(), center.y(), center.z(),      /* center is at (0,0,0) */
    0.0, 1.0, 0.);      /* up is in positive Y direction */

  glPushMatrix();   


}

int
main(int argc, char **argv)
{

// load in the mesh

    MT_Vector3 mesh_min,mesh_max;

    LOD_Decimation_InfoPtr LOD_info = NewVertsFromFile("beethoven.ply",mesh_min,mesh_max);

    // load the mesh data 

    int load_result = LOD_LoadMesh(LOD_info);
    int preprocess_result = LOD_PreprocessMesh(LOD_info);

    if (!(load_result && preprocess_result)) {
        cout << " could not load mesh! \n";
        return 0;
    }

    // make and install a mouse handler

    MEM_SmartPtr<MyGlutMouseHandler> mouse_handler(MyGlutMouseHandler::New());
    GlutMouseManager::Instance()->InstallHandler(mouse_handler);

    // instantiate the drawing class    

    MEM_SmartPtr<GlutMeshDrawer> drawer(GlutMeshDrawer::New());
    GlutDrawManager::Instance()->InstallDrawer(drawer);
    drawer->SetLODInfo(LOD_info);   
    drawer->SetMouseHandler(mouse_handler);

    // make and install a keyhandler

    MEM_SmartPtr<MyGlutKeyHandler> key_handler(MyGlutKeyHandler::New(LOD_info));
    GlutKeyboardManager::Instance()->InstallHandler(key_handler);


    LOD_GhostTestApp LOD_app;

    LOD_app.InitApp();
    init(mesh_min,mesh_max);

    LOD_app.Run();


    return 0;             /* ANSI C requires main to return int. */
}