Text archives Help

---

Author: thiago
Date: Sun Sep 23 18:58:55 2007
New Revision: 1738

Modified:
   trunk/Interface/RayPacket.h
   trunk/Model/Cameras/PinholeCamera.cc
   trunk/Model/Groups/Mesh.cc
   trunk/Model/Groups/Mesh.h
   trunk/Model/Groups/private/CGT.cc
   trunk/Model/Primitives/WaldTriangle.cc
Log:
Interface/RayPacket.h:
  -Changed corner_dir from being an sse_t to being a Real. Now corner
   rays can be used in non-sse code.

Model/Groups/Mesh:
  -overloaded Group::get() to return a MeshTriangle*. Makes things
   cleaner/nicer.

Model/Groups/private/CGT.cc:
  -updates to use Real corner_dir instead of sse_t corner_dir.

Model/Primitives/WaldTriangle.cc :
  -updates to use Real corner_dir instead of sse_t corner_dir.
  -slight optimization not to compute values if there is a common origin.

Model/Cameras/PinholeCamera.cc:
  -updates to use Real corner_dir instead of sse_t corner_dir.
  -create corner rays for non-sse case.

Modified: trunk/Interface/RayPacket.h
==============================================================================
--- trunk/Interface/RayPacket.h (original)
+++ trunk/Interface/RayPacket.h Sun Sep 23 18:58:55 2007
@@ -88,15 +88,12 @@
     MaterialCP hitMatl[MaxSize];
     TexCoordMapperCP hitTex[MaxSize];
 
-#ifdef MANTA_SSE
-    sse_t corner_dir[3];
-#endif
-
     // Real-based arrays
     MANTA_ALIGN(16) Real origin[3][MaxSize];
     MANTA_ALIGN(16) Real direction[3][MaxSize];
     MANTA_ALIGN(16) Real inverseDirection[3][MaxSize];
     MANTA_ALIGN(16) Real minT[MaxSize];
+    MANTA_ALIGN(16) Real corner_dir[3][4];
 
     MANTA_ALIGN(16) Real image[2][MaxSize];
     MANTA_ALIGN(16) Real normal[3][MaxSize];

Modified: trunk/Model/Cameras/PinholeCamera.cc
==============================================================================
--- trunk/Model/Cameras/PinholeCamera.cc        (original)
+++ trunk/Model/Cameras/PinholeCamera.cc        Sun Sep 23 18:58:55 2007
@@ -173,20 +173,17 @@
 template <bool NORMALIZE_RAYS, bool CREATE_CORNER_RAYS>
 void PinholeCamera::makeRaysSpecialized(RayPacket& rays) const
 {
-#ifdef MANTA_SSE
+
   //we need to find the max ray extents so that we can calculate the
   //corner rays.  These are used by the WaldTriangle intersector and
   //CGT acceleration structure to do frustum culling/traversal, and
   //possibly elsewhere.
-
-  // NOTE(boulos): Unless the corner rays code is also available to
-  // the scalar section, these should only be declared in this path.
   float min_v = std::numeric_limits<float>::max();
   float max_v = -std::numeric_limits<float>::max();
   float min_u = std::numeric_limits<float>::max();
   float max_u = -std::numeric_limits<float>::max();
 
-
+#ifdef MANTA_SSE
     int b = (rays.rayBegin + 3) & (~3);
     int e = rays.rayEnd & (~3);
     if(b >= e){
@@ -197,7 +194,9 @@
         rays.setRay(i, eye, raydir);
 
         if (CREATE_CORNER_RAYS) {
-          //find max ray extents
+          //find max ray extents.
+          //TODO: double check that calling getImageCoordinates again
+          //won't return different values and isn't slow.
           min_v = SCIRun::Min(min_v, rays.getImageCoordinates(i, 0));
           max_v = SCIRun::Max(max_v, rays.getImageCoordinates(i, 0));
           min_u = SCIRun::Min(min_u, rays.getImageCoordinates(i, 1));
@@ -300,24 +299,47 @@
         if (NORMALIZE_RAYS) {
           const sse_t length2 = add4(add4(mul4(xd, xd), mul4(yd, yd)), 
mul4(zd, zd));
           const sse_t scale = accurateReciprocalSqrt(length2);
-          data->corner_dir[0] = mul4(xd, scale);
-          data->corner_dir[1] = mul4(yd, scale);
-          data->corner_dir[2] = mul4(zd, scale);
+          store44(data->corner_dir[0], mul4(xd, scale));
+          store44(data->corner_dir[1], mul4(yd, scale));
+          store44(data->corner_dir[2], mul4(zd, scale));
         }
         else {
-          data->corner_dir[0] = xd;
-          data->corner_dir[1] = yd;
-          data->corner_dir[2] = zd;
+          store44(data->corner_dir[0], xd);
+          store44(data->corner_dir[1], yd);
+          store44(data->corner_dir[2], zd);
         }
         rays.setFlag(RayPacket::HaveCornerRays);
       }
     }
 #else
     for(int i = rays.begin(); i < rays.end(); i++){
-      Vector raydir(v*rays.getImageCoordinates(i, 
0)+u*rays.getImageCoordinates(i, 1)+direction);
+      const float v_imageCoord = rays.getImageCoordinates(i, 0);
+      const float u_imageCoord = rays.getImageCoordinates(i, 1);
+      Vector raydir(v*v_imageCoord + u*u_imageCoord + direction);
       if (NORMALIZE_RAYS)
         raydir.normalize();
       rays.setRay(i, eye, raydir);
+      if (CREATE_CORNER_RAYS) {
+          min_v = SCIRun::Min(min_v, v_imageCoord);
+          max_v = SCIRun::Max(max_v, v_imageCoord);
+          min_u = SCIRun::Min(min_u, u_imageCoord);
+          max_u = SCIRun::Max(max_u, u_imageCoord);
+      }
+    }
+    
+    if (CREATE_CORNER_RAYS) {
+      Vector raydir[4] = { v*min_v + u*min_u + direction,
+                           v*min_v + u*max_u + direction,
+                           v*max_v + u*min_u + direction,
+                           v*max_v + u*max_u + direction};
+      for (int i=0; i < 4; ++i) {
+        if (NORMALIZE_RAYS)
+          raydir[i].normalize();
+        rays.data->corner_dir[0][i] = raydir[i][0];
+        rays.data->corner_dir[1][i] = raydir[i][1];
+        rays.data->corner_dir[2][i] = raydir[i][2];
+      }
+      rays.setFlag(RayPacket::HaveCornerRays);
     }
 #endif
     if (NORMALIZE_RAYS)

Modified: trunk/Model/Groups/Mesh.cc
==============================================================================
--- trunk/Model/Groups/Mesh.cc  (original)
+++ trunk/Model/Groups/Mesh.cc  Sun Sep 23 18:58:55 2007
@@ -23,7 +23,7 @@
   Group::clone(depth, copy);
 
   for (unsigned int i=0; i < objs.size(); ++i) {
-    static_cast<MeshTriangle*>(copy->objs[i])->attachMesh(copy);
+    copy->get(i)->attachMesh(copy);
   }
 
   copy->vertices = vertices;
@@ -140,6 +140,17 @@
   throw SCIRun::InternalError(string("Illegal call to ") + __func__, 
__FILE__, __LINE__);
 }
 
+MeshTriangle* Mesh::get( size_t i ) {
+  ASSERT( i < objs.size() );
+  return static_cast<MeshTriangle*>(objs[i]);
+}
+
+const MeshTriangle* Mesh::get(size_t i) const
+{
+  ASSERT( i < objs.size() );
+  return static_cast<MeshTriangle*>(objs[i]);
+}
+
 void Mesh::addTriangle(MeshTriangle *meshTri)
 {
   meshTri->attachMesh(this, objs.size());
@@ -288,7 +299,7 @@
       face_material[tri_index] = face_material.back();
       face_material.pop_back();
 
-      MeshTriangle* tri = static_cast<MeshTriangle*>(objs[tri_index]);
+      MeshTriangle* tri = get(tri_index);
       tri->attachMesh(this, tri_index);
       shrinkTo(size()-1, false); //note this might cause a memory leak.
 

Modified: trunk/Model/Groups/Mesh.h
==============================================================================
--- trunk/Model/Groups/Mesh.h   (original)
+++ trunk/Model/Groups/Mesh.h   Sun Sep 23 18:58:55 2007
@@ -66,6 +66,9 @@
     virtual void add(Object* obj);
     virtual void set( int i, Object *obj );
 
+    MeshTriangle* get( size_t i );
+    const MeshTriangle* get( size_t i ) const;
+
     //this only adds the triangle to the group. You still need to add
     //the vertices, materials, etc. to the mesh.
     void addTriangle(MeshTriangle *tri);

Modified: trunk/Model/Groups/private/CGT.cc
==============================================================================
--- trunk/Model/Groups/private/CGT.cc   (original)
+++ trunk/Model/Groups/private/CGT.cc   Sun Sep 23 18:58:55 2007
@@ -465,7 +465,8 @@
     sse_t dir4[3];
     for (int i=0;i<3;i++)
     {
-      dir4[i] = mul4(ray.data->corner_dir[i],set4(((float4&)scaleN)[i]));
+      dir4[i] = mul4(load44(ray.data->corner_dir[i]),
+                     set4(((float4&)scaleN)[i]));
     }
 
     // all rays in u space are u(k) = f_orgU + d_u/d_k * (k - f_orgK)
@@ -524,9 +525,9 @@
     maxDv *= DK;
 
     //some intersecters, like WaldTriangle use corner rays, so get corners.
-    ray.data->corner_dir[K] = set4(DK);
-    ray.data->corner_dir[U] = set44(maxDu, maxDu, minDu, minDu);
-    ray.data->corner_dir[V] = set44(maxDv, minDv, maxDv, minDv);
+    store44(ray.data->corner_dir[K], set4(DK));
+    store44(ray.data->corner_dir[U], set44(maxDu, maxDu, minDu, minDu));
+    store44(ray.data->corner_dir[V], set44(maxDv, minDv, maxDv, minDv));
     ray.setFlag(RayPacket::HaveCornerRays);
 
     float u_scale = ((float4&)scaleN)[U] * ((float4&)inv_scaleN)[K]*DK;

Modified: trunk/Model/Primitives/WaldTriangle.cc
==============================================================================
--- trunk/Model/Primitives/WaldTriangle.cc      (original)
+++ trunk/Model/Primitives/WaldTriangle.cc      Sun Sep 23 18:58:55 2007
@@ -233,17 +233,17 @@
                           mul4(sse_n_v, org_kv))));
 
       if (HasCornerRays) {
-        const sse_t nd0 = add4(add4(mul4(sse_n_u,data->corner_dir[ku]),
-                                    mul4(sse_n_v,data->corner_dir[kv])),
-                               data->corner_dir[k]);
+        const sse_t nd0 = 
add4(add4(mul4(sse_n_u,load44(data->corner_dir[ku])),
+                                    
mul4(sse_n_v,load44(data->corner_dir[kv]))),
+                               load44(data->corner_dir[k]));
         const sse_t nd = oneOver(nd0);
         const sse_t f  = mul4(f0,nd);
         sse_t mask = cmp4_gt(f,_mm_eps);
         if (none4(mask))
           return;
 
-        const sse_t hu = add4(org_ku,mul4(f,data->corner_dir[ku]));
-        const sse_t hv = add4(org_kv,mul4(f,data->corner_dir[kv]));
+        const sse_t hu = add4(org_ku,mul4(f,load44(data->corner_dir[ku])));
+        const sse_t hv = add4(org_kv,mul4(f,load44(data->corner_dir[kv])));
         const sse_t lambda = add4(sse_b_d,
                                   add4(mul4(hu,sse_b_nu),
                                        mul4(hv,sse_b_nv)));
@@ -450,17 +450,19 @@
    const Real* const dir_ku = data->direction[ku];
    const Real* const dir_kv = data->direction[kv];
 
-   float org_k, org_ku, org_kv, f0;
+   float org_k = 0,
+     org_ku = 0, 
+     org_kv = 0,
+     f0 = 0;
 
    const bool RaysConstantOrigin = rays.getAllFlags() & 
RayPacket::ConstantOrigin;
 
-   //if (RaysConstantOrigin) { NOTE(boulos): Lame compiler can't tell
-   //it's one or the other, so this has to always happen (not a big
-   //deal though) to avoid warnings.
-   org_k  = data->origin[axis][rays.begin()];
-   org_ku = data->origin[ku][rays.begin()];
-   org_kv = data->origin[kv][rays.begin()];
-   f0 = n_d - (org_k + n_u * org_ku + n_v * org_kv);
+   if (RaysConstantOrigin) {
+     org_k  = data->origin[axis][rays.begin()];
+     org_ku = data->origin[ku][rays.begin()];
+     org_kv = data->origin[kv][rays.begin()];
+     f0 = n_d - (org_k + n_u * org_ku + n_v * org_kv);
+   }
 
    for (int i = rays.begin(); i < rays.end(); i++ )
    {

---

• [Manta] r1738 - in trunk: Interface Model/Cameras Model/Groups Model/Groups/private Model/Primitives, thiago, 09/23/2007

---

Archive powered by MHonArc 2.6.16.