Text archives Help

---

Author: sparker
Date: Wed Dec 21 16:12:00 2005
New Revision: 801

Modified:
   branches/vertical/Engine/PixelSamplers/JitterSampler.cc
   branches/vertical/Engine/PixelSamplers/SingleSampler.cc
   branches/vertical/Engine/Renderers/Moire.cc
   branches/vertical/Engine/Renderers/NullRenderer.cc
   branches/vertical/Engine/Renderers/Raytracer.cc
   branches/vertical/Engine/Shadows/HardShadows.cc
   branches/vertical/Engine/Shadows/NoShadows.cc
   branches/vertical/Interface/RayPacket.h
   branches/vertical/Model/AmbientLights/ConstantAmbient.cc
   branches/vertical/Model/Backgrounds/ConstantBackground.cc
   branches/vertical/Model/Cameras/PinholeCamera.cc
   branches/vertical/Model/Materials/Checker.cc
   branches/vertical/Model/Materials/Phong.cc
   branches/vertical/Model/Primitives/Parallelogram.cc
   branches/vertical/Model/Primitives/Plane.cc
   branches/vertical/Model/Primitives/Sphere.cc
   branches/vertical/Model/TexCoordMappers/UniformMapper.cc
   branches/vertical/Model/Textures/CheckerTexture.h
   branches/vertical/Model/Textures/Constant.h
Log:
Vertical ray packets now have a start/end instead of an offset within the 
raypacket
Performance is now 5% slower than horizontal


Modified: branches/vertical/Engine/PixelSamplers/JitterSampler.cc
==============================================================================
--- branches/vertical/Engine/PixelSamplers/JitterSampler.cc     (original)
+++ branches/vertical/Engine/PixelSamplers/JitterSampler.cc     Wed Dec 21 
16:12:00 2005
@@ -98,7 +98,7 @@
   int samples_collected = samples_collected_return;
   int current_fragment = current_fragment_return;
   Color fragment_color = Color::black();
-  for(int sample_index = 0; sample_index < rays.getSize(); sample_index++) {
+  for(int sample_index = rays.begin(); sample_index < rays.end(); 
sample_index++) {
     fragment_color += rays.getResult(sample_index);
     samples_collected++;
     // We've collected enough samples, so compute the average and
@@ -145,7 +145,7 @@
 
   int depth = 0;
   RayPacketData raydata;
-  RayPacket rays(raydata, RayPacket::MaxSize, depth, flags);
+  RayPacket rays(raydata, 0, RayPacket::MaxSize, depth, flags);
 
   Real inx = (Real)1/nx;
   Real iny = (Real)1/ny;

Modified: branches/vertical/Engine/PixelSamplers/SingleSampler.cc
==============================================================================
--- branches/vertical/Engine/PixelSamplers/SingleSampler.cc     (original)
+++ branches/vertical/Engine/PixelSamplers/SingleSampler.cc     Wed Dec 21 
16:12:00 2005
@@ -64,7 +64,7 @@
     // Create a ray packet
     int depth = 0;
     RayPacketData raydata;
-    RayPacket rays(raydata, size, depth, flags);
+    RayPacket rays(raydata, 0, size, depth, flags);
 
     // Check to see if the fragment is consecutive in x.
     if(fragment.getFlags() & Fragment::ConsecutiveX){

Modified: branches/vertical/Engine/Renderers/Moire.cc
==============================================================================
--- branches/vertical/Engine/Renderers/Moire.cc (original)
+++ branches/vertical/Engine/Renderers/Moire.cc Wed Dec 21 16:12:00 2005
@@ -56,7 +56,7 @@
   ASSERT(rays.getFlag(RayPacket::HaveImageCoordinates));
   double phase = context.frameState->frameTime * M_PI;
   double cycles = 100;
-  for(int i=0;i<rays.getSize();i++){
+  for(int i=rays.begin();i<rays.end();i++){
     Real ix = rays.getImageCoordinates(i, 0);
     Real iy = rays.getImageCoordinates(i, 1);
     Real dist2 = ix*ix + iy*iy;

Modified: branches/vertical/Engine/Renderers/NullRenderer.cc
==============================================================================
--- branches/vertical/Engine/Renderers/NullRenderer.cc  (original)
+++ branches/vertical/Engine/Renderers/NullRenderer.cc  Wed Dec 21 16:12:00 
2005
@@ -38,14 +38,14 @@
 void NullRenderer::traceEyeRays(const RenderContext&, RayPacket& rays)
 {
   ASSERT(rays.getFlag(RayPacket::HaveImageCoordinates));
-  for(int i=0;i<rays.getSize();i++){
+  for(int i=rays.begin();i<rays.end();i++){
     rays.setResult(i, color);
   }
 }
 
 void NullRenderer::traceRays(const RenderContext&, RayPacket& rays)
 {
-  for(int i=0;i<rays.getSize();i++){
+  for(int i=rays.begin();i<rays.end();i++){
     rays.setResult(i, color);
   }
 }

Modified: branches/vertical/Engine/Renderers/Raytracer.cc
==============================================================================
--- branches/vertical/Engine/Renderers/Raytracer.cc     (original)
+++ branches/vertical/Engine/Renderers/Raytracer.cc     Wed Dec 21 16:12:00 
2005
@@ -53,11 +53,11 @@
 
   // Go through the ray packet and shade them.  Group rays that hit the
   // same object and material to shade with a single shade call
-  for(int i = 0;i<rays.getSize();){
+  for(int i = rays.begin();i<rays.end();){
     if(rays.wasHit(i)){
       const Material* hit_matl = rays.hitMaterial(i);
       int end = i+1;
-      while(end < rays.getSize() && rays.wasHit(end) &&
+      while(end < rays.end() && rays.wasHit(end) &&
             rays.hitMaterial(end) == hit_matl)
        end++;
       RayPacket subPacket(rays, i, end);
@@ -65,7 +65,7 @@
       i=end;
     } else {
       int end = i+1;
-      while(end < rays.getSize() && !rays.wasHit(end))
+      while(end < rays.end() && !rays.wasHit(end))
        end++;
       RayPacket subPacket(rays, i, end);
       context.scene->getBackground()->shade(context, subPacket);

Modified: branches/vertical/Engine/Shadows/HardShadows.cc
==============================================================================
--- branches/vertical/Engine/Shadows/HardShadows.cc     (original)
+++ branches/vertical/Engine/Shadows/HardShadows.cc     Wed Dec 21 16:12:00 
2005
@@ -83,7 +83,7 @@
 
   int sidx = 0;
   int end = start;
-  while(end < rays.getSize() && sidx+nlights <= RayPacket::MaxSize){
+  while(end < rays.end() && sidx+nlights <= RayPacket::MaxSize){
 
     // Specify the beginning index for this ray in the shadow packet.
     rays.setShadowBegin(end, sidx);

Modified: branches/vertical/Engine/Shadows/NoShadows.cc
==============================================================================
--- branches/vertical/Engine/Shadows/NoShadows.cc       (original)
+++ branches/vertical/Engine/Shadows/NoShadows.cc       Wed Dec 21 16:12:00 
2005
@@ -27,7 +27,7 @@
   rays.computeHitPositions();
 
   int sidx = 0;
-  while(start < rays.getSize() && sidx+nlights < RayPacket::MaxSize){
+  while(start < rays.end() && sidx+nlights < RayPacket::MaxSize){
     rays.setShadowBegin(start, sidx);
     for(int l = 0;l<nlights;l++){
       Color color;

Modified: branches/vertical/Interface/RayPacket.h
==============================================================================
--- branches/vertical/Interface/RayPacket.h     (original)
+++ branches/vertical/Interface/RayPacket.h     Wed Dec 21 16:12:00 2005
@@ -96,14 +96,14 @@
       ConstantSigns         = 0x1000
     };
 
-    RayPacket(RayPacketData& data, int size, int depth, int flags)
-      : data(&data), start(0), end(size), depth(depth), flags(flags)
+    RayPacket(RayPacketData& data, int rayBegin, int rayEnd, int depth, int 
flags)
+      : data(&data), rayBegin(rayBegin), rayEnd(rayEnd), depth(depth), 
flags(flags)
       {
       }
 
     // Create a subset of another raypacket
-    RayPacket(RayPacket& parent, int start, int end)
-      : data(parent.data), start(parent.start+start), end(parent.start+end),
+    RayPacket(RayPacket& parent, int rayBegin, int rayEnd)
+      : data(parent.data), rayBegin(rayBegin), rayEnd(rayEnd),
         depth(parent.depth), flags(parent.flags)
       {
       }
@@ -132,160 +132,163 @@
     void resetFlag(int flag) {
       flags &= ~flag;
     }
-    int getSize() const {
-      return end-start;
+    int begin() const {
+      return rayBegin;
+    }
+    int end() const {
+      return rayEnd;
     }
     void resetHits() {
-      for(int i=start;i<end;i++){
+      for(int i=rayBegin;i<rayEnd;i++){
         data->hitMatl[i] = 0;
         data->minT[i] = MAXT;
       }
       flags |= HaveHitRecords;
     }
     void resetHit(int which, Real maxt) {
-      data->hitMatl[which+start] = 0;
-      data->minT[which+start] = maxt;
+      data->hitMatl[which] = 0;
+      data->minT[which] = maxt;
     }
 
     void resize(int newSize)
     {
-      start = 0; end = newSize;
+      rayBegin = 0; rayEnd = newSize;
     }
 
     void setPixel(int which, int whichEye, Real imageX, Real imageY)
     {
-      data->image[0][which+start] = imageX;
-      data->image[1][which+start] = imageY;
-      data->whichEye[which+start] = whichEye;
+      data->image[0][which] = imageX;
+      data->image[1][which] = imageY;
+      data->whichEye[which] = whichEye;
     }
 
     void setResult(int which, const Color& color)
     {
       for(int i=0;i<Color::NumComponents;i++)
-        data->color[i][which+start] = color[i];
+        data->color[i][which] = color[i];
     }
     void setImportance(int which, const Color& importance)
     {
       for(int i=0;i<Color::NumComponents;i++)
-        data->importance[i][which+start] = importance[i];
+        data->importance[i][which] = importance[i];
     }
     Color getImportance(int which)
     {
       Color result;
       for(int i=0;i<Color::NumComponents;i++)
-        result[i] = data->importance[i][which+start];
+        result[i] = data->importance[i][which];
       return result;
     }
 
     void setAmbientLight(int which, const Color& ambientLight)
     {
       for(int i=0;i<Color::NumComponents;i++)
-        data->ambientLight[i][which+start] = ambientLight[i];
+        data->ambientLight[i][which] = ambientLight[i];
     }
     Color getAmbientLight(int which)
     {
       Color result;
       for(int i=0;i<Color::NumComponents;i++)
-        result[i] = data->ambientLight[i][which+start];
+        result[i] = data->ambientLight[i][which];
       return result;
     }
     void setLight(int which, const Color& light)
     {
       for(int i=0;i<Color::NumComponents;i++)
-        data->light[i][which+start] = light[i];
+        data->light[i][which] = light[i];
     }
     Color getLight(int which)
     {
       Color result;
       for(int i=0;i<Color::NumComponents;i++)
-        result[i] = data->light[i][which+start];
+        result[i] = data->light[i][which];
       return result;
     }
     int shadowBegin(int which)
     {
-      return data->shadowBegin[which+start];
+      return data->shadowBegin[which];
     }
     int shadowEnd(int which)
     {
-      return data->shadowEnd[which+start];
+      return data->shadowEnd[which];
     }
     void setShadowBegin(int which, int s)
     {
-      data->shadowBegin[which+start] = s;
+      data->shadowBegin[which] = s;
     }
     void setShadowEnd(int which, int s)
     {
-      data->shadowEnd[which+start] = s;
+      data->shadowEnd[which] = s;
     }
 
     Real getImageCoordinates(int which, int dim)
     {
-      return data->image[dim][which+start];
+      return data->image[dim][which];
     }
     int getWhichEye(int which) const
     {
-      return data->whichEye[which+start];
+      return data->whichEye[which];
     }
 
     void setRay(int which, const Point& origin, const Vector& direction)
     {
       for(int i=0;i<3;i++)
-        data->origin[i][which+start] = origin[i];
+        data->origin[i][which] = origin[i];
       for(int i=0;i<3;i++)
-        data->direction[i][which+start] = direction[i];
+        data->direction[i][which] = direction[i];
     }
     void setDirection(int which, const Vector& direction)
     {
       for(int i=0;i<3;i++)
-        data->direction[i][which+start] = direction[i];
+        data->direction[i][which] = direction[i];
     }
     void setTexCoords(int which, const Point& tc)
     {
       for(int i=0;i<3;i++)
-        data->texCoords[i][which+start] = tc[i];
+        data->texCoords[i][which] = tc[i];
     }
 
     Point getTexCoords(int which) const
     {
-      return Point(data->texCoords[0][which+start], 
data->texCoords[1][which+start], data->texCoords[2][which+start]);
+      return Point(data->texCoords[0][which], data->texCoords[1][which], 
data->texCoords[2][which]);
     }
 
     void setNormal(int which, const Vector& normal)
     {
       for(int i=0;i<3;i++)
-        data->normal[i][which+start] = normal[i];
+        data->normal[i][which] = normal[i];
     }
 
     Point getOrigin(int which) const
     {
-      return Point(data->origin[0][which+start], 
data->origin[1][which+start], data->origin[2][which+start]);
+      return Point(data->origin[0][which], data->origin[1][which], 
data->origin[2][which]);
     }
     Vector getDirection(int which) const
     {
-      return Vector(data->direction[0][which+start], 
data->direction[1][which+start], data->direction[2][which+start]);
+      return Vector(data->direction[0][which], data->direction[1][which], 
data->direction[2][which]);
     }
     Real getMinT(int which) const
     {
-      return data->minT[which+start];
+      return data->minT[which];
     }
     Vector getNormal(int which) const
     {
-      return Vector(data->normal[0][which+start], 
data->normal[1][which+start], data->normal[2][which+start]);
+      return Vector(data->normal[0][which], data->normal[1][which], 
data->normal[2][which]);
     }
     Point getHitPosition(int which) const
     {
-      return Point(data->hitPosition[0][which+start], 
data->hitPosition[1][which+start], data->hitPosition[2][which+start]);
+      return Point(data->hitPosition[0][which], data->hitPosition[1][which], 
data->hitPosition[2][which]);
     }
 
     bool hit(int which, Real t, const Material* matl, const Primitive* prim,
              const TexCoordMapper* tex) {
       if(t < (Real)T_EPSILON)
         return false;
-      if(t < data->minT[which+start]){
-        data->minT[which+start] = t;
-        data->hitMatl[which+start] = matl;
-        data->hitPrim[which+start] = prim;
-        data->hitTex[which+start] = tex;
+      if(t < data->minT[which]){
+        data->minT[which] = t;
+        data->hitMatl[which] = matl;
+        data->hitPrim[which] = prim;
+        data->hitTex[which] = tex;
         return true;
       } else {
         return false;
@@ -307,20 +310,20 @@
 #     else
       ASSERT(sizeof(T) <= RayPacketData::MaxScratchpadSize);
 #     endif
-      return *(T*)data->scratchpad_data[which+start];
+      return *(T*)data->scratchpad_data[which];
     }
     Color getResult(int which) const
     {
       Color result;
       for(int i=0;i<Color::NumComponents;i++)
-        result[i] = data->color[i][which+start];
+        result[i] = data->color[i][which];
       return result;
     }
     Color getColor(int which) const
     {
       Color result;
       for(int i=0;i<Color::NumComponents;i++)
-        result[i] = data->color[i][which+start];
+        result[i] = data->color[i][which];
       return result;
     }
     void normalizeDirections()
@@ -329,7 +332,7 @@
         return;
 
       if(flags & HaveHitRecords){
-        for(int i=start;i<end;i++){
+        for(int i=rayBegin;i<rayEnd;i++){
           Real sum = 0;
           for(int j=0;j<3;j++)
             sum += data->direction[j][i] * data->direction[j][i];
@@ -341,7 +344,7 @@
             data->direction[j][i] *= scale;
         }
       } else {
-        for(int i=start;i<end;i++){
+        for(int i=rayBegin;i<rayEnd;i++){
           Real sum = 0;
           for(int j=0;j<3;j++)
             sum += data->direction[j][i] * data->direction[j][i];
@@ -357,7 +360,7 @@
     {
       if(flags & HaveHitPositions)
         return;
-      for(int i=start;i<end;i++) {
+      for(int i=rayBegin;i<rayEnd;i++) {
         for(int j=0;j<3;j++)
           data->hitPosition[j][i] = data->origin[j][i] + 
data->direction[j][i] * data->minT[i];
       }
@@ -401,7 +404,7 @@
     {
       if(flags & (HaveTexture2|HaveTexture3))
         return;
-      const TexCoordMapper* tex = data->hitTex[start];
+      const TexCoordMapper* tex = data->hitTex[rayBegin];
       tex->computeTexCoords2(context, *this);
       flags |= HaveTexture2;
     }
@@ -409,7 +412,7 @@
     {
       if(flags & HaveTexture3)
         return;
-      const TexCoordMapper* tex = data->hitTex[start];
+      const TexCoordMapper* tex = data->hitTex[rayBegin];
       tex->computeTexCoords3(context, *this);
       flags |= HaveTexture2|HaveTexture3;
     }
@@ -431,12 +434,12 @@
         return;
       
       // Compute normals
-      for(int i=start;i<end;){
+      for(int i=rayBegin;i<rayEnd;){
         const Primitive* prim = data->hitPrim[i];
         int tend = i+1;
-        while(tend < end && data->hitPrim[tend] == prim)
+        while(tend < rayEnd && data->hitPrim[tend] == prim)
           tend++;
-        RayPacket subPacket(*this, i-start, tend-start);
+        RayPacket subPacket(*this, i, tend);
         prim->computeNormal(context, subPacket);
         i=tend;
       }
@@ -451,24 +454,24 @@
     void initializeImportance()
     {
       for(int j=0;j<Color::NumComponents;j++)
-        for(int i=start;i<end;i++)
+        for(int i=rayBegin;i<rayEnd;i++)
           data->importance[j][i] = 1;
     }
     bool wasHit(int which)
     {
-      return data->hitMatl[which+start] != 0;
+      return data->hitMatl[which] != 0;
     }
     const Material* hitMaterial(int which)
     {
-      return data->hitMatl[which+start];
+      return data->hitMatl[which];
     }
   private:
     RayPacket(const RayPacket&);
     RayPacket& operator=(const RayPacket&);
 
     RayPacketData* data;
-    int start;
-    int end;
+    int rayBegin;
+    int rayEnd;
     int depth;
     int flags;
   };

Modified: branches/vertical/Model/AmbientLights/ConstantAmbient.cc
==============================================================================
--- branches/vertical/Model/AmbientLights/ConstantAmbient.cc    (original)
+++ branches/vertical/Model/AmbientLights/ConstantAmbient.cc    Wed Dec 21 
16:12:00 2005
@@ -26,7 +26,7 @@
 void ConstantAmbient::computeAmbient(const RenderContext&,
                                     RayPacket& rays) const
 {
-  for(int i=0;i<rays.getSize();i++)
+  for(int i=rays.begin();i<rays.end();i++)
     rays.setAmbientLight(i, color);
 }
 

Modified: branches/vertical/Model/Backgrounds/ConstantBackground.cc
==============================================================================
--- branches/vertical/Model/Backgrounds/ConstantBackground.cc   (original)
+++ branches/vertical/Model/Backgrounds/ConstantBackground.cc   Wed Dec 21 
16:12:00 2005
@@ -19,6 +19,6 @@
 
 void ConstantBackground::shade(const RenderContext&, RayPacket& rays) const
 {
-  for(int i=0;i<rays.getSize();i++)
+  for(int i=rays.begin();i<rays.end();i++)
     rays.setResult(i, bgcolor);
 }

Modified: branches/vertical/Model/Cameras/PinholeCamera.cc
==============================================================================
--- branches/vertical/Model/Cameras/PinholeCamera.cc    (original)
+++ branches/vertical/Model/Cameras/PinholeCamera.cc    Wed Dec 21 16:12:00 
2005
@@ -135,7 +135,7 @@
   stereo_eye[1] = (eye + (v*stereo_offset));
   
   if(normalizeRays){    
-    for(int i=0;i<rays.getSize();i++){
+    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);
@@ -144,7 +144,7 @@
 
 
   } else {
-    for(int i=0;i<rays.getSize();i++){
+    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);
     }

Modified: branches/vertical/Model/Materials/Checker.cc
==============================================================================
--- branches/vertical/Model/Materials/Checker.cc        (original)
+++ branches/vertical/Model/Materials/Checker.cc        Wed Dec 21 16:12:00 
2005
@@ -39,14 +39,13 @@
   int i1 = (int)vv1;
   int i2 = (int)vv2;
   int which0 = (i1+i2)%2;
-  int start = 0;
-  while(start < rays.getSize()){
+  for(int start = rays.begin(); start < rays.end();){
     int stop = start+1;
     // I'm not sure what the default value for "which" should be, but
     // this will not change the value of "which0" if "which" is never
     // changed.  - James Bigler
     int which = which0;
-    while(stop < rays.getSize()){
+    while(stop < rays.end()){
       Real vv1 = Dot(rays.getTexCoords(stop), v1);
       Real vv2 = Dot(rays.getTexCoords(stop), v2);
       if(vv1<0)

Modified: branches/vertical/Model/Materials/Phong.cc
==============================================================================
--- branches/vertical/Model/Materials/Phong.cc  (original)
+++ branches/vertical/Model/Materials/Phong.cc  Wed Dec 21 16:12:00 2005
@@ -69,11 +69,11 @@
   // We normalized directions for proper dot product computation.
   rays.normalizeDirections();
 
-  int start = 0;
+  int start = rays.begin();
 
   do {
     RayPacketData shadowData;
-    RayPacket shadowRays(shadowData, 0, rays.getDepth(), 0);
+    RayPacket shadowRays(shadowData, 0, 0, rays.getDepth(), 0);
 
     // Call the shadowalgorithm to generate shadow rays.  The shadowAlgorithm
     // will potentially increment the light index.  If some lights do not
@@ -103,7 +103,7 @@
       rays.setResult(i, diffuse[i]*totalDiffuse+specular[i]*totalSpecular);
     }
     start = end;
-  } while(start < rays.getSize());
+  } while(start < rays.end());
 
   // Compute reflections
   if(do_refl && rays.getDepth() < 
context.scene->getRenderParameters().maxDepth){
@@ -112,9 +112,9 @@
 
     rays.computeHitPositions();
     RayPacketData rdata;
-    RayPacket refl_rays(rdata, rays.getSize(), rays.getDepth()+1,
+    RayPacket refl_rays(rdata, rays.begin(), rays.end(), rays.getDepth()+1,
                         RayPacket::NormalizedDirections);
-    for(int i=0;i<rays.getSize();i++){
+    for(int i=rays.begin();i<rays.end();i++){
       Vector refl_dir = (rays.getDirection(i) -
                          rays.getNormal(i)*(2*Dot(rays.getNormal(i), 
rays.getDirection(i) )));
       refl_rays.setRay(i, rays.getHitPosition(i), refl_dir);
@@ -122,7 +122,7 @@
     }
     refl_rays.resetHits();
     context.renderer->traceRays(context, refl_rays);
-    for(int i=0;i<rays.getSize();i++)
+    for(int i=rays.begin();i<rays.end();i++)
       rays.setResult(i, rays.getColor(i) + refl_rays.getColor(i) * refl[i]);
   }
 }

Modified: branches/vertical/Model/Primitives/Parallelogram.cc
==============================================================================
--- branches/vertical/Model/Primitives/Parallelogram.cc (original)
+++ branches/vertical/Model/Primitives/Parallelogram.cc Wed Dec 21 16:12:00 
2005
@@ -36,7 +36,7 @@
 
 void Parallelogram::computeNormal(const RenderContext&, RayPacket& rays) 
const
 {
-  for(int i=0;i<rays.getSize();i++)
+  for(int i=rays.begin();i<rays.end();i++)
     rays.setNormal(i, normal);
 }
 
@@ -47,12 +47,12 @@
   // affect this value.  You should be doing this dot product against
   // normalized vectors anyway.
   rays.normalizeDirections();
-  if(rays.getAllFlags() & RayPacket::ConstantOrigin && rays.getSize()>1){
+  if(rays.getFlag(RayPacket::ConstantOrigin) && rays.end()-rays.begin() > 1){
     Real num = d-Dot(normal, rays.getOrigin(0));
     Point a(rays.getOrigin(0)-anchor);
     Real o1 = Dot(a, v1);
     Real o2 = Dot(a, v2);
-    for(int i=0;i<rays.getSize();i++){
+    for(int i=rays.begin();i<rays.end();i++){
       Real dt=Dot(rays.getDirection(i), normal);
       if(Abs(dt) < (Real)1.e-6)
         continue;
@@ -71,7 +71,7 @@
         rays.scratchpad<Point>(i) = Point(a1, a2, 0);
     }
   } else {
-    for(int i=0;i<rays.getSize();i++){
+    for(int i=rays.begin();i<rays.end();i++){
       Real dt=Dot(rays.getDirection(i), normal);
       if(Abs(dt) < (Real)1.e-6)
         continue;
@@ -96,7 +96,7 @@
 void Parallelogram::computeTexCoords2(const RenderContext&,
                                      RayPacket& rays) const
 {
-  for(int i=0;i<rays.getSize();i++){
+  for(int i=rays.begin();i<rays.end();i++){
     rays.setTexCoords(i, rays.scratchpad<Point>(i));
   }
   rays.setFlag(RayPacket::HaveTexture2|RayPacket::HaveTexture3);
@@ -105,7 +105,7 @@
 void Parallelogram::computeTexCoords3(const RenderContext&,
                                      RayPacket& rays) const
 {
-  for(int i=0;i<rays.getSize();i++){
+  for(int i=rays.begin();i<rays.end();i++){
     rays.setTexCoords(i, rays.scratchpad<Point>(i));
   }
   rays.setFlag(RayPacket::HaveTexture2|RayPacket::HaveTexture3);

Modified: branches/vertical/Model/Primitives/Plane.cc
==============================================================================
--- branches/vertical/Model/Primitives/Plane.cc (original)
+++ branches/vertical/Model/Primitives/Plane.cc Wed Dec 21 16:12:00 2005
@@ -62,7 +62,7 @@
   // This is a simple first pass.  We should do different
   // optimizations in the future.
   rays.normalizeDirections();
-  for(int i = 0;i<rays.getSize();i++){
+  for(int i = rays.begin();i<rays.end();i++){
     Real dn = Dot( rays.getDirection(i), normal );
     if (dn != 0) {
       // Ray isn't parallel to the plane.
@@ -78,7 +78,7 @@
 {
   // We don't need to do anything except stuff the normal in the the
   // RayPacket.
-  for(int i = 0;i<rays.getSize();i++){
+  for(int i = rays.begin();i<rays.end();i++){
     rays.setNormal(i, normal);
   }
   rays.setFlag(RayPacket::HaveUnitNormals);

Modified: branches/vertical/Model/Primitives/Sphere.cc
==============================================================================
--- branches/vertical/Model/Primitives/Sphere.cc        (original)
+++ branches/vertical/Model/Primitives/Sphere.cc        Wed Dec 21 16:12:00 
2005
@@ -62,7 +62,7 @@
       // Rays of constant origin and normalized directions
       Vector O(rays.getOrigin(0)-center);
       Real C = Dot(O, O) - radius*radius;
-      for(int i = 0;i<rays.getSize();i++){
+      for(int i = rays.begin();i<rays.end();i++){
         Vector D(rays.getDirection(i));
         Real B = Dot(O, D);
         Real disc = B*B-C;
@@ -84,7 +84,7 @@
       // Rays of constant origin for not normalized directions
       Vector O(rays.getOrigin(0)-center);
       Real C = Dot(O, O) - radius*radius;
-      for(int i = 0;i<rays.getSize();i++){
+      for(int i = rays.begin();i<rays.end();i++){
         Vector D(rays.getDirection(i));
         Real A = Dot(D, D);
         Real B = Dot(O, D);
@@ -105,7 +105,7 @@
   case RayPacket::NormalizedDirections:
     {
       // Rays of non-constant origin and normalized directions
-      for(int i = 0;i<rays.getSize();i++){
+      for(int i = rays.begin();i<rays.end();i++){
         Vector O(rays.getOrigin(i)-center);
         Vector D(rays.getDirection(i));
         Real B = Dot(O, D);
@@ -127,7 +127,7 @@
   case 0:
     {
       // Rays of non-constant origin and non-normalized directions
-      for(int i = 0;i<rays.getSize();i++){
+      for(int i = rays.begin();i<rays.end();i++){
         Vector O(rays.getOrigin(i)-center);
         Vector D(rays.getDirection(i));
         Real A = Dot(D, D);
@@ -154,7 +154,7 @@
 void Sphere::computeNormal(const RenderContext&, RayPacket& rays) const
 {
   rays.computeHitPositions();
-  for(int i = 0;i<rays.getSize();i++){
+  for(int i = rays.begin();i<rays.end();i++){
     Vector n = rays.getHitPosition(i) - center;
     n *= inv_radius;
     rays.setNormal(i, n);
@@ -166,7 +166,7 @@
                                RayPacket& rays) const
 {
   rays.computeHitPositions();
-  for(int i = 0;i<rays.getSize();i++){
+  for(int i = rays.begin();i<rays.end();i++){
     Vector n = (rays.getHitPosition(i)-center)*inv_radius;
     Real angle = Clamp(n.z(), (Real)-1, (Real)1);
     Real theta = Acos(angle);
@@ -182,7 +182,7 @@
                                RayPacket& rays) const
 {
   rays.computeHitPositions();
-  for(int i = 0;i<rays.getSize();i++){
+  for(int i = rays.begin();i<rays.end();i++){
     Vector n = (rays.getHitPosition(i)-center)*inv_radius;
     Real angle = Clamp(n.z(), (Real)-1, (Real)1);
     Real theta = Acos(angle);

Modified: branches/vertical/Model/TexCoordMappers/UniformMapper.cc
==============================================================================
--- branches/vertical/Model/TexCoordMappers/UniformMapper.cc    (original)
+++ branches/vertical/Model/TexCoordMappers/UniformMapper.cc    Wed Dec 21 
16:12:00 2005
@@ -16,7 +16,7 @@
                                      RayPacket& rays) const
 {
   rays.computeHitPositions();
-  for(int i=0;i<rays.getSize();i++){
+  for(int i=rays.begin();i<rays.end();i++){
     rays.setTexCoords(i, rays.getHitPosition(i));
   }
   rays.setFlag(RayPacket::HaveTexture2|RayPacket::HaveTexture3);
@@ -26,7 +26,7 @@
                                      RayPacket& rays) const
 {
   rays.computeHitPositions();
-  for(int i=0;i<rays.getSize();i++){
+  for(int i=rays.begin();i<rays.end();i++){
     rays.setTexCoords(i, rays.getHitPosition(i));
   }
   rays.setFlag(RayPacket::HaveTexture2|RayPacket::HaveTexture3);

Modified: branches/vertical/Model/Textures/CheckerTexture.h
==============================================================================
--- branches/vertical/Model/Textures/CheckerTexture.h   (original)
+++ branches/vertical/Model/Textures/CheckerTexture.h   Wed Dec 21 16:12:00 
2005
@@ -58,7 +58,7 @@
       rays.computeTextureCoordinates3(context);
     else
       rays.computeTextureCoordinates2(context);
-    for(int i=0;i<rays.getSize();i++){
+    for(int i=rays.begin();i<rays.end();i++){
       Real vv1 = Dot(rays.getTexCoords(i), v1);
       Real vv2 = Dot(rays.getTexCoords(i), v2);
       if(vv1<0)

Modified: branches/vertical/Model/Textures/Constant.h
==============================================================================
--- branches/vertical/Model/Textures/Constant.h (original)
+++ branches/vertical/Model/Textures/Constant.h Wed Dec 21 16:12:00 2005
@@ -43,7 +43,7 @@
                                      RayPacket& rays,
                                      ValueType results[]) const
   {
-    for(int i=0;i<rays.getSize();i++)
+    for(int i=rays.begin();i<rays.end();i++)
       results[i] = value;
   }
 }

---

• [MANTA] r801 - in branches/vertical: Engine/PixelSamplers Engine/Renderers Engine/Shadows Interface Model/AmbientLights Model/Backgrounds Model/Cameras Model/Materials Model/Primitives Model/TexCoordMappers Model/Textures, sparker, 12/21/2005

---

Archive powered by MHonArc 2.6.16.