WebSVN – gelsvn – Diff – /trunk/apps/Raytracer/raytrace.cpp

 #include "CGLA/Vec2f.h"
 #include "CGLA/Vec3i.h"
 #include "CGLA/Vec3f.h"
 #include "CGLA/Vec3d.h"
 #include "CGLA/Mat4x4f.h"
+#include "HMesh/build_manifold.h"
 #include "Geometry/TriMesh.h"
 #include "Geometry/obj_load.h"
 #include "Geometry/Ray.h"
 #include "Geometry/BSPTree.h"
-#include "GLGraphics/QuatTrackBall.h"
+#include "GLGraphics/GLViewController.h"
+#include "Geometry/build_bbtree.h"
+#include "Geometry/AABox.h"
+#include "Geometry/OBox.h"
+#include "Util/Timer.h"
 #include "Camera.h"
+//#define USE_BDL
 using namespace std;
 using namespace CGLA;
 using namespace Geometry;
+using namespace HMesh;
 using namespace GLGraphics;
+/*
+ * TODO:
+ * - BSP fix bug preventing bunny model from loading.
+ * - 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 = 2;   // Maximum number of triangles in a BSP tree node
   const int MAX_LEVEL = 20;    // Maximum number of BSP tree subdivisions
   int mouse_state = GLUT_UP;
   int mouse_button = 0;
   int spin_timer = 20;
-  QuatTrackBall* ball = 0;
+		GLViewController *vctrl;
   TriMesh mesh;
   vector<TriMesh*> mesh_vector(1, &mesh);
   vector<Mat4x4f> transforms(1, identity_Mat4x4f());
   // rand() returns a random number ranging from 0 to RAND_MAX.
   inline double my_random()
+  {
     return rand()/static_cast<double>(RAND_MAX);
+  }
+		AABBTree bb_tree;
+}
 void spin(int x);
   float r;
   mesh.get_bsphere(c, r);
   r *= 1.5;
   // Initialize track ball
-  ball = new QuatTrackBall(c,        // Center
+	vctrl = new GLViewController(winx, winy, c, r);
-		       r,        // Eye distance
-		       winx,     // Window width
-		       winy);    // Window height
   // Initialize corresponding camera
   cam = new Camera(c - Vec3f(r),
 		   c,
 		   Vec3f(0.0f, 1.0f, 0.0f),
 .0f);
+#ifdef USE_BDL
-  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;
+	build_manifold(m,
+								 mesh.geometry.no_vertices(),
+								 &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);
-  glEnable(GL_CULL_FACE);
+  glDisable(GL_CULL_FACE);
   glFrontFace(GL_CCW);
   glClearColor(1.0, 1.0, 1.0, 1.0);
   glColor3f(0.0, 0.0, 0.0);
+}
   return s*light_pow*dot(r.hit_normal, light_dir);
+}
 double lambertian_shade(Ray& r)
+{
+#ifdef USE_BDL
-  r.compute_normal();
+		r.compute_normal();
+#endif
   return light_pow*dot(r.hit_normal, light_dir);
+}
 double (*shade_ray[2])(Ray&) = { lambertian_shade,
 				 shadow_shade      };
     first = false;
     glutTimerFunc(spin_timer, spin, 0);
+  }
   Vec3f eye, focus, up;
-  ball->get_view_param(eye, focus, up);
+	vctrl->get_view_param(eye, focus, up);
-  cam->set(eye, focus, up, cam->get_focal_dist());
+	cam->set(eye, focus, up, cam->get_focal_dist());
   if(raytrace)
+  {
     raytrace = false;
     cout << "Raytracing";
+      {
 	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)
+				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_BDL
-	    if(tree.intersect(r))
+										if(tree.intersect(r))
-	      sum += Vec3d(shade_ray[shadow](r));
+												sum += Vec3d(shade_ray[shadow](r));
+										else
+												sum += background;
-	    else
+#else
+										float t = FLT_MAX;
+										bb_tree.intersect(r);
+										if(r.has_hit)
+												sum += Vec3d(shade_ray[0](r));
-	      sum += background;
+										else 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;
   else
+  {
     glEnable(GL_DEPTH_TEST);
     cam->glSetPerspective(winx, winy);
+		vctrl->reset_projection();
     glClearColor(background[0], background[1], background[2], 1.0);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
-    cam->glSetCamera();
+		vctrl->set_gl_modelview();
     glColor3f(0.5, 0.5, 0.5);
     drawOBJ();
     glDisable(GL_DEPTH_TEST);
 void reshape(int w, int h)
+{
   winx = w; winy = h;
-  ball->set_screen_window(winx, winy);
+  vctrl->reshape(winx, winy);
-  ball->set_screen_centre(Vec2i(winx/2, winy/2));
   glViewport(0, 0, winx, winy);
   set_ortho_proj();
+}
   case 's':
     shadow = !shadow;
     cout << "Shadow " << (shadow ? "on." : "off.") << endl;
     break;
   case 27:
-    delete ball;
+    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)
-      ball->grab_ball(ROTATE_ACTION, Vec2i(x, y));
+      vctrl->grab_ball(ROTATE_ACTION, Vec2i(x, y));
     else if(btn == GLUT_MIDDLE_BUTTON)
-      ball->grab_ball(ZOOM_ACTION, Vec2i(x, y));
+      vctrl->grab_ball(ZOOM_ACTION, Vec2i(x, y));
     else if(btn == GLUT_RIGHT_BUTTON)
-      ball->grab_ball(PAN_ACTION, Vec2i(x, y));
+      vctrl->grab_ball(PAN_ACTION, Vec2i(x, y));
+  }
   else if(state == GLUT_UP)
-    ball->release_ball();
+			vctrl->release_ball();
   mouse_state = state;
   mouse_button = btn;
   glutPostRedisplay();
+}
 void move(int x, int y)
+{
-  if(mouse_state == GLUT_DOWN)
-    ball->roll_ball(Vec2i(x, y));
+    vctrl->roll_ball(Vec2i(x, y));
   glutPostRedisplay();
+}
 void spin(int x)
+{
-  ball->do_spin();
+  vctrl->try_spin();
   glutTimerFunc(spin_timer, spin, 0);
   glutPostRedisplay();
+}

Subversion Repositories gelsvn

(root)/trunk/apps/Raytracer/raytrace.cpp @ 596 – Rev 305 → 309