WebSVN – gelsvn – Diff – /branches/cpp11-devel/apps/Raytracer/raytrace.cpp

 using namespace Geometry;
 using namespace HMesh;
 using namespace GLGraphics;
 /*
  * TODO:
  * - BBOX remove HMesh dependency - that is crazy.
  * - BBox visit child nodes in order of how far away the intersection point on
  *        the bbox is. Closest nodes visited first. Cull nodes farther than
  *        an actual intersection point.
  * - BBox Smooth interpolation of triangle normals. Straightforward.
  */
 namespace
+{
-  const int MAX_OBJECTS = 4;   // Maximum number of triangles in a BSP tree node
+    const int MAX_OBJECTS = 4;   // Maximum number of triangles in a BSP tree node
-  const int MAX_LEVEL = 20;    // Maximum number of BSP tree subdivisions
+    const int MAX_LEVEL = 20;    // Maximum number of BSP tree subdivisions
-  const unsigned int TEX_SIZE = 512;
+    const unsigned int TEX_SIZE = 512;
-  bool raytrace = false;
+    bool raytrace = false;
-  bool done = false;
+    bool done = false;
-  bool shadow = false;
+    bool shadow = false;
-  unsigned int winx = TEX_SIZE;     // Screen width
+    unsigned int winx = TEX_SIZE;     // Screen width
-  unsigned int winy = TEX_SIZE;     // Screen height
+    unsigned int winy = TEX_SIZE;     // Screen height
-  unsigned int PIXEL_SUBDIVS = 1;
+    unsigned int PIXEL_SUBDIVS = 1;
-  int mouse_state = GLUT_UP;
+    int mouse_state = GLUT_UP;
-  int mouse_button = 0;
+    int mouse_button = 0;
-  int spin_timer = 20;
+    int spin_timer = 20;
-  GLViewController *vctrl;
+    GLViewController *vctrl;
-  TriMesh mesh;
+    TriMesh mesh;
-  vector<const TriMesh*> mesh_vector(1, &mesh);
+    vector<const TriMesh*> mesh_vector(1, &mesh);
-  vector<Mat4x4f> transforms(1, identity_Mat4x4f());
+    vector<Mat4x4f> transforms(1, identity_Mat4x4f());
-  double light_pow = 1.0;
+    double light_pow = 1.0;
-  Vec3f light_dir = normalize(Vec3f(1.0, 1.0, 1.0));
+    Vec3f light_dir = normalize(Vec3f(1.0, 1.0, 1.0));
-  Vec3d background(0.8, 0.9, 1.0);
+    Vec3d background(0.8, 0.9, 1.0);
-  BSPTree tree;
+    BSPTree tree;
-  Camera* cam;
+    Camera* cam;
-  Vec3f image[TEX_SIZE][TEX_SIZE];
+    Vec3f image[TEX_SIZE][TEX_SIZE];
-  unsigned int image_tex;
+    unsigned int image_tex;
-  // Function to generate a random number between 0 and 1.
+    // Function to generate a random number between 0 and 1.
-  // gel_rand() returns a random number ranging from 0 to GEL_RAND_MAX.
+    // gel_rand() returns a random number ranging from 0 to GEL_RAND_MAX.
-  inline double my_random()
+    inline double my_random()
-  {
+    {
-    return gel_rand()/static_cast<double>(GEL_RAND_MAX);
+        return gel_rand()/static_cast<double>(GEL_RAND_MAX);
-  }
+    }
-  AABBTree bb_tree;
+    AABBTree bb_tree;
+}
 void spin(int x);
 //////////////////////////////////////////////////////////////
 //      I N I T I A L I Z A T I O N
 //////////////////////////////////////////////////////////////
 void init_texture(unsigned int& tex)
+{
-  glGenTextures(1, reinterpret_cast<GLuint*>(&tex));
+    glGenTextures(1, reinterpret_cast<GLuint*>(&tex));
-  glBindTexture(GL_TEXTURE_2D, tex);
+    glBindTexture(GL_TEXTURE_2D, tex);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  // load the texture image
+    // load the texture image
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
 	             TEX_SIZE, TEX_SIZE,
 , GL_RGB, GL_FLOAT, image[0][0].get());
+}
 void initRaytracer()
+{
-  Vec3f c;
+    Vec3f c;
-  float r;
+    float r;
-  mesh.get_bsphere(c, r);
+    mesh.get_bsphere(c, r);
-  r *= 1.5;
+    r *= 1.5;
-  // Initialize track ball
+    // Initialize track ball
-  vctrl = new GLViewController(winx, winy, c, r);
+    vctrl = new GLViewController(winx, winy, c, r);
-  // Initialize corresponding camera
+    // Initialize corresponding camera
-  cam = new Camera(c - Vec3f(r), c, Vec3f(0.0f, 1.0f, 0.0f), 1.0f);
+    cam = new Camera(c - Vec3f(r), c, Vec3f(0.0f, 1.0f, 0.0f), 1.0f);
 #ifdef USE_BSP
-   cout << "Constructing BSP tree..." << endl;
+    cout << "Constructing BSP tree..." << endl;
-   tree.init(mesh_vector, transforms, MAX_OBJECTS, MAX_LEVEL);
+    tree.init(mesh_vector, transforms, MAX_OBJECTS, MAX_LEVEL);
-   tree.build();
+    tree.build();
 #else
 	// AABB TREE
 	Manifold m;
 	vector<int> faces(mesh.geometry.no_faces(), 3);
 	cout << "Creating manifold" << endl;
 #endif
+}
 void initGL()
+{
-  glShadeModel(GL_SMOOTH);
+    glShadeModel(GL_SMOOTH);
-  glDisable(GL_CULL_FACE);
+    glDisable(GL_CULL_FACE);
-  glFrontFace(GL_CCW);
+    glFrontFace(GL_CCW);
-  glClearColor(1.0, 1.0, 1.0, 1.0);
+    glClearColor(1.0, 1.0, 1.0, 1.0);
-  glColor3f(0.0, 0.0, 0.0);
+    glColor3f(0.0, 0.0, 0.0);
+}
 //////////////////////////////////////////////////////////////
 //      S H A D E   F U N C T I O N S
 //////////////////////////////////////////////////////////////
 double shadow_shade(Ray& r)
+{
-  r.compute_position();
+    r.compute_position();
-  Ray shadow(r.hit_pos, light_dir);
+    Ray shadow(r.hit_pos, light_dir);
-  double s = tree.intersect(shadow) ? 0.0 : 1.0;
+    double s = tree.intersect(shadow) ? 0.0 : 1.0;
-  r.compute_normal();
+    r.compute_normal();
-  return s*light_pow*dot(r.hit_normal, light_dir);
+    return s*light_pow*dot(r.hit_normal, light_dir);
+}
 double lambertian_shade(Ray& r)
+{
 #ifdef USE_BSP
 	r.compute_normal();
 #endif
-  return light_pow*dot(r.hit_normal, light_dir);
+    return light_pow*dot(r.hit_normal, light_dir);
+}
 double (*shade_ray[2])(Ray&) = { lambertian_shade,
-				                         shadow_shade      };
+    shadow_shade      };
 //////////////////////////////////////////////////////////////
 //      D R A W   F U N C T I O N S
 //////////////////////////////////////////////////////////////
 /*
-void enable_textures(TriMesh& tm)
+ void enable_textures(TriMesh& tm)
-{
+ {
-  for(unsigned int i=0;i<tm.materials.size(); ++i)
+ for(unsigned int i=0;i<tm.materials.size(); ++i)
-  {
+ {
-    Material& mat = tm.materials[i];
+ Material& mat = tm.materials[i];
-    if(mat.tex_name != "")
+ if(mat.tex_name != "")
-    {
+ {
-      string name = mat.tex_path + mat.tex_name;
+ string name = mat.tex_path + mat.tex_name;
-      GLuint tex_id;
+ GLuint tex_id;
-      if(load_image_into_texture(name, tex_id))
+ if(load_image_into_texture(name, tex_id))
-	mat.tex_id = tex_id;
+ mat.tex_id = tex_id;
-    }
+ }
-  }
+ }
-}
+ }
-*/
+ */
 void set_perspective_proj()
+{
-  glMatrixMode(GL_PROJECTION);
+    glMatrixMode(GL_PROJECTION);
-  glLoadIdentity();
+    glLoadIdentity();
-  gluPerspective(64.0, 1.0, 0.1, 1000.0);
+    gluPerspective(64.0, 1.0, 0.1, 1000.0);
-  glMatrixMode(GL_MODELVIEW);
+    glMatrixMode(GL_MODELVIEW);
+}
 void set_ortho_proj()
+{
-  glMatrixMode(GL_PROJECTION);
+    glMatrixMode(GL_PROJECTION);
-  glLoadIdentity();
+    glLoadIdentity();
-  glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
+    glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
-  glMatrixMode(GL_MODELVIEW);
+    glMatrixMode(GL_MODELVIEW);
+}
 void draw_texture(unsigned int tex)
+{
-  static GLfloat verts[] = { 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0 };
+    static GLfloat verts[] = { 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0 };
-  glColor4f(1.0, 1.0, 1.0, 1.0);
+    glColor4f(1.0, 1.0, 1.0, 1.0);
-  glBindTexture(GL_TEXTURE_2D, tex);
+    glBindTexture(GL_TEXTURE_2D, tex);
-  glEnable(GL_TEXTURE_2D);
+    glEnable(GL_TEXTURE_2D);
-  glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_VERTEX_ARRAY);
-  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-  glVertexPointer(2, GL_FLOAT, 0, verts);
+    glVertexPointer(2, GL_FLOAT, 0, verts);
-  glTexCoordPointer(2, GL_FLOAT, 0, verts);
+    glTexCoordPointer(2, GL_FLOAT, 0, verts);
-  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-  glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_VERTEX_ARRAY);
-  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-  glDisable(GL_TEXTURE_2D);
+    glDisable(GL_TEXTURE_2D);
+}
 void drawOBJ()
+{
-  static bool washere = false;
+    static bool washere = false;
-  static unsigned int disp_list;
+    static unsigned int disp_list;
-  if(!washere)
+    if(!washere)
-  {
-    disp_list = glGenLists(1);
-    glNewList(disp_list, GL_COMPILE);
-    glBegin(GL_TRIANGLES);
-    for(int i = 0; i < mesh.geometry.no_faces(); ++i)
+    {
-      Vec3i n_face = mesh.normals.face(i);
+        disp_list = glGenLists(1);
-      Vec3i g_face = mesh.geometry.face(i);
+        glNewList(disp_list, GL_COMPILE);
-      for(int j=0;j<3;j++)
-      {
-        double shade = 0.5;
+        glBegin(GL_TRIANGLES);
-        if(n_face != Geometry::NULL_FACE)
+        for(int i = 0; i < mesh.geometry.no_faces(); ++i)
+        {
+            Vec3i n_face = mesh.normals.face(i);
+            Vec3i g_face = mesh.geometry.face(i);
+            for(int j=0;j<3;j++)
+            {
+                double shade = 0.5;
+                if(n_face != Geometry::NULL_FACE)
+                {
-          Vec3f norm = normalize(mesh.normals.vertex(n_face[j]));
+                    Vec3f norm = normalize(mesh.normals.vertex(n_face[j]));
-          glNormal3fv(norm.get());
+                    glNormal3fv(norm.get());
-          shade = light_pow*dot(norm, light_dir);
+                    shade = light_pow*dot(norm, light_dir);
+                }
+                glColor3d(shade, shade, shade);
+                Vec3f vert = mesh.geometry.vertex(g_face[j]);
+                glVertex3fv(vert.get());
+            }
+        }
-        glColor3d(shade, shade, shade);
+        glEnd();
-        Vec3f vert = mesh.geometry.vertex(g_face[j]);
-        glVertex3fv(vert.get());
+        glEndList();
-      }
+        washere = true;
+    }
-    glEnd();
-    glEndList();
-    washere = true;
-  }
-  glCallList(disp_list);
+    glCallList(disp_list);
+}
 //////////////////////////////////////////////////////////////
 //      G L U T   C A L L B A C K   F U N C T I O N S
 //////////////////////////////////////////////////////////////
 void display()
+{
-  static bool first = true;
+    static bool first = true;
-  if(first)
+    if(first)
-  {
+    {
-    first = false;
+        first = false;
-    glutTimerFunc(spin_timer, spin, 0);
+        glutTimerFunc(spin_timer, spin, 0);
-  }
+    }
-  Vec3f eye, focus, up;
+    Vec3f eye, focus, up;
 	vctrl->get_view_param(eye, focus, up);
 	cam->set(eye, focus, up, cam->get_focal_dist());
-  if(raytrace)
+    if(raytrace)
-  {
-    raytrace = false;
-    cout << "Raytracing";
-    float win_to_vp = 1.0f/static_cast<float>(TEX_SIZE);
-    float lowerleft = 0.5 + win_to_vp*0.5;
-    float step = win_to_vp/static_cast<float>(PIXEL_SUBDIVS);
-    vector<Vec2f> jitter(PIXEL_SUBDIVS*PIXEL_SUBDIVS);
-    for(unsigned int i = 0; i < PIXEL_SUBDIVS; ++i)
-      for(unsigned int j = 0; j < PIXEL_SUBDIVS; ++j)
-      {
-	      jitter[i*PIXEL_SUBDIVS + j][0] = (my_random() + (j%PIXEL_SUBDIVS))*step;
-	      jitter[i*PIXEL_SUBDIVS + j][1] = (my_random() + (i%PIXEL_SUBDIVS))*step;
-      }
-    Util::Timer tim;
-    tim.start();
-    for(unsigned int i = 0; i < TEX_SIZE; ++i)
+    {
+        raytrace = false;
+        cout << "Raytracing";
+        float win_to_vp = 1.0f/static_cast<float>(TEX_SIZE);
+        float lowerleft = 0.5 + win_to_vp*0.5;
+        float step = win_to_vp/static_cast<float>(PIXEL_SUBDIVS);
+        vector<Vec2f> jitter(PIXEL_SUBDIVS*PIXEL_SUBDIVS);
+        for(unsigned int i = 0; i < PIXEL_SUBDIVS; ++i)
+            for(unsigned int j = 0; j < PIXEL_SUBDIVS; ++j)
+            {
+                jitter[i*PIXEL_SUBDIVS + j][0] = (my_random() + (j%PIXEL_SUBDIVS))*step;
+                jitter[i*PIXEL_SUBDIVS + j][1] = (my_random() + (i%PIXEL_SUBDIVS))*step;
+            }
+        Util::Timer tim;
+        tim.start();
-	    for(unsigned int j = 0; j < TEX_SIZE; ++j)
+        for(unsigned int i = 0; i < TEX_SIZE; ++i)
-	    {
+        {
+            for(unsigned int j = 0; j < TEX_SIZE; ++j)
+            {
-		    Vec3d sum(0.0f);
+                Vec3d sum(0.0f);
-		    Vec2f vp_pos(j*win_to_vp - lowerleft, i*win_to_vp - lowerleft);
+                Vec2f vp_pos(j*win_to_vp - lowerleft, i*win_to_vp - lowerleft);
-		    for(unsigned int ky = 0; ky < PIXEL_SUBDIVS; ++ky)
+                for(unsigned int ky = 0; ky < PIXEL_SUBDIVS; ++ky)
-		      for(unsigned int kx = 0; kx < PIXEL_SUBDIVS; ++kx)
+                    for(unsigned int kx = 0; kx < PIXEL_SUBDIVS; ++kx)
-		      {
+                    {
-			      Ray r = cam->get_ray(vp_pos + jitter[ky*PIXEL_SUBDIVS + kx]);
+                        Ray r = cam->get_ray(vp_pos + jitter[ky*PIXEL_SUBDIVS + kx]);
 #ifdef USE_BSP
-			      if(tree.intersect(r))
+                        if(tree.intersect(r))
-			        sum += Vec3d(shade_ray[shadow](r));
+                            sum += Vec3d(shade_ray[shadow](r));
-			      else
+                        else
-			        sum += background;
+                            sum += background;
 #else
-			      float t = FLT_MAX;
+                        float t = FLT_MAX;
-			      bb_tree.intersect(r);
+                        bb_tree.intersect(r);
-			      if(r.has_hit)
+                        if(r.has_hit)
-			        sum += Vec3d(shade_ray[0](r));
+                            sum += Vec3d(shade_ray[0](r));
-			      else
+                        else
-			        sum += background;
+                            sum += background;
 #endif
-		      }
+                    }
-	      image[i][j] = Vec3f(sum/static_cast<double>(PIXEL_SUBDIVS*PIXEL_SUBDIVS));
+                image[i][j] = Vec3f(sum/static_cast<double>(PIXEL_SUBDIVS*PIXEL_SUBDIVS));
-      }
+            }
-      if(((i + 1) % 50) == 0) cerr << ".";
+            if(((i + 1) % 50) == 0) cerr << ".";
+        }
+        cout << " - " << tim.get_secs() << " secs " << endl;
+        cout << endl;
+        init_texture(image_tex);
+        done = true;
+    }
-	  cout << " - " << tim.get_secs() << " secs " << endl;
-    cout << endl;
-    init_texture(image_tex);
-    done = true;
-  }
-  if(done)
-  {
-    set_ortho_proj();
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    glLoadIdentity();
-    draw_texture(image_tex);
-  }
-  else
-  {
-    glEnable(GL_DEPTH_TEST);
-    cam->glSetPerspective(winx, winy);
-    glClearColor(background[0], background[1], background[2], 1.0);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    glLoadIdentity();
-	  cam->glSetCamera();
+    if(done)
+    {
+        set_ortho_proj();
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        glLoadIdentity();
+        draw_texture(image_tex);
+    }
+    else
+    {
+        glEnable(GL_DEPTH_TEST);
+        cam->glSetPerspective(winx, winy);
+        glClearColor(background[0], background[1], background[2], 1.0);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        glLoadIdentity();
+        cam->glSetCamera();
-    glColor3f(0.5, 0.5, 0.5);
+        glColor3f(0.5, 0.5, 0.5);
-    drawOBJ();
+        drawOBJ();
-    glDisable(GL_DEPTH_TEST);
+        glDisable(GL_DEPTH_TEST);
-  }
+    }
-  glutSwapBuffers();
+    glutSwapBuffers();
+}
 void reshape(int w, int h)
+{
-  winx = w; winy = h;
+    winx = w; winy = h;
-  vctrl->reshape(winx, winy);
+    vctrl->reshape(winx, winy);
-  glViewport(0, 0, winx, winy);
+    glViewport(0, 0, winx, winy);
+}
 void keyboard(unsigned char key, int x, int y)
+{
-  switch(key)
+    switch(key)
-  {
+    {
-  case '+':
+        case '+':
-    ++PIXEL_SUBDIVS;
+            ++PIXEL_SUBDIVS;
-    cout << "Rays per pixel: " << PIXEL_SUBDIVS*PIXEL_SUBDIVS << endl;
+            cout << "Rays per pixel: " << PIXEL_SUBDIVS*PIXEL_SUBDIVS << endl;
-    break;
+            break;
-  case '-':
+        case '-':
-    if(PIXEL_SUBDIVS > 1)
+            if(PIXEL_SUBDIVS > 1)
-      --PIXEL_SUBDIVS;
+                --PIXEL_SUBDIVS;
-    cout << "Rays per pixel: " << PIXEL_SUBDIVS*PIXEL_SUBDIVS << endl;
+            cout << "Rays per pixel: " << PIXEL_SUBDIVS*PIXEL_SUBDIVS << endl;
-    break;
+            break;
-  case 'r':
+        case 'r':
-    if(done) done = false;
+            if(done) done = false;
-    else raytrace = true;
+            else raytrace = true;
-    break;
+            break;
-  case 's':
+        case 's':
-    shadow = !shadow;
+            shadow = !shadow;
-    cout << "Shadow " << (shadow ? "on." : "off.") << endl;
+            cout << "Shadow " << (shadow ? "on." : "off.") << endl;
-    break;
+            break;
-  case 27:
+        case 27:
-    delete vctrl;
+            delete vctrl;
-    delete cam;
+            delete cam;
-    exit(0);
+            exit(0);
-  }
+    }
+}
 void mouse(int btn, int state, int x, int y)
+{
-  if(state == GLUT_DOWN)
+    if(state == GLUT_DOWN)
-  {
+    {
-    if(btn == GLUT_LEFT_BUTTON)
+        if(btn == GLUT_LEFT_BUTTON)
-      vctrl->grab_ball(ROTATE_ACTION, Vec2i(x, y));
+            vctrl->grab_ball(ROTATE_ACTION, Vec2i(x, y));
-    else if(btn == GLUT_MIDDLE_BUTTON)
+        else if(btn == GLUT_MIDDLE_BUTTON)
-      vctrl->grab_ball(ZOOM_ACTION, Vec2i(x, y));
+            vctrl->grab_ball(ZOOM_ACTION, Vec2i(x, y));
-    else if(btn == GLUT_RIGHT_BUTTON)
+        else if(btn == GLUT_RIGHT_BUTTON)
-      vctrl->grab_ball(PAN_ACTION, Vec2i(x, y));
+            vctrl->grab_ball(PAN_ACTION, Vec2i(x, y));
-  }
+    }
-  else if(state == GLUT_UP)
+    else if(state == GLUT_UP)
-			vctrl->release_ball();
+        vctrl->release_ball();
-  mouse_state = state;
+    mouse_state = state;
-  mouse_button = btn;
+    mouse_button = btn;
-  glutPostRedisplay();
+    glutPostRedisplay();
+}
 void move(int x, int y)
+{
     vctrl->roll_ball(Vec2i(x, y));
-  glutPostRedisplay();
+    glutPostRedisplay();
+}
 void spin(int x)
+{
-  vctrl->try_spin();
+    vctrl->try_spin();
-  glutTimerFunc(spin_timer, spin, 0);
+    glutTimerFunc(spin_timer, spin, 0);
-  glutPostRedisplay();
+    glutPostRedisplay();
+}
 //////////////////////////////////////////////////////////////
 //                        M A I N
 //////////////////////////////////////////////////////////////
 int main(int argc, char** argv)
+{
 #ifdef __BORLANDC__
-  _control87(MCW_EM, MCW_EM);  // Borland C++ will crash OpenGL if this
+    _control87(MCW_EM, MCW_EM);  // Borland C++ will crash OpenGL if this
-                               // magic line is not inserted
+    // magic line is not inserted
 #endif
-  glutInit(&argc, argv);
+    glutInit(&argc, argv);
-  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
+    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
-  glutInitWindowSize(winx, winy);
+    glutInitWindowSize(winx, winy);
-  glutCreateWindow("Press 'r' to raytrace");
+    glutCreateWindow("Press 'r' to raytrace");
-  glutDisplayFunc(display);
+    glutDisplayFunc(display);
-  glutReshapeFunc(reshape);
+    glutReshapeFunc(reshape);
-  glutKeyboardFunc(keyboard);
+    glutKeyboardFunc(keyboard);
-  glutMouseFunc(mouse);
+    glutMouseFunc(mouse);
-  glutMotionFunc(move);
+    glutMotionFunc(move);
-  // LOAD OBJ
+    // LOAD OBJ
-  string filename;
+    string filename;
-  if(argc > 1)
+    if(argc > 1)
-  {
+    {
-    filename = argv[1];
+        filename = argv[1];
-    cout << "Loading " << filename << endl;
+        cout << "Loading " << filename << endl;
-    obj_load(filename, mesh);
+        obj_load(filename, mesh);
-    //if(!mesh.has_normals())
+        //if(!mesh.has_normals())
-    //{
+        //{
-      cout << "Computing normals" << endl;
+        cout << "Computing normals" << endl;
-      mesh.compute_normals();
+        mesh.compute_normals();
-    //}
+        //}
-    cout << "No. of triangles: " << mesh.geometry.no_faces() << endl;
+        cout << "No. of triangles: " << mesh.geometry.no_faces() << endl;
-  }
+    }
-  else
+    else
-  {
+    {
-    obj_load("../../data/dolphins.obj", mesh);
+        obj_load("../../data/dolphins.obj", mesh);
-  	cout << "Computing normals" << endl;
+        cout << "Computing normals" << endl;
-    mesh.compute_normals();
+        mesh.compute_normals();
-    //cout << "Usage: raytrace any_object.obj";
+        //cout << "Usage: raytrace any_object.obj";
-    //exit(0);
+        //exit(0);
-  }
+    }
-  initRaytracer();
+    initRaytracer();
-  initGL();
+    initGL();
-  glutMainLoop();
+    glutMainLoop();
-  return 0;
+    return 0;
+}

Subversion Repositories gelsvn

(root)/branches/cpp11-devel/apps/Raytracer/raytrace.cpp @ 638 – Rev 653 → 654