WebSVN – gelsvn – Diff – /trunk/src/Geometry/BSPTree.cpp

       node.left = left_node;
       node.right = right_node;
       //node.is_leaf = false;
-      // Make test on all three axis
       int new_axis=-1;
       double min_cost=CGLA::BIG;
       int new_pos = -1;
 /*
        float max_size=0;
 	   new_axis=i;
 	   new_pos = 1;
+	 }
+       }
 */
-      unsigned int j;
       for(i=0;i<3;i++)
+      {
 	for(int k=1;k<TESTS;k++)
+	{
 	  BBox left_bbox = bbox;
-	  double center = (bbox.max_corner[i]- bbox.min_corner[i])*(double)k/(double)TESTS+bbox.min_corner[i];
+	  double center = (bbox.max_corner[i]- bbox.min_corner[i])*(double)k/(double)TESTS + bbox.min_corner[i];
 	  node.plane = center;
 	  left_bbox.max_corner[i] = center;
 	  right_bbox.min_corner[i] = center;
 	  // Try putting the triangles in the left and right boxes
 	  int left_count = 0;
 	  int right_count = 0;
-	  for(j=0;j<objects.size();j++)
+	  for(unsigned int j=0;j<objects.size();j++)
+	  {
 	    ISectTri* tri = objects[j];
-	    if (left_bbox.intersect_triangle(*tri))
+	    left_count += left_bbox.intersect_triangle(*tri);
-	      left_count++;
-	    if (right_bbox.intersect_triangle(*tri))
+	    right_count += right_bbox.intersect_triangle(*tri);
-	      right_count++;
+	  }
-	  if ((double)left_count*left_bbox.area()+(double)right_count*right_bbox.area()<min_cost)
+	  if (left_count*left_bbox.area() + right_count*right_bbox.area() < min_cost)
+	  {
-	    min_cost = (double)left_count*left_bbox.area()+(double)right_count*right_bbox.area();
+	    min_cost = left_count*left_bbox.area() + right_count*right_bbox.area();
-	    new_axis=i;
+	    new_axis = i;
 	    new_pos = k;
-	    if (right_count==0)
+	    right_zero = (right_count==0);
-	      right_zero=true;
-	    else
-	      right_zero=false;
-	    if (left_count==0)
+	    left_zero = (left_count==0);
-	      left_zero=true;
-	    else
-	      left_zero=false;
+	  }
+	}
+      }
       node.axis_leaf = new_axis;
       //	node.axis_leaf = level %3;
-      left_node->axis_leaf = -1; //(node.axis + 1)%3;
+      left_node->axis_leaf = static_cast<unsigned char>(-1); //(node.axis + 1)%3;
-      right_node->axis_leaf = -1; //(node.axis + 1)%3;
+      right_node->axis_leaf = static_cast<unsigned char>(-1); //(node.axis + 1)%3;
       // Now chose the right splitting plane
       BBox left_bbox = bbox;
       BBox right_bbox = bbox;
+      double size = bbox.max_corner[node.axis_leaf]- bbox.min_corner[node.axis_leaf];
-      double center = (bbox.max_corner[node.axis_leaf]- bbox.min_corner[node.axis_leaf])*(double)new_pos/(double)TESTS+bbox.min_corner[node.axis_leaf];
+      double center = size*(double)new_pos/(double)TESTS + bbox.min_corner[node.axis_leaf];
+      double diff = f_eps < size/8.0 ? f_eps : size/8.0;
       // This doesn't help that much
       if (left_zero)
+      {
 //			cout << "Old left center: " << center;
 	// Find min position af alle trekanter og placer center der
 	center = bbox.max_corner[node.axis_leaf];
-	for(j=0;j<objects.size();j++)
+	for(unsigned int j=0;j<objects.size();j++)
+	{
 	  ISectTri* tri = objects[j];
 	  if (tri->point0[node.axis_leaf]<center)
 	    center=tri->point0[node.axis_leaf];
 	  if (tri->point1[node.axis_leaf]<center)
 	    center=tri->point1[node.axis_leaf];
 	  if (tri->point2[node.axis_leaf]<center)
 	    center=tri->point2[node.axis_leaf];
+	}
+	center -= diff;
 //			cout << "new left center: " << center << endl;
+      }
       if (right_zero)
+      {
 //			cout << "Old right center: " << center;
-	// Find min position af alle trekanter og placer center der
+	// Find max position af alle trekanter og placer center der
-	center = left_bbox.min_corner[node.axis_leaf];
+	center = bbox.min_corner[node.axis_leaf];
-	for(j=0;j<objects.size();j++)
+	for(unsigned int j=0;j<objects.size();j++)
+	{
 	  ISectTri* tri = objects[j];
 	  if (tri->point0[node.axis_leaf]>center)
 	    center=tri->point0[node.axis_leaf];
 	  if (tri->point1[node.axis_leaf]>center)
 	    center=tri->point1[node.axis_leaf];
 	  if (tri->point2[node.axis_leaf]>center)
 	    center=tri->point2[node.axis_leaf];
+	}
+	center += diff;
 //			cout << "new right center: " << center << endl;
+      }
       node.plane = center;
-      left_bbox.max_corner[node.axis_leaf] = center+f_eps;
+      left_bbox.max_corner[node.axis_leaf] = center; // + f_eps;
-      right_bbox.min_corner[node.axis_leaf] = center-f_eps;
+      right_bbox.min_corner[node.axis_leaf] = center; // - f_eps;
-		// Now put the triangles in the right and left node
+      // Now put the triangles in the right and left node
       for(i=0;i<objects.size();i++)
+      {
 	ISectTri* tri = objects[i];
+	{
 	  right_objects.push_back(tri);
 	  tri_right_objects.push_back(tri_accel);
+	}
+      }
-/*	if (left_zero||right_zero) {
+      if (left_zero||right_zero)
-			cout << left_objects.size() << "," << right_objects.size() << endl;
+	cout << left_objects.size() << "," << right_objects.size() << "," << level << endl;
-		}
-*/
       objects.clear();
       subdivide_node(*left_node , left_bbox , level+1, left_objects, tri_left_objects);
       subdivide_node(*right_node, right_bbox, level+1, right_objects, tri_right_objects);
+    }
+  }
   void BSPTree::init()
+  {
     root = new BSPNode();
     bbox.compute_bbox(isecttris);
-    bbox.min_corner-=Vec3f(f_eps*100,f_eps*100,f_eps*100);
+    bbox.min_corner-=Vec3f(1.0);
-    bbox.max_corner+=Vec3f(f_eps*100,f_eps*100,f_eps*100);
+    bbox.max_corner+=Vec3f(1.0);
+  }
   void BSPTree::init(vector<TriMesh*>& _trimesh,
 		     vector<Mat4x4f>& _transforms,
 		     int _max_objects, int _max_level)
+    {
       vector<ISectTri*> objects;
       vector<TriAccel*> tri_objects;
       for(unsigned int i=0;i<isecttris.size();i++)
+      {
-	ISectTri& tri = isecttris[i];
+	ISectTri* tri = &isecttris[i];
-	TriAccel& tri_accel = triaccel[i];
+	TriAccel* tri_accel = &triaccel[i];
-	objects.push_back(&tri);
+	objects.push_back(tri);
-	tri_objects.push_back(&tri_accel);
+	tri_objects.push_back(tri_accel);
+      }
       subdivide_node(*root, bbox, 0, objects, tri_objects);
       b_is_build = true;
+    }
     isecttris.clear();
+  {
     double t_min, t_max;
     bbox.intersect_min_max(ray, t_min, t_max);
     if (t_min>t_max)
       return false;
-    if (!intersect_node(ray, *root, t_min, t_max))
+//    if (!intersect_node(ray, *root, t_min, t_max))
-      return false;
+//      return false;
 //	cout << "____" << endl;
 //	ray.reset();
 //	cout << "Here " << endl;
-//	intersect_fast_node(ray, &fast_tree[0], t_min, t_max);
+    intersect_fast_node(ray, &fast_tree[0], t_min, t_max);
-//	if (!ray.has_hit)
+    if (!ray.has_hit)
-//		return false;
+      return false;
     else
+    {
       // Calculate the normal at the intersection
       ray.hit_object = trimesh[(int)ray.hit_object];
+/*
       Vec3i face = ray.hit_object->normals.face(ray.hit_face_id);
       Vec3f normal0 = ray.hit_object->normals.vertex(face[0]);
       Vec3f normal1 = ray.hit_object->normals.vertex(face[1]);
       Vec3f normal2 = ray.hit_object->normals.vertex(face[2]);
       ray.hit_normal = normalize(normal0*(1 - ray.u - ray.v)
 				 +normal1*ray.u
 				 +normal2*ray.v);
       ray.hit_pos = ray.origin + ray.direction*ray.dist;
+*/
       return true;
+    }
+  }
   const int MAX_DEPTH=25;
     double t_max;
   };
   inline void IntersectAlltrianglesInLeaf(const BSPLeaf* leaf, Ray &ray, double t_max) {
     TriAccel** tri_acc_ptr = reinterpret_cast<TriAccel**>(leaf->flagAndOffset & (0x7FFFFFFF));
-    vector<TriAccel*>::iterator acc(tri_acc_ptr);
+    vector<TriAccel*>::iterator acc = vector<TriAccel*>::iterator(tri_acc_ptr);
 //	vector<TriAccel*>::iterator acc = ABSP_TRIANGLENODE(leaf);
     for(unsigned int i=0;i<leaf->count;++i)
       intersect2(ray, *(*acc++), t_max);
+  }

Subversion Repositories gelsvn

(root)/trunk/src/Geometry/BSPTree.cpp – Rev 304 → 310