Subversion Repositories gelsvn

#include <iostream>

#include <vector>

#include <algorithm>

#include <cmath>

#include <GLGraphics/GLViewController.h>

#include <GEL/GL/glew.h>

#ifdef __APPLE__

#include <GLUT/GLUT.h>

#else

#include <GL/glut.h>

#endif

#include <CGLA/Vec2f.h>

#include <CGLA/Vec3i.h>

#include <CGLA/Vec3f.h>

#include <CGLA/Vec3d.h>

#include <CGLA/Mat4x4f.h>

#include <HMesh/Manifold.h>

#include <Geometry/TriMesh.h>

#include <Geometry/obj_load.h>

#include <Geometry/Ray.h>

#include <Geometry/BSPTree.h>

#include <Geometry/build_bbtree.h>

#include <Geometry/AABox.h>

#include <Geometry/OBox.h>

#include <Util/Timer.h>

#include "Camera.h"

//#define USE_BSP

using namespace std;

using namespace CGLA;

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_LEVEL = 20;    // Maximum number of BSP tree subdivisions

  const unsigned int TEX_SIZE = 512;

  bool raytrace = false;

  bool done = false;

  bool shadow = false;

  unsigned int winx = TEX_SIZE;     // Screen width

  unsigned int winy = TEX_SIZE;     // Screen height

  unsigned int PIXEL_SUBDIVS = 1;

  int mouse_state = GLUT_UP;

  int mouse_button = 0;

  int spin_timer = 20;

  GLViewController *vctrl;

  TriMesh mesh;

  vector<const TriMesh*> mesh_vector(1, &mesh);

  vector<Mat4x4f> transforms(1, identity_Mat4x4f());

  double light_pow = 1.0;

  Vec3f light_dir = normalize(Vec3f(1.0, 1.0, 1.0));

  Vec3d background(0.8, 0.9, 1.0);

  BSPTree tree;

  Camera* cam;

  Vec3f image[TEX_SIZE][TEX_SIZE];

  unsigned int image_tex;

  // Function to generate a random number between 0 and 1.

  // gel_rand() returns a random number ranging from 0 to GEL_RAND_MAX.

  inline double my_random()

  {

    return gel_rand()/static_cast<double>(GEL_RAND_MAX);

  }

  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));

  glBindTexture(GL_TEXTURE_2D, tex);

  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

  // load the texture image

  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 

	             TEX_SIZE, TEX_SIZE,

	             0, GL_RGB, GL_FLOAT, image[0][0].get());

}

void initRaytracer()

{

  Vec3f c;

  float r;

  mesh.get_bsphere(c, r);

  r *= 1.5;

  // Initialize track ball

  vctrl = new GLViewController(winx, winy, c, r);

  // Initialize corresponding camera

  cam = new Camera(c - Vec3f(r), c, Vec3f(0.0f, 1.0f, 0.0f), 1.0f);

#ifdef USE_BSP

   cout << "Constructing BSP tree..." << endl;

   tree.init(mesh_vector, transforms, MAX_OBJECTS, MAX_LEVEL);

   tree.build();

#else

	// AABB TREE

	Manifold m;

	vector<int> faces(mesh.geometry.no_faces(), 3);

	cout << "Creating manifold" << endl;

    m.build(mesh.geometry.no_vertices(),

            reinterpret_cast<const float*>(&mesh.geometry.vertex(0)),

            faces.size(),

            &faces[0],

            reinterpret_cast<const int*>(&mesh.geometry.face(0)));

	cout << "Building tree" << endl;

	build_AABBTree(m, bb_tree);

#endif

}

void initGL()

{

  glShadeModel(GL_SMOOTH); 

  glDisable(GL_CULL_FACE);

  glFrontFace(GL_CCW);

  glClearColor(1.0, 1.0, 1.0, 1.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();

  Ray shadow(r.hit_pos, light_dir);

  double s = tree.intersect(shadow) ? 0.0 : 1.0;

  r.compute_normal();

  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);

}

double (*shade_ray[2])(Ray&) = { lambertian_shade,

				                         shadow_shade      };

//////////////////////////////////////////////////////////////

//      D R A W   F U N C T I O N S

//////////////////////////////////////////////////////////////

/*

void enable_textures(TriMesh& tm)

{

  for(unsigned int i=0;i<tm.materials.size(); ++i)

  {

    Material& mat = tm.materials[i];

    if(mat.tex_name != "")

    {

      string name = mat.tex_path + mat.tex_name;

      GLuint tex_id;

      if(load_image_into_texture(name, tex_id))

	mat.tex_id = tex_id;

    }

  }

}

*/

void set_perspective_proj()

{

  glMatrixMode(GL_PROJECTION);	 

  glLoadIdentity();            

  gluPerspective(64.0, 1.0, 0.1, 1000.0);

  glMatrixMode(GL_MODELVIEW);

}

void set_ortho_proj()

{

  glMatrixMode(GL_PROJECTION);	 

  glLoadIdentity();             

  glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

  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 };

  glColor4f(1.0, 1.0, 1.0, 1.0);

  glBindTexture(GL_TEXTURE_2D, tex);

  glEnable(GL_TEXTURE_2D);

  glEnableClientState(GL_VERTEX_ARRAY);

  glEnableClientState(GL_TEXTURE_COORD_ARRAY);

  glVertexPointer(2, GL_FLOAT, 0, verts);

  glTexCoordPointer(2, GL_FLOAT, 0, verts);

  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

  glDisableClientState(GL_VERTEX_ARRAY);

  glDisableClientState(GL_TEXTURE_COORD_ARRAY);

  glDisable(GL_TEXTURE_2D);

}

void drawOBJ()

{

  static bool washere = false;

  static unsigned int disp_list;

  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);

      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]));

          glNormal3fv(norm.get());

          shade = light_pow*dot(norm, light_dir);

        }

        glColor3d(shade, shade, shade);

        Vec3f vert = mesh.geometry.vertex(g_face[j]);	  

        glVertex3fv(vert.get());

      }

    }

    glEnd();

    glEndList();

    washere = true;

  }

  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;

  if(first)

  {

    first = false;

    glutTimerFunc(spin_timer, spin, 0);

  }

  Vec3f eye, focus, up;

	vctrl->get_view_param(eye, focus, up);

	cam->set(eye, focus, up, cam->get_focal_dist());

  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)

    {

	    for(unsigned int j = 0; j < TEX_SIZE; ++j)

	    {

		    Vec3d sum(0.0f);

		    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 kx = 0; kx < PIXEL_SUBDIVS; ++kx)

		      {

			      Ray r = cam->get_ray(vp_pos + jitter[ky*PIXEL_SUBDIVS + kx]);

#ifdef USE_BSP

			      if(tree.intersect(r))

			        sum += Vec3d(shade_ray[shadow](r));

			      else

			        sum += background;

#else

			      float t = FLT_MAX;

			      bb_tree.intersect(r);

			      if(r.has_hit)

			        sum += Vec3d(shade_ray[0](r));

			      else 

			        sum += background;

#endif		

		      }

	      image[i][j] = Vec3f(sum/static_cast<double>(PIXEL_SUBDIVS*PIXEL_SUBDIVS));

      }

      if(((i + 1) % 50) == 0) cerr << ".";

    }

	  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();

    glColor3f(0.5, 0.5, 0.5);

    drawOBJ();

    glDisable(GL_DEPTH_TEST);

  }

  glutSwapBuffers();  

}

void reshape(int w, int h)

{

  winx = w; winy = h;

  vctrl->reshape(winx, winy);

  glViewport(0, 0, winx, winy);

}

void keyboard(unsigned char key, int x, int y)

{

  switch(key)

  {

  case '+':

    ++PIXEL_SUBDIVS;

    cout << "Rays per pixel: " << PIXEL_SUBDIVS*PIXEL_SUBDIVS << endl;

    break;

  case '-':

    if(PIXEL_SUBDIVS > 1)

      --PIXEL_SUBDIVS;

    cout << "Rays per pixel: " << PIXEL_SUBDIVS*PIXEL_SUBDIVS << endl;

    break;

  case 'r':

    if(done) done = false;

    else raytrace = true;

    break;

  case 's':

    shadow = !shadow;

    cout << "Shadow " << (shadow ? "on." : "off.") << endl;

    break;

  case 27:

    delete vctrl;

    delete cam;

    exit(0);

  }

}

void mouse(int btn, int state, int x, int y)

{

  if(state == GLUT_DOWN) 

  {

    if(btn == GLUT_LEFT_BUTTON) 

      vctrl->grab_ball(ROTATE_ACTION, Vec2i(x, y));

    else if(btn == GLUT_MIDDLE_BUTTON) 

      vctrl->grab_ball(ZOOM_ACTION, Vec2i(x, y));

    else if(btn == GLUT_RIGHT_BUTTON) 

      vctrl->grab_ball(PAN_ACTION, Vec2i(x, y));

  }

  else if(state == GLUT_UP)

			vctrl->release_ball();

  mouse_state = state;

  mouse_button = btn;

  glutPostRedisplay();

}

void move(int x, int y)

{

    vctrl->roll_ball(Vec2i(x, y));

  glutPostRedisplay();

}

void spin(int x)

{

  vctrl->try_spin();

  glutTimerFunc(spin_timer, spin, 0);  

  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

                               // magic line is not inserted

#endif

  glutInit(&argc, argv);

  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);

  glutInitWindowSize(winx, winy);

  glutCreateWindow("Press 'r' to raytrace");

  glutDisplayFunc(display);

  glutReshapeFunc(reshape);

  glutKeyboardFunc(keyboard);

  glutMouseFunc(mouse);

  glutMotionFunc(move);

  // LOAD OBJ

  string filename;

  if(argc > 1)

  {

    filename = argv[1];

    cout << "Loading " << filename << endl;

    obj_load(filename, mesh);

    //if(!mesh.has_normals())

    //{

      cout << "Computing normals" << endl;

      mesh.compute_normals();

    //}

    cout << "No. of triangles: " << mesh.geometry.no_faces() << endl;

  }

  else

  {

    obj_load("../../data/dolphins.obj", mesh);

  	cout << "Computing normals" << endl;

    mesh.compute_normals();

    //cout << "Usage: raytrace any_object.obj";

    //exit(0);

  }

  initRaytracer();

  initGL();    

  glutMainLoop();

  return 0;

}