Text archives Help

---

Author: sparker
Date: Thu Apr 27 17:16:25 2006
New Revision: 1016

Modified:
   trunk/Engine/Display/OpenGLDisplay.cc
   trunk/Engine/ImageTraversers/DissolveImageTraverser.cc
   trunk/Engine/ImageTraversers/DissolveTiledImageTraverser.cc
   trunk/Engine/ImageTraversers/FilteredImageTraverser.cc
   trunk/Engine/ImageTraversers/HardTile.cc
   trunk/Engine/ImageTraversers/TiledImageTraverser.cc
   trunk/Engine/PixelSamplers/FastSampler.cc
   trunk/Engine/PixelSamplers/JitterSampler.cc
   trunk/Engine/PixelSamplers/NullSampler.cc
   trunk/Engine/PixelSamplers/SingleSampler.cc
   trunk/Image/SimpleImage.h
   trunk/Interface/Fragment.h
   trunk/Interface/RayPacket.h
   trunk/Model/Textures/ImageTexture.h
Log:
Verticalize Fragment


Modified: trunk/Engine/Display/OpenGLDisplay.cc
==============================================================================
--- trunk/Engine/Display/OpenGLDisplay.cc       (original)
+++ trunk/Engine/Display/OpenGLDisplay.cc       Thu Apr 27 17:16:25 2006
@@ -440,12 +440,14 @@
 
   GLenum format;
   GLenum type;
+  bool have_alpha = true;
   if(typeid(*image) == typeid(SimpleImage<RGBA8Pixel>)){
     format = GL_RGBA;
     type = big_endian? GL_UNSIGNED_INT_8_8_8_8 : GL_UNSIGNED_INT_8_8_8_8_REV;
   } else if(typeid(*image) == typeid(SimpleImage<RGB8Pixel>)){
     format = GL_RGB;
     type = GL_UNSIGNED_BYTE;
+    have_alpha = false;
   } else if(typeid(*image) == typeid(SimpleImage<ABGR8Pixel>)){
     format = GL_RGBA;
     type = big_endian? GL_UNSIGNED_INT_8_8_8_8_REV : GL_UNSIGNED_INT_8_8_8_8;
@@ -457,12 +459,12 @@
   }
 
   // Load textures
-  glTexImage2D(GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGB,
+  glTexImage2D(GL_TEXTURE_RECTANGLE_EXT, 0, have_alpha? GL_RGBA : GL_RGB,
                xres, yres, 0, format, type,
                si->getRawData(0));
   if(stereo){
     glBindTexture(GL_TEXTURE_RECTANGLE_EXT, texids[0]);
-    glTexImage2D(GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGB,
+    glTexImage2D(GL_TEXTURE_RECTANGLE_EXT, 0, have_alpha? GL_RGBA : GL_RGB,
                  xres, yres, 0, format, type,
                  si->getRawData(0));
     glBindTexture(GL_TEXTURE_RECTANGLE_EXT, texids[0]);

Modified: trunk/Engine/ImageTraversers/DissolveImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/DissolveImageTraverser.cc      (original)
+++ trunk/Engine/ImageTraversers/DissolveImageTraverser.cc      Thu Apr 27 
17:16:25 2006
@@ -174,7 +174,7 @@
         // I'm not sure you want to do stereo
       }
       // Check to see if your fragment is full.  If it is, then render it.
-      if (frag.getSize() == Fragment::MaxSize) {
+      if (frag.end() == Fragment::MaxSize) {
         context.pixelSampler->renderFragment(context, frag);
 #if 0
         for(int f = 0; f < frag.getSize(); f++)
@@ -201,7 +201,7 @@
     }
   }
   // Pick up strays
-  if (frag.getSize()) {
+  if (frag.end() != 0) {
     context.pixelSampler->renderFragment(context, frag);
     image->set(frag);
   }

Modified: trunk/Engine/ImageTraversers/DissolveTiledImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/DissolveTiledImageTraverser.cc (original)
+++ trunk/Engine/ImageTraversers/DissolveTiledImageTraverser.cc Thu Apr 27 
17:16:25 2006
@@ -183,7 +183,7 @@
           // I'm not sure you want to do stereo
         }
         // Check to see if your fragment is full.  If it is, then render it.
-        if (frag.getSize() == Fragment::MaxSize) {
+        if (frag.end() == Fragment::MaxSize) {
 //           // It might be useful to check for ConsecutiveX, but only if
 //           // certain conditions exist.
 //           if ((xend-xstart) == Fragment::MaxSize)
@@ -206,7 +206,7 @@
     
   }
   // Pick up strays
-  if (frag.getSize()) {
+  if (frag.end() != 0) {
     context.pixelSampler->renderFragment(context, frag);
     image->set(frag);
   }

Modified: trunk/Engine/ImageTraversers/FilteredImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/FilteredImageTraverser.cc      (original)
+++ trunk/Engine/ImageTraversers/FilteredImageTraverser.cc      Thu Apr 27 
17:16:25 2006
@@ -165,7 +165,7 @@
           ASSERT( total_fragments < total_allocated );
           
           Fragment &frag = fragment_array[total_fragments++];
-          frag.setConsecutiveX( 0, x, xend, y );
+          frag.setConsecutiveX( x, xend, y, 0, 999 );
           
         }
       }
@@ -182,29 +182,23 @@
             ASSERT( total_fragments < total_allocated );
             
             Fragment &frag = fragment_array[total_fragments++];
-            frag.setConsecutiveX( 1, x, xend, y );            
+            frag.setConsecutiveX( x, xend, y, 1, 999 );
           }
         }
       }
 
       
/////////////////////////////////////////////////////////////////////////
       // Render the fragments.
-      for (int i=0;i<total_fragments; ++i) {
+      for (int i=0;i<total_fragments; ++i)
         context.pixelSampler->renderFragment( context, fragment_array[i] );
-      }
 
       // Filter the fragments.
-      for (int i=0;i<total_fragments; ++i) {
-        for (int f=0;f<fragment_array[i].getSize();++f) {
-          Color &color = fragment_array[i].get(f).color;
-          color *= Color(RGB(0.5,0.5,0.5));
-        }
-      }
+      for (int i=0;i<total_fragments; ++i)
+        fragment_array[i].scaleColors(0.5);
 
       // Set image values.
-      for (int i=0;i<total_fragments; ++i) {
+      for (int i=0;i<total_fragments; ++i)
         image->set( fragment_array[i] );
-      }
     }
   }
   

Modified: trunk/Engine/ImageTraversers/HardTile.cc
==============================================================================
--- trunk/Engine/ImageTraversers/HardTile.cc    (original)
+++ trunk/Engine/ImageTraversers/HardTile.cc    Thu Apr 27 17:16:25 2006
@@ -133,7 +133,7 @@
           int xnarf = x+Fragment::MaxSize;
           if (xnarf > xend) xnarf = xend;
           // Create a Fragment that is consecutive in X pixels
-          Fragment frag(0, x, xnarf, y);
+          Fragment frag(x, xnarf, y, 0, 999);
           context.pixelSampler->renderFragment(context, frag);
           image->set(frag);
         }

Modified: trunk/Engine/ImageTraversers/TiledImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/TiledImageTraverser.cc (original)
+++ trunk/Engine/ImageTraversers/TiledImageTraverser.cc Thu Apr 27 17:16:25 
2006
@@ -131,13 +131,13 @@
           if (xnarf > xend) xnarf = xend;
 
           // Create a Fragment that is consecutive in X pixels
-          Fragment frag(0, x, xnarf, y);
+          Fragment frag(x, xnarf, y, 0, 999);
           context.pixelSampler->renderFragment(context, frag);
           image->set(frag);
 
           // Check to see if we need to render another copy in setero.
           if(stereo){
-            Fragment fragST(1, x, xnarf, y);
+            Fragment fragST(x, xnarf, y, 1, 999);
             context.pixelSampler->renderFragment(context, fragST);
             image->set(fragST);
           }

Modified: trunk/Engine/PixelSamplers/FastSampler.cc
==============================================================================
--- trunk/Engine/PixelSamplers/FastSampler.cc   (original)
+++ trunk/Engine/PixelSamplers/FastSampler.cc   Thu Apr 27 17:16:25 2006
@@ -50,34 +50,34 @@
 {
   ChannelInfo& ci = channelInfo[context.channelIndex];
   int flags = RayPacket::HaveImageCoordinates;
-  if(fragment.getFlags() & Fragment::ConstantEye)
+  if(fragment.getFlag(Fragment::ConstantEye))
     flags |= RayPacket::ConstantEye;
-  for(int f=0;f<fragment.getSize();f+=RayPacket::MaxSize){
+  for(int f=fragment.begin();f<fragment.end();f+=RayPacket::MaxSize){
     // We want to fill our RayPacket with as many as
     // RayPacket::MaxSize rays.
     int size = RayPacket::MaxSize;
-    if(size >= fragment.getSize()-f)
+    if(size >= fragment.end()-f)
       // We don't have enough fragments left to fill a ray packet, so
       // set the size of the RayPacket to the number of fragments we
       // have left.
-      size = fragment.getSize()-f;
+      size = fragment.end()-f;
     // Create a ray packet
     int depth = 0;
     RayPacketData raydata;
     RayPacket rays(raydata, 0, size, depth, flags);
 
     // Check to see if the fragment is consecutive in x.
-    if(fragment.getFlags() & Fragment::ConsecutiveX){
+    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) == 
Fragment::ConsecutiveX|Fragment::ConstantEye){
 
       // If so place each pixel in the ray packet relative to the first
       // fragment.
-      Fragment::Element& fe0 = fragment.get(f);
-      Real px = fe0.x*ci.xscale+ci.xoffset;
-      Real py = fe0.y*ci.yscale+ci.yoffset;
-
-      for(int i=0;i<size;i++){
-        Fragment::Element& fe = fragment.get(f+i);
-        rays.setPixel(i, fe.which_eye, px, py);
+      int b = fragment.begin();
+      Real px = fragment.getX(b)*ci.xscale+ci.xoffset;
+      Real py = fragment.getY(b)*ci.yscale+ci.yoffset;
+      int eye = fragment.getWhichEye(b);
+
+      for(int i=fragment.begin();i<fragment.end();i++){
+        rays.setPixel(i, eye, px, py);
         px += ci.xscale;
       }
 
@@ -85,29 +85,20 @@
 
     // Otherwise, set each pixel individually.
     else {
-      for(int i=0;i<size;i++){
-        Fragment::Element& fe = fragment.get(f+i);
-        Real px = fe.x*ci.xscale+ci.xoffset;
-        Real py = fe.y*ci.yscale+ci.yoffset;
-        rays.setPixel(i, fe.which_eye, px, py);
+      for(int i=fragment.begin();i<fragment.end();i++){
+        Real px = fragment.getX(i)*ci.xscale+ci.xoffset;
+        Real py = fragment.getY(i)*ci.yscale+ci.yoffset;
+        rays.setPixel(i, fragment.getWhichEye(i), px, py);
       }
     }
 
     // Trace the rays.  The results will automatically go into the fragment
     context.renderer->traceEyeRays(context, rays);
 
-#if 0 // old code
-    for(int i=0;i<size;i++){
-      Fragment::Element& fe = fragment.get(f+i);
-      fe.color = rays.getColor(i);
-    }
-#else
     for(int i=0;i<size;i++)
     {
-        Fragment::Element& fe = fragment.get(f+i);
         for ( int c = 0; c < Color::NumComponents; c++ )
-            fe.color.data[c] = raydata.color[c][i];
+            fragment.color[c][i] = raydata.color[c][i];
     }
-#endif
   }
 }

Modified: trunk/Engine/PixelSamplers/JitterSampler.cc
==============================================================================
--- trunk/Engine/PixelSamplers/JitterSampler.cc (original)
+++ trunk/Engine/PixelSamplers/JitterSampler.cc Thu Apr 27 17:16:25 2006
@@ -104,7 +104,7 @@
     // We've collected enough samples, so compute the average and
     // assign it to the fragment.
     if(samples_collected == num_samples) {
-      fragment.get(current_fragment).color += fragment_color / num_samples;
+      fragment.addColor(current_fragment, fragment_color / num_samples);
       // Reset our accumulation variables
       fragment_color = Color::black();
       samples_collected = 0;
@@ -114,9 +114,9 @@
   // Pick up left over fragments.  It is OK if this is a partial sum.
   // The remaining sum will be picked up in the next call to
   // computeAverages.
-  if (samples_collected > 0) {
-    fragment.get(current_fragment).color += fragment_color / num_samples;
-  }
+  if (samples_collected > 0) 
+    fragment.addColor(current_fragment, fragment_color / num_samples);
+
   // Assign the values back to the parameters.
   samples_collected_return = samples_collected;
   current_fragment_return = current_fragment;
@@ -129,18 +129,18 @@
   int thd_num = context.proc;
     
   int flags = RayPacket::HaveImageCoordinates;
-  if(fragment.getFlags() & Fragment::ConstantEye)
+  if(fragment.getFlag(Fragment::ConstantEye))
     flags |= RayPacket::ConstantEye;
 
-  int consecutivex_flag = fragment.getFlags() & Fragment::ConsecutiveX;
+  int consecutivex_flag = fragment.getFlag(Fragment::ConsecutiveX);
 
   CheapRNG rng;
   if (consecutivex_flag) {
-    Fragment::Element& fe = fragment.get(0);
+    int b = fragment.begin();
     if (use_cheaprng)
-      rng.seed(fe.x*ci.xres+fe.y);
+      rng.seed(fragment.getX(b)*ci.xres+fragment.getY(b));
     else
-      random[thd_num].seed_rng(fe.x*ci.xres+fe.y);
+      random[thd_num].seed_rng(fragment.getX(b)*ci.xres+fragment.getY(b));
   }
 
   int depth = 0;
@@ -158,22 +158,22 @@
   int current_fragment = 0;
 
   // We can compute at most RayPacket::MaxSize number of rays at time.
-  for(int frag_index = 0; frag_index < fragment.getSize(); frag_index++) {
+  for(int frag_index = fragment.begin(); frag_index < fragment.end(); 
frag_index++) {
     // Initialize the color
-    fragment.get(frag_index).color = Color::black();
-
-    Fragment::Element& fe0 = fragment.get(frag_index);
+    fragment.setColor(frag_index, Color::black());
 
     if (!consecutivex_flag) {
       if (use_cheaprng)
-        rng.seed(fe0.x*ci.xres+fe0.y);
+        
rng.seed(fragment.getX(frag_index)*ci.xres+fragment.getY(frag_index));
       else
-        random[thd_num].seed_rng(fe0.x*ci.xres+fe0.y);
+        
random[thd_num].seed_rng(fragment.getX(frag_index)*ci.xres+fragment.getY(frag_index));
     }
     
     // For each fragment start filling up the RayPacket with samples.
     // When you filled up the empty_slots compute the rays, do the
     // average, and store the results in the fragment.
+    int fx = fragment.getX(frag_index);
+    int fy = fragment.getY(frag_index);
     for(int xs = 0; xs < nx; xs++)
       for(int ys = 0; ys  < ny; ys++)
         {
@@ -185,8 +185,8 @@
             x_sample = (xs + random[thd_num].genRealRand<Real>()) * inx;
             y_sample = (ys + random[thd_num].genRealRand<Real>()) * iny;
           }
-          px = (fe0.x+(x_sample))*ci.xscale+ci.xoffset;
-          py = (fe0.y+(y_sample))*ci.yscale+ci.yoffset;
+          px = (fx+x_sample)*ci.xscale+ci.xoffset;
+          py = (fy+y_sample)*ci.yscale+ci.yoffset;
           rays.setPixel(sample_count, 0, px, py);
           sample_count++;
           

Modified: trunk/Engine/PixelSamplers/NullSampler.cc
==============================================================================
--- trunk/Engine/PixelSamplers/NullSampler.cc   (original)
+++ trunk/Engine/PixelSamplers/NullSampler.cc   Thu Apr 27 17:16:25 2006
@@ -32,6 +32,6 @@
 
 void NullSampler::renderFragment(const RenderContext&, Fragment& fragment)
 {
-  for(int i=0;i<fragment.getSize();i++)
-    fragment.get(i).color = Color(RGBColor(0.3, 0.6, 0.9));
+  for(int i=fragment.begin();i<fragment.end();i++)
+    fragment.setColor(i, Color(RGBColor(0.3, 0.6, 0.9)));
 }

Modified: trunk/Engine/PixelSamplers/SingleSampler.cc
==============================================================================
--- trunk/Engine/PixelSamplers/SingleSampler.cc (original)
+++ trunk/Engine/PixelSamplers/SingleSampler.cc Thu Apr 27 17:16:25 2006
@@ -50,34 +50,34 @@
 {
   ChannelInfo& ci = channelInfo[context.channelIndex];
   int flags = RayPacket::HaveImageCoordinates;
-  if(fragment.getFlags() & Fragment::ConstantEye)
+  if(fragment.getFlag(Fragment::ConstantEye))
     flags |= RayPacket::ConstantEye;
-  for(int f=0;f<fragment.getSize();f+=RayPacket::MaxSize){
+  for(int f=fragment.begin();f<fragment.end();f+=RayPacket::MaxSize){
     // We want to fill our RayPacket with as many as
     // RayPacket::MaxSize rays.
     int size = RayPacket::MaxSize;
-    if(size >= fragment.getSize()-f)
+    if(size >= fragment.end()-f)
       // We don't have enough fragments left to fill a ray packet, so
       // set the size of the RayPacket to the number of fragments we
       // have left.
-      size = fragment.getSize()-f;
+      size = fragment.end()-f;
     // Create a ray packet
     int depth = 0;
     RayPacketData raydata;
     RayPacket rays(raydata, 0, size, depth, flags);
 
     // Check to see if the fragment is consecutive in x.
-    if(fragment.getFlags() & Fragment::ConsecutiveX){
+    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) == 
Fragment::ConsecutiveX|Fragment::ConstantEye){
 
       // If so place each pixel in the ray packet relative to the first
       // fragment.
-      Fragment::Element& fe0 = fragment.get(f);
-      Real px = fe0.x*ci.xscale+ci.xoffset;
-      Real py = fe0.y*ci.yscale+ci.yoffset;
+      int b = fragment.begin();
+      Real px = fragment.getX(b)*ci.xscale+ci.xoffset;
+      Real py = fragment.getY(b)*ci.yscale+ci.yoffset;
+      int eye = fragment.getWhichEye(b);
       
       for(int i=0;i<size;i++){
-        Fragment::Element& fe = fragment.get(f+i);
-        rays.setPixel(i, fe.which_eye, px, py);
+        rays.setPixel(i, eye, px, py);
         px += ci.xscale;
       }
 
@@ -86,19 +86,19 @@
     // Otherwise, set each pixel individually.
     else {
       for(int i=0;i<size;i++){
-        Fragment::Element& fe = fragment.get(f+i);
-        Real px = fe.x*ci.xscale+ci.xoffset;
-        Real py = fe.y*ci.yscale+ci.yoffset;
-        rays.setPixel(i, fe.which_eye, px, py);
+        Real px = fragment.getX(i)*ci.xscale+ci.xoffset;
+        Real py = fragment.getY(i)*ci.yscale+ci.yoffset;
+        rays.setPixel(i, fragment.getWhichEye(i), px, py);
       }
     }
     
     // Trace the rays.  The results will automatically go into the fragment
     context.renderer->traceEyeRays(context, rays);
 
-    for(int i=0;i<size;i++){
-      Fragment::Element& fe = fragment.get(f+i);
-      fe.color = rays.getColor(i);
+    for(int i=0;i<size;i++)
+    {
+        for ( int c = 0; c < Color::NumComponents; c++ )
+            fragment.color[c][i] = raydata.color[c][i];
     }
   }
 }

Modified: trunk/Image/SimpleImage.h
==============================================================================
--- trunk/Image/SimpleImage.h   (original)
+++ trunk/Image/SimpleImage.h   Thu Apr 27 17:16:25 2006
@@ -104,17 +104,15 @@
   template<class Pixel>
   void SimpleImage<Pixel>::set(const Fragment& fragment)
   {
-    if(fragment.getFlags() & (Fragment::ConsecutiveX|Fragment::ConstantEye) 
==
-       (Fragment::ConsecutiveX|Fragment::ConstantEye)){
-      int nf = fragment.getSize();
-      Pixel* pix = 
eyeStart[fragment.get(0).which_eye][fragment.get(0).y]+fragment.get(0).x;
-      for(int i=0;i<nf;i++)
-       convertToPixel(*pix++, fragment.get(i).color.convertRGB());
+    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) ==
+       Fragment::ConsecutiveX|Fragment::ConstantEye){
+      int b = fragment.begin();
+      Pixel* pix = 
eyeStart[fragment.getWhichEye(b)][fragment.getY(b)]+fragment.getX(b);
+      for(int i=fragment.begin(); i< fragment.end();i++)
+       convertToPixel(*pix++, fragment.getColor(i).convertRGB());
     } else {
-      for(int i=0;i<fragment.getSize();i++){
-       const Fragment::Element& f = fragment.get(i);
-        if(f.x<xres && f.x>=0 && f.y<yres && f.y>=0)
-          convertToPixel(eyeStart[f.which_eye][f.y][f.x], 
f.color.convertRGB());
+      for(int i=fragment.begin();i<fragment.end();i++){
+        
convertToPixel(eyeStart[fragment.getWhichEye(i)][fragment.getY(i)][fragment.getX(i)],
 fragment.getColor(i).convertRGB());
       }
     }
   }
@@ -122,21 +120,20 @@
   template<class Pixel>
   void SimpleImage<Pixel>::get(Fragment& fragment) const
   {
-    if(fragment.getFlags() & (Fragment::ConsecutiveX|Fragment::ConstantEye) 
-       == (Fragment::ConsecutiveX|Fragment::ConstantEye)){
-      int nf = fragment.getSize();
-      Pixel* pix = 
eyeStart[fragment.get(0).which_eye][fragment.get(0).y]+fragment.get(0).x;
-      for(int i=0;i<nf;i++) {
+    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) ==
+       Fragment::ConsecutiveX|Fragment::ConstantEye){
+      int b = fragment.begin();
+      Pixel* pix = 
eyeStart[fragment.getWhichEye(b)][fragment.getY(b)]+fragment.getX(b);
+      for(int i=fragment.begin(); i < fragment.end();i++) {
         RGBColor color;
         convertToRGBColor(color, *pix++);
         // Convert from RGBColor to Color
         fragment.setColor(i, Color(color));
       }
     } else {
-      for(int i=0;i<fragment.getSize();i++){
-        const Fragment::Element& f = fragment.get(i);
+      for(int i=fragment.begin(); i < fragment.end(); i++){
         RGBColor color;
-        convertToRGBColor(color, eyeStart[f.which_eye][f.y][f.x]);
+        convertToRGBColor(color, 
eyeStart[fragment.getWhichEye(i)][fragment.getY(i)][fragment.getX(i)]);
         // Convert from RGBColor to Color
         fragment.setColor(i, Color(color));
       }

Modified: trunk/Interface/Fragment.h
==============================================================================
--- trunk/Interface/Fragment.h  (original)
+++ trunk/Interface/Fragment.h  Thu Apr 27 17:16:25 2006
@@ -21,6 +21,7 @@
 #include <Core/Util/Assert.h>
 
 #include <FragmentParameters.h>
+#include <Core/Util/Align.h>
 
 // TODO:
 //
@@ -31,82 +32,92 @@
 //
 
 namespace Manta {
-  class Fragment {
+  class MANTA_ALIGN(16) Fragment {
   public:
 
     static const int ConsecutiveX    = 0x01;  // Implies a constant Y:
-    static const int ConstantEye = 0x02;
+    static const int ConstantEye     = 0x02;
 
     
///////////////////////////////////////////////////////////////////////////
     // Empty Constructor    
     Fragment()
-      : flags(0), size(0), data(reinterpret_cast<Element*>(databuf))
+      : flags(0), pixelBegin(0), pixelEnd(0)
       {}
 
     // Creates a "Scan-line" fragment.
-    Fragment(int which_eye, int xstart, int xend, int y)
-      : data(reinterpret_cast<Element*>(databuf))
+    Fragment(int xstart, int xend, int y, int eye, int)
     {
-      ASSERTRANGE(xend-xstart, 0, MaxSize+1);
-      int nx = xend-xstart;
-      for(int i=0; i< nx;i++){
-        data[i].x = i+xstart;
-        data[i].y = y;
-        data[i].which_eye = which_eye;
-      }
-      flags = ConsecutiveX|ConstantEye;
-      size = nx;
+      setConsecutiveX(xstart, xend, y, eye, 999);
     }
        
     ~Fragment() {}
 
-    void addElement(int x, int y, int which_eye) {
-      ASSERT(size < MaxSize);
-      data[size].x = x;
-      data[size].y = y;
-      data[size].which_eye = which_eye;
-      size++;
+    void addElement(int x, int y, int eye) {
+      ASSERT(pixelEnd < MaxSize);
+      pixel[0][pixelEnd] = x;
+      pixel[1][pixelEnd] = y;
+      which_eye[pixelEnd] = eye;
+      pixelEnd++;
     }
       
-    void setElement( int i, int x, int y, int which_eye ) {
+    void setElement( int i, int x, int y, int eye ) {
       ASSERTRANGE(i, 0, MaxSize);
-      data[i].x = x;
-      data[i].y = y;
-      data[i].which_eye = which_eye;
+      pixel[0][i] = x;
+      pixel[1][i] = y;
+      which_eye[i] = eye;
     }
 
-    void setConsecutiveX(int which_eye, int xstart, int xend, int y) {
+    void setConsecutiveX(int xstart, int xend, int y, int eye, int) {
       ASSERTRANGE(xend-xstart, 0, MaxSize+1);
       int nx = xend-xstart;
       for(int i=0; i< nx;i++){
-        data[i].x = i+xstart;
-        data[i].y = y;
-        data[i].which_eye = which_eye;
+        pixel[0][i] = i+xstart;
+        pixel[1][i] = y;
+        which_eye[i] = eye;
       }
       flags = ConsecutiveX|ConstantEye;
-      size = nx;
+      pixelBegin = 0;
+      pixelEnd = nx;
     }
     
+    void resetSize() {
+      pixelBegin = 0;
+      pixelEnd = 0;
+    }
+
     
///////////////////////////////////////////////////////////////////////////
     // Accessors.
-    int getFlags() const {
+    // Fragment flags
+    int getAllFlags() const
+    {
       return flags;
     }
-    void setAllFlags(const int newflags) {
-      flags = newflags;
+
+    bool getFlag( int flag ) const
+    {
+      return (flags & flag) == flag;
     }
 
-    int getSize() const {
-      return size;
+    void setAllFlags(int new_flags)
+    {
+      flags = new_flags;
     }
-    void setSize(const int newSize) {
-      size = newSize;
+    void setFlag(int flag) {
+      flags |= flag;
     }
-    void resetSize() {
-      size = 0;
+    void resetFlag(int flag) {
+      flags &= ~flag;
+    }
+
+    int begin() const {
+      return pixelBegin;
+    }
+    int end() const {
+      return pixelEnd;
     }
     void resetAll() {
-      size = 0;
+      pixelBegin = 0;
+      pixelEnd = 0;
       flags = 0;
     }
 
@@ -115,8 +126,8 @@
     void testSetWhichEye() {
       // This will be true if size is <= 1.
       int test_passed = ConstantEye;
-      for(int i = 1; i < size; ++i)
-        if (data[i-1].which_eye != data[i].which_eye) {
+      for(int i = pixelBegin+1; i < pixelEnd; ++i)
+        if (which_eye[i-1] != which_eye[i]) {
           test_passed = 0;
           break;
         }
@@ -126,19 +137,61 @@
     }
     void testSetConsecutiveX() {
       int test_passed = ConsecutiveX;
-      for(int i = 1; i < size; ++i)
+      for(int i = pixelBegin+1; i < pixelEnd; ++i)
         // Test to see if the y's are the same as well as X being
         // consecutive.
-        if (data[i].y != data[i-1].y &&
-            (data[i].x - data[i-1].x) == 1) {
+        if (pixel[1][i] != pixel[1][i-1] ||
+            pixel[0][i] - pixel[0][i-1] != 1){
           test_passed = 0;
           break;
         }
       flags = test_passed | (flags & ~ConsecutiveX);
     }
-    
-    void setColor(int which, const Color& color) {
-      data[which].color = color;
+
+    // Pixel
+    int getX(int which) const
+    {
+      return pixel[0][which];
+    }
+    int getY(int which) const
+    {
+      return pixel[1][which];
+    }
+    int getWhichEye(int which) const
+    {
+      return which_eye[which];
+    }
+
+    // Color
+    void setColor(int which, const Color& newcolor)
+    {
+      for(int i=0;i<Color::NumComponents;i++)
+        color[i][which] = newcolor[i];
+    }
+    Color getColor(int which) const
+    {
+      Color result;
+      for(int i=0;i<Color::NumComponents;i++)
+        result[i] = color[i][which];
+      return result;
+    }
+
+    void scaleColors(Color::ComponentType scale)
+    {
+      for(int j=pixelBegin;j<pixelEnd;j++){
+        for(int i = 0 ; i < Color::NumComponents; i++)
+          color[i][j] *= scale;
+      }
+    }
+    void scaleColor(int which, Color::ComponentType scale)
+    {
+      for(int i = 0 ; i < Color::NumComponents; i++)
+        color[i][which] *= scale;
+    }
+    void addColor(int which, const Color& add)
+    {
+      for(int i = 0 ; i < Color::NumComponents; i++)
+        color[i][which] += add[i];
     }
 
     
///////////////////////////////////////////////////////////////////////////
@@ -148,32 +201,24 @@
     // dynamically allocate them.
     static const int MaxSize = FRAGMENT_MAXSIZE;
 
-    // Represents a Pixel
-    struct Element {
-      // Pixel position in image space
-      int x, y;
-      int which_eye; // monocular: always 0, stereo: 0=left, 1=right
-      Color color;   // Final result
-    };
-    const Element& get(int which) const {
-      return data[which];
-    }
-    Element& get(int which) {
-      return data[which];
-    }
-  private:
-    //Element data[MaxSize];
-    Element* data;
-    char databuf[MaxSize*sizeof(Element)];
+  public:
+    // Fragment data
+    MANTA_ALIGN(16) Color::ComponentType 
color[Manta::Color::NumComponents][MaxSize];
+    MANTA_ALIGN(16) int pixel[2][MaxSize];
+    MANTA_ALIGN(16) int which_eye[MaxSize];
 
-    // ConstantEye | ConsecutiveX
+    // Properties of this packet
     int flags;
 
-    // Number of Elements that are currently being used.
-    int size;
-  };
+    // Range of Elements that are currently being used.
+    int pixelBegin, pixelEnd;
 
-  
+  private:
+    // Prevent accidental copying of Fragments
+    Fragment(const Fragment&);
+    Fragment& operator=(const Fragment&);
+
+  };
 }
 
 #endif

Modified: trunk/Interface/RayPacket.h
==============================================================================
--- trunk/Interface/RayPacket.h (original)
+++ trunk/Interface/RayPacket.h Thu Apr 27 17:16:25 2006
@@ -26,7 +26,7 @@
   public:
     enum {
       MaxScratchpadSize = SCRATCHPAD_MAXSIZE,
-      Size              = RAYPACKET_MAXSIZE
+      MaxSize              = RAYPACKET_MAXSIZE
     };
     RayPacketData()
       {
@@ -44,38 +44,38 @@
     typedef Material const*  MaterialCP;
     typedef TexCoordMapper const* TexCoordMapperCP;
 
-    PrimitiveCP hitPrim[Size];
-    MaterialCP hitMatl[Size];
-    TexCoordMapperCP hitTex[Size];
+    PrimitiveCP hitPrim[MaxSize];
+    MaterialCP hitMatl[MaxSize];
+    TexCoordMapperCP hitTex[MaxSize];
 
     // Real-based arrays
-    MANTA_ALIGN(16) Real origin[3][Size];
-    MANTA_ALIGN(16) Real direction[3][Size];
-    MANTA_ALIGN(16) Real inverseDirection[3][Size];
-    MANTA_ALIGN(16) Real minT[Size];
-
-    Real image[2][Size];
-    Real normal[3][Size];
-    Real hitPosition[3][Size];
-    Real texCoords[3][Size];
+    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];
+
+    Real image[2][MaxSize];
+    Real normal[3][MaxSize];
+    Real hitPosition[3][MaxSize];
+    Real texCoords[3][MaxSize];
 
 
     // Color-based arrays
-    Color::ComponentType color[Manta::Color::NumComponents][Size];
-    Color::ComponentType importance[Manta::Color::NumComponents][Size];   // 
1-attenuation, where eye rays have importance == 1
+    Color::ComponentType color[Manta::Color::NumComponents][MaxSize];
+    Color::ComponentType importance[Manta::Color::NumComponents][MaxSize];   
// 1-attenuation, where eye rays have importance == 1
 
     // Int-based arrays
-    int whichEye[Size];
-    int signs[3][Size]; // 1=negative, 0=zero, positive
+    int whichEye[MaxSize];
+    int signs[3][MaxSize]; // 1=negative, 0=zero, positive
 
     // Char-based arrays
-    char scratchpad_data[Size][MaxScratchpadSize];
+    char scratchpad_data[MaxSize][MaxScratchpadSize];
   };
 
   class RayPacket {
   public:
     enum {
-      MaxSize               = RayPacketData::Size,
+      MaxSize               = RayPacketData::MaxSize,
 
       // Flags.
       ConstantOrigin        = 0x0001,
@@ -561,6 +561,7 @@
     }
 
   private:
+    // Prevent accidental copying of RayPackets
     RayPacket(const RayPacket&);
     RayPacket& operator=(const RayPacket&);
 

Modified: trunk/Model/Textures/ImageTexture.h
==============================================================================
--- trunk/Model/Textures/ImageTexture.h (original)
+++ trunk/Model/Textures/ImageTexture.h Thu Apr 27 17:16:25 2006
@@ -215,10 +215,10 @@
       for(int x = 0; x < xres; x+=Fragment::MaxSize) {
         int end = x + Fragment::MaxSize;
         if (end > xres) end = xres;
-        Fragment fragment(0, x, end, y);
+        Fragment fragment(x, end, y, 0, 999);
         image->get(fragment);
-        for(int i = 0; i < fragment.getSize(); i++) {
-          texture(x+i, y) = fragment.get(i).color;
+        for(int i = fragment.begin(); i < fragment.end(); i++) {
+          texture(x+i, y) = fragment.getColor(i);
         }
       }
     }

---

• [MANTA] r1016 - in trunk: Engine/Display Engine/ImageTraversers Engine/PixelSamplers Image Interface Model/Textures, sparker, 04/27/2006

---

Archive powered by MHonArc 2.6.16.