Changeset 1281 for GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp

Timestamp:

08/24/06 22:23:33 (18 years ago)

Author:

bittner

Message:

mlrt 16 ray tracing support

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp (modified) (2 diffs)

GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp

@@ -906 +906 @@
                 tPoint[2] = pforg[2] + pfdir[2] * dist;
 
-                return mFaceParents[hittriangle];
+                return mFaceParents[hittriangle].mObject;
         }
 }
@@ -1013 +1013 @@
 
 
+int
+Preprocessor::ProcessRay(
+                                                 Vector3 &viewPoint,
+                                                 Vector3 &direction,
+                                                 Intersectable *objectA,
+                                                 Vector3 &pointA,
+                                                 Vector3 &normalA,
+                                                 Intersectable *objectB,
+                                                 Vector3 &pointB,
+                                                 Vector3 &normalB,
+                                                 const float probability,
+                                                 VssRayContainer &vssRays,
+                                                 const AxisAlignedBox3 &box
+                                                 )
+{
+  int hits=0;
+
+  if (objectA == NULL && objectB == NULL)
+        return 0;
+
+  AxisAlignedBox3 sbox = box;
+  sbox.Enlarge(Vector3(-Limits::Small));
+
+  
+  if (!sbox.IsInside(viewPoint))
+        return 0;
+
+  if (objectA == NULL) {
+        // compute intersection with the scene bounding box
+        static Ray ray;
+        SetupRay(ray, viewPoint, direction);
+        
+        float tmin, tmax;
+        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
+          pointA = ray.Extrap(tmax);
+        else
+          return 0;
+  } else {
+        if (mDetectEmptyViewSpace)
+          if (DotProd(normalA, direction) >= 0) {
+                // discard the sample
+                return 0;
+          }
+  }
+
+  if (objectB == NULL) {
+        // compute intersection with the scene bounding box
+        static Ray ray;
+        SetupRay(ray, viewPoint, -direction);
+
+        float tmin, tmax;
+        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
+          pointB = ray.Extrap(tmax);
+        else
+          return 0;
+  } else {
+        if (mDetectEmptyViewSpace)
+          if (DotProd(normalB, direction) <= 0) {
+                // discard the sample
+                return 0;
+          }
+  }
+  
+  VssRay *vssRay  = NULL;
+  bool validSample = (objectA != objectB);
+  if (validSample) {
+        if (objectA) {
+          vssRay = new VssRay(pointB,
+                                                  pointA,
+                                                  objectB,
+                                                  objectA,
+                                                  mPass,
+                                                  probability
+                                                  );
+          vssRays.push_back(vssRay);
+          hits ++;
+        }
+        
+        if (objectB) {
+          vssRay = new VssRay(pointA,
+                                                  pointB,
+                                                  objectA,
+                                                  objectB,
+                                                  mPass,
+                                                  probability
+                                                  );
+          vssRays.push_back(vssRay);
+          hits ++;
+        }
+  }
+  
+  return hits;
+}
+
+void
+Preprocessor::CastRays16(const int index,
+                                                 SimpleRayContainer &rays, 
+                                                 VssRayContainer &vssRays,
+                                                 const AxisAlignedBox3 &sbox)
+{
+  int i;
+  int num = 16;
+  
+  if (mRayCastMethod == INTEL_RAYCASTER) {
+#ifdef GTP_INTERNAL
+
+  int forward_hit_triangles[16];
+  float forward_dist[16];
+
+  int backward_hit_triangles[16];
+  float backward_dist[16];
+  
+  Vector3 min = sbox.Min();
+  Vector3 max = sbox.Max();
+  
+  for (i=0; i < num; i++) {
+        mlrtaStoreRayAS16(&rays[index + i].mOrigin.x,
+                                          &rays[index + i].mDirection.x,
+                                          i);
+  }
+  
+  
+  mlrtaTraverseGroupAS16(&min.x,
+                                                 &max.x,
+                                                 forward_hit_triangles,
+                                                 forward_dist);
+
+  for (i=0; i < num; i++) {
+        Vector3 dir = -rays[index+i].mDirection;
+        mlrtaStoreRayAS16(&rays[index+i].mOrigin.x,
+                                          &dir.x,
+                                          i);
+  }
+  
+  
+  mlrtaTraverseGroupAS16(&min.x,
+                                                 &max.x,
+                                                 backward_hit_triangles,
+                                                 backward_dist);
+  
+
+  for (i=0; i < num; i++) {
+        Intersectable *objectA = NULL, *objectB = NULL;
+        Vector3 pointA, pointB;
+        Vector3 normalA, normalB;
+        if (forward_hit_triangles[i] !=-1 ) {
+          objectA = mFaceParents[forward_hit_triangles[i]].mObject;
+          // Get the normal of that face
+          Mesh *mesh = ((MeshInstance *)objectA)->GetMesh();
+          normalA = mesh->GetFacePlane(mFaceParents[forward_hit_triangles[i]].mFaceIndex).mNormal;
+          //-rays[index+i].mDirection; // $$ temporary
+          pointA = rays[index+i].Extrap(forward_dist[i]);
+        }
+        
+        if (backward_hit_triangles[i]!=-1) {
+          objectB = mFaceParents[backward_hit_triangles[i]].mObject;
+          Mesh *mesh = ((MeshInstance *)objectB)->GetMesh();
+
+          normalB = mesh->GetFacePlane(mFaceParents[backward_hit_triangles[i]].mFaceIndex).mNormal;
+          
+          //      normalB = rays[index+i].mDirection; // $$ temporary
+          pointB = rays[index+i].Extrap(-backward_dist[i]);
+        }
+        
+        ProcessRay(rays[index+i].mOrigin,
+                           rays[index+i].mDirection,
+                           objectA, pointA, normalA,
+                           objectB, pointB, normalB,
+                           rays[index+i].mPdf,
+                           vssRays,
+                           sbox
+                           );
+  }
+#endif
+  } else {
+
+        for (i=index; i < index + num; i++) {
+          CastRay(rays[i].mOrigin,
+                          rays[i].mDirection,
+                          rays[i].mPdf,
+                          vssRays,
+                          sbox);
+        }
+  }
+  
+}
+
+void
+Preprocessor::CastRays(
+                                           SimpleRayContainer &rays,
+                                           VssRayContainer &vssRays
+                                           )
+{
+  long t1 = GetTime();
+  for (int i=0; i < rays.size(); ) {
+        if (i + 16 < rays.size()) {
+          CastRays16(
+                                 i,
+                                 rays,
+                                 vssRays,
+                                 mViewCellsManager->GetViewSpaceBox());
+          i += 16;
+        } else {
+          CastRay(rays[i].mOrigin,
+                          rays[i].mDirection,
+                          rays[i].mPdf,
+                          vssRays,
+                          mViewCellsManager->GetViewSpaceBox());
+          i++;
+        }
+        if (i % 10000 == 0)
+          cout<<".";
+  }
+
+  long t2 = GetTime();
+  
+  cout<<2*rays.size()/(1e3*TimeDiff(t1, t2))<<"M rays/s"<<endl;
+}
+
 int Preprocessor::CastRay(
                                                   const Vector3 &viewPoint,