Text archives Help

---

Author: bigler
Date: Fri Mar  3 17:04:40 2006
New Revision: 969

Modified:
   trunk/Core/Geometry/Vector.h
   trunk/Engine/ImageTraversers/HardTile.cc
   trunk/Engine/Renderers/RayGen.cc
   trunk/Interface/RayPacket.h
   trunk/Model/Cameras/PinholeCamera.cc
Log:
Committing latest stuff for performance.

Modified: trunk/Core/Geometry/Vector.h
==============================================================================
--- trunk/Core/Geometry/Vector.h        (original)
+++ trunk/Core/Geometry/Vector.h        Fri Mar  3 17:04:40 2006
@@ -64,9 +64,9 @@
     }
 
     Vector( const Vector& copy) {
-      data[0] = copy[0];
-      data[1] = copy[1];
-      data[2] = copy[2];
+      data[0] = copy.data[0];
+      data[1] = copy.data[1];
+      data[2] = copy.data[2];
     }
 
     // Copy from another vector of the same size, but of a templated type.
@@ -79,9 +79,9 @@
 
 #ifndef SWIG
     Vector& operator=(const Vector& copy) {
-      data[0] = copy[0];
-      data[1] = copy[1];
-      data[2] = copy[2];
+      data[0] = copy.data[0];
+      data[1] = copy.data[1];
+      data[2] = copy.data[2];
       return *this;
     }
 #endif
@@ -338,7 +338,8 @@
     friend Vector Min(const Vector& v1, const Vector& v2);
     friend Vector Max(const Vector& v1, const Vector& v2);
     friend Vector Interpolate(const Vector& v1, const Vector& v2, Real 
weight);
-  private:
+    
+    //private:
     Real data[3];
 
     // Do not use this function!!!!  Use getDataPtr() instead.
@@ -351,9 +352,9 @@
   inline Vector operator*(S s, const Vector& v)
   {
     Real scalar = static_cast<Real>(s);
-    Vector result(scalar * v[0],
-                  scalar * v[1],
-                  scalar * v[2]);
+    Vector result(scalar * v.data[0],
+                  scalar * v.data[1],
+                  scalar * v.data[2]);
     return result;
   }
 
@@ -361,51 +362,51 @@
   inline Vector operator*(const Vector& v, S s)
   {
     Real scalar = static_cast<Real>(s);
-    Vector result(v[0] * scalar,
-                  v[1] * scalar,
-                  v[2] * scalar);
+    Vector result(v.data[0] * scalar,
+                  v.data[1] * scalar,
+                  v.data[2] * scalar);
     return result;
   }
 
   inline Real Dot(const Vector& v1, const Vector& v2)
   {
-    return (v1[0] * v2[0] +
-            v1[1] * v2[1] +
-            v1[2] * v2[2]);
+    return (v1.data[0] * v2.data[0] +
+            v1.data[1] * v2.data[1] +
+            v1.data[2] * v2.data[2]);
   }
 
   // Cross product is only defined for R3
   inline Vector Cross(const Vector& v1, const Vector& v2)
   {
-    return Vector(v1[1]*v2[2] - v1[2]*v2[1],
-                  v1[2]*v2[0] - v1[0]*v2[2],
-                  v1[0]*v2[1] - v1[1]*v2[0]);
+    return Vector(v1.data[1]*v2.data[2] - v1.data[2]*v2.data[1],
+                  v1.data[2]*v2.data[0] - v1.data[0]*v2.data[2],
+                  v1.data[0]*v2.data[1] - v1.data[1]*v2.data[0]);
   }
 
   inline Vector Min(const Vector& v1, const Vector& v2)
   {
     using SCIRun::Min;
-    Vector result(Min(v1[0], v2[0]),
-                  Min(v1[1], v2[1]),
-                  Min(v1[2], v2[2]));
+    Vector result(Min(v1.data[0], v2.data[0]),
+                  Min(v1.data[1], v2.data[1]),
+                  Min(v1.data[2], v2.data[2]));
     return result;
   }
 
   inline Vector Max(const Vector& v1, const Vector& v2)
   {
     using SCIRun::Max;
-    Vector result(Max(v1[0], v2[0]),
-                  Max(v1[1], v2[1]),
-                  Max(v1[2], v2[2]));
+    Vector result(Max(v1.data[0], v2.data[0]),
+                  Max(v1.data[1], v2.data[1]),
+                  Max(v1.data[2], v2.data[2]));
     return result;
   }
 
   inline Vector Interpolate(const Vector& v1, const Vector& v2, Real weight)
   {
     using SCIRun::Interpolate;
-    Vector result(Interpolate(v1[0], v2[0], weight),
-                  Interpolate(v1[1], v2[1], weight),
-                  Interpolate(v1[2], v2[2], weight));
+    Vector result(Interpolate(v1.data[0], v2.data[0], weight),
+                  Interpolate(v1.data[1], v2.data[1], weight),
+                  Interpolate(v1.data[2], v2.data[2], weight));
     return result;
   }
 

Modified: trunk/Engine/ImageTraversers/HardTile.cc
==============================================================================
--- trunk/Engine/ImageTraversers/HardTile.cc    (original)
+++ trunk/Engine/ImageTraversers/HardTile.cc    Fri Mar  3 17:04:40 2006
@@ -134,8 +134,8 @@
           if (xnarf > xend) xnarf = xend;
           // Create a Fragment that is consecutive in X pixels
           Fragment frag(0, x, xnarf, y);
-          //context.pixelSampler->renderFragment(context, frag);
-          //image->set(frag);
+          context.pixelSampler->renderFragment(context, frag);
+          image->set(frag);
         }
       }
 

Modified: trunk/Engine/Renderers/RayGen.cc
==============================================================================
--- trunk/Engine/Renderers/RayGen.cc    (original)
+++ trunk/Engine/Renderers/RayGen.cc    Fri Mar  3 17:04:40 2006
@@ -6,6 +6,11 @@
 #include <Interface/Context.h>
 #include <Interface/RayPacket.h>
 #include <Core/Util/Assert.h>
+#include <Interface/Camera.h>
+#include <Interface/Material.h>
+#include <Interface/Object.h>
+#include <Interface/Scene.h>
+
 
 using namespace Manta;
 
@@ -34,9 +39,10 @@
 {
 }
 
-void RayGen::traceEyeRays(const RenderContext&, RayPacket& rays)
+void RayGen::traceEyeRays(const RenderContext& context, RayPacket& rays)
 {
-
+  ASSERT(rays.getFlag(RayPacket::HaveImageCoordinates));
+  context.camera->makeRays(rays);
 }
 
 void RayGen::traceRays(const RenderContext&, RayPacket& rays)

Modified: trunk/Interface/RayPacket.h
==============================================================================
--- trunk/Interface/RayPacket.h (original)
+++ trunk/Interface/RayPacket.h Fri Mar  3 17:04:40 2006
@@ -166,7 +166,7 @@
       data->image[1][which] = imageY;
       data->whichEye[which] = whichEye;
     }
-    Real getImageCoordinates(int which, int dim)
+    Real getImageCoordinates(int which, int dim) const
     {
       return data->image[dim][which];
     }
@@ -179,9 +179,9 @@
     void setRay(int which, const Vector& origin, const Vector& direction)
     {
       for(int i=0;i<3;i++)
-        data->origin[i][which] = origin[i];
+        data->origin[i][which] = origin.data[i];
       for(int i=0;i<3;i++)
-        data->direction[i][which] = direction[i];
+        data->direction[i][which] = direction.data[i];
     }
     void setRay(int which, const Ray& ray)
     {
@@ -419,7 +419,7 @@
       for(int i=0;i<Color::NumComponents;i++)
         data->importance[i][which] = importance[i];
     }
-    Color getImportance(int which)
+    Color getImportance(int which) const
     {
       Color result;
       for(int i=0;i<Color::NumComponents;i++)
@@ -554,13 +554,13 @@
     }
     // This will copy the contects of the scratchpad from the incoming
     // RayPacket.
-    void copyScratchpad(int which, RayPacket& copy, int which_copy) {
+    void copyScratchpad(int which, const RayPacket& copy, int which_copy) {
       memcpy( data->scratchpad_data[which],
               copy.data->scratchpad_data[which_copy],
               RayPacketData::MaxScratchpadSize);
     }
 
-  private:
+    //  private:
     RayPacket(const RayPacket&);
     RayPacket& operator=(const RayPacket&);
 

Modified: trunk/Model/Cameras/PinholeCamera.cc
==============================================================================
--- trunk/Model/Cameras/PinholeCamera.cc        (original)
+++ trunk/Model/Cameras/PinholeCamera.cc        Fri Mar  3 17:04:40 2006
@@ -127,23 +127,36 @@
   ASSERT(rays.getFlag(RayPacket::HaveImageCoordinates));
   rays.setFlag(RayPacket::ConstantOrigin);
 
-  Vector stereo_eye[2];
-  stereo_eye[0] = (eye - (v*stereo_offset));
-  stereo_eye[1] = (eye + (v*stereo_offset));
-  
-  if(normalizeRays){    
+  if(normalizeRays)
+    {
+    Vector stereo_eye[2];
+    stereo_eye[0] = (eye - (v*stereo_offset));
+    stereo_eye[1] = (eye + (v*stereo_offset));
+    
     for(int i=rays.begin();i<rays.end();i++){
       Vector raydir(v*rays.getImageCoordinates(i, 
0)+u*rays.getImageCoordinates(i, 1)+direction);
       raydir.normalize();
       rays.setRay(i, stereo_eye[rays.getWhichEye(i)], raydir);
     }
     rays.setFlag(RayPacket::NormalizedDirections);
-
-
   } else {
-    for(int i=rays.begin();i<rays.end();i++){
-      Vector raydir(v*rays.getImageCoordinates(i, 
0)+u*rays.getImageCoordinates(i, 1)+direction);
-      rays.setRay(i, stereo_eye[rays.getWhichEye(i)], raydir);
+    Real u_vec[3] = { u[0], u[1], u[2] };
+    Real v_vec[3] = { v[0], v[1], v[2] };
+    Real d_vec[3] = { direction[0], direction[1], direction[2] };
+    
+    RayPacketData* data = rays.data;
+    for(int i=rays.begin();i<rays.end();i++)
+      {
+        data->origin[0][i] = eye.data[0];
+        data->origin[1][i] = eye.data[1];
+        data->origin[2][i] = eye.data[2];
+
+        const Real u_coord = data->image[1][i];
+        const Real v_coord = data->image[0][i];
+        
+        data->direction[0][i] = d_vec[0] + u_coord * u_vec[0] + v_coord * 
v_vec[0];
+        data->direction[1][i] = d_vec[1] + u_coord * u_vec[1] + v_coord * 
v_vec[1];
+        data->direction[2][i] = d_vec[2] + u_coord * u_vec[2] + v_coord * 
v_vec[2];        
     }
   }
 }

---

• [MANTA] r969 - in trunk: Core/Geometry Engine/ImageTraversers Engine/Renderers Interface Model/Cameras, bigler, 03/03/2006

---

Archive powered by MHonArc 2.6.16.