Text archives Help

---

Author: bigler
Date: Mon Feb 13 17:08:57 2006
New Revision: 937

Modified:
   trunk/fox/disco_demo/Engine/ImageTraversers/DiscoImageTraverser.cc
   trunk/fox/disco_demo/Engine/Shaders/AOShader.cc
   trunk/fox/disco_demo/Interface/DiscoTile.cc
   trunk/fox/disco_demo/Interface/DiscoTile.h
   trunk/fox/disco_demo/Interface/TilePacket.h
Log:

Interface/TilePacket.h

  Made TilePacket::Element and TilePacket::TilePacketData their own
  classes outside of TilePacket called TilePacketElement and
  TilePacketData respectively.

  Added a few flag operators.

  You should now use ::begin() and ::end() instead of iterating from 0
  to ::size().

  Added set/getColor().

Engine/ImageTraversers/DiscoImageTraverser.cc
Engine/Shaders/AOShader.cc

  Updates for new TilePacket interface.

  TilePacket::Element& t is now TilePacketElement& element (or tile).

Interface/DiscoTile.cc
Interface/DiscoTile.h

  Updates for new TilePacket interface.

  get is now getElement()


Modified: trunk/fox/disco_demo/Engine/ImageTraversers/DiscoImageTraverser.cc
==============================================================================
--- trunk/fox/disco_demo/Engine/ImageTraversers/DiscoImageTraverser.cc  
(original)
+++ trunk/fox/disco_demo/Engine/ImageTraversers/DiscoImageTraverser.cc  Mon 
Feb 13 17:08:57 2006
@@ -177,21 +177,21 @@
       // Total number of packets
       int packet_sent = 0;
 
-      // Iterate across the tile.
+      // Iterate across the tile in the tile's index space (not screen).
       for (int y=-overlap;y<ytile_end+overlap;++y) {
         for (int x=-overlap;x<xtile_end+overlap;++x) {
 
-          TilePacket::Element &t = disco_tile.get( x, y );
+          TilePacketElement& element = disco_tile.getElement( x, y );
 
           
/////////////////////////////////////////////////////////////////////
           // Initialize the tile.
 
-          t.tilex = x;
-          t.tiley = y;
-          // We need to flag the Element as being an "overlap" tile.
+          element.tilex = x;
+          element.tiley = y;
+          // We need to flag the Element as being an "overlap" element.
           // As it turns out the value of this is 0x02.
-          t.flags = ((x<0 || x>=xtilesize) ||
-                     (y<0 || y>=ytilesize)) << 1;
+          element.flags = ((x<0 || x>=xtilesize) ||
+                           (y<0 || y>=ytilesize)) << 1;
 
           
/////////////////////////////////////////////////////////////////////
           // Initialize the ray packet element
@@ -206,7 +206,7 @@
 
             // Create a tile packet.
             TilePacket tile_packet( disco_tile.getTilePacketData( 
packet_sent++ ),
-                                    RayPacket::MaxSize );
+                                    0, RayPacket::MaxSize );
             ray_packet.resize( RayPacket::MaxSize );
 
             // Render the packet.
@@ -224,7 +224,7 @@
       if (packet_size != 0) {
         // Create a tile packet with the remaining rays.
         TilePacket tile_packet( disco_tile.getTilePacketData( packet_sent++ 
),
-                                packet_size );
+                                0, packet_size );
         
         // Render the packet.
         ray_packet.resize( packet_size );
@@ -242,23 +242,20 @@
 
         // Create a tile packet.
         TilePacket tile_packet( disco_tile.getTilePacketData( i ),
-                                disco_tile.getPacketSize( i ) );
+                                0, disco_tile.getPacketSize( i ) );
         
         
///////////////////////////////////////////////////////////////////////
         // Shade the packet
 
         // Find the first hit.
-        int start = 0;
-        
-        for (;start<tile_packet.getSize();++start) {
+        for (int start=tile_packet.begin();start<tile_packet.end();++start) {
 
-          while ((start<tile_packet.getSize()) &&
-                 !tile_packet.wasHit(start))
+          while ((start<tile_packet.end()) && !tile_packet.wasHit(start))
             ++start;
           
           // Find a run of elements that generated hits.
           int end = start;
-          while (end < tile_packet.getSize() && tile_packet.wasHit(end))
+          while (end < tile_packet.end() && tile_packet.wasHit(end))
             ++end;
           
           // Create a sub packet of elements which generated hits.
@@ -272,13 +269,13 @@
         
///////////////////////////////////////////////////////////////////////
         // Copy results to a fragment.
         int fragment_size = 0;
-        for (int j=0;j<tile_packet.getSize();++j) {
+        for (int j=tile_packet.begin();j<tile_packet.end();++j) {
 
           // Make sure the element isn't part of the overlap.
           if (!tile_packet.isOverlap(j)) {
           
-            Fragment::Element   &f = fragment.get( fragment_size++ );
-            TilePacket::Element &t = tile_packet.get( j );
+            Fragment::Element &f = fragment.get( fragment_size++ );
+            TilePacketElement &t = tile_packet.getElement( j );
 
             // Pixel coordinates.
             f.which_eye = 0;
@@ -293,7 +290,7 @@
         fragment.setSize( fragment_size );
 
         // Set image values.
-        image->set( fragment ); 
+        image->set( fragment );
       }
     }
   }

Modified: trunk/fox/disco_demo/Engine/Shaders/AOShader.cc
==============================================================================
--- trunk/fox/disco_demo/Engine/Shaders/AOShader.cc     (original)
+++ trunk/fox/disco_demo/Engine/Shaders/AOShader.cc     Mon Feb 13 17:08:57 
2006
@@ -173,7 +173,7 @@
   RayPacket     secondary_packet( secondary_data, 0, 0, 1, 0 );
 
   // Keep track of which primary rays each secondary ray maps to.
-  int secondary_map[RayPacket::MaxSize];  
+  int secondary_map[RayPacket::MaxSize];
   int secondary_size = secondary_packet.begin();
 
   // Keep track of how many secondary rays hit something for each
@@ -181,11 +181,11 @@
   Real total_hits[RayPacket::MaxSize];
   
   ///////////////////////////////////////////////////////////////////////////
-  // Decide which directions to shoot based on TilePacket element task id.  
+  // Decide which directions to shoot based on TilePacket element task id.
   Vector W, U, V;
   for (int i=ray_packet.begin();i<ray_packet.end();++i) {
 
-    TilePacket::Element &p = tile_packet.get( i );
+    TilePacketElement& tile = tile_packet.getElement( i );
 
     // Initialize total secondary hits for this primary ray.
     total_hits[i] = 0;
@@ -202,8 +202,8 @@
    
     // Determine which directions to use.
     int task =
-      ((p.tilex+overlap)%kernel_width) +
-      ((p.tiley+overlap)%kernel_width) * kernel_width;
+      ((tile.tilex+overlap)%kernel_width) +
+      ((tile.tiley+overlap)%kernel_width) * kernel_width;
       
     int d     = static_cast<int>(task*task_size);
     int d_end = static_cast<int>(d+task_size);
@@ -278,15 +278,16 @@
   // Determine hit ratio.
   for (int i=ray_packet.begin();i<ray_packet.end();++i) {
 
-    TilePacket::Element &p = tile_packet.get( i - ray_packet.begin());
+    //    TilePacketElement& tile = tile_packet.getElement( i - 
ray_packet.begin());
+    TilePacketElement& tile = tile_packet.getElement( i );
     
-    p.illuminance = 1 - ( total_hits[i] / task_size );
+    tile.illuminance = 1 - ( total_hits[i] / task_size );
     
     // Copy over the material color and normal
-    p.color  = ray_packet.getColor( i ); // Color(RGB(1,1,1));
-    p.normal = ray_packet.getNormal( i );
-    p.t      = ray_packet.getMinT( i );
-    p.point  = ray_packet.getHitPosition( i );
+    tile.color  = ray_packet.getColor( i ); // Color(RGB(1,1,1));
+    tile.normal = ray_packet.getNormal( i );
+    tile.t      = ray_packet.getMinT( i );
+    tile.point  = ray_packet.getHitPosition( i );
   }
 }
 
@@ -316,19 +317,19 @@
   
   
/////////////////////////////////////////////////////////////////////////////
   // Filter the hit ratios from neighboring pixels.
-  for (int i=0;i<tile_packet.getSize();++i) {
+  for (int i=tile_packet.begin();i<tile_packet.end();++i) {
     
-    TilePacket::Element &p = tile_packet.get( i );
+    TilePacketElement& tile = tile_packet.getElement( i );
 
     // Check to see if the element is part of the tile.
-    if (!p.isOverlap()) {
+    if (!tile.isOverlap()) {
 
       // Determine the location of this element.
-      int x = p.tilex;
-      int y = p.tiley;
+      int x = tile.tilex;
+      int y = tile.tiley;
       
       // Find normal.
-      Vector &normal = p.normal;
+      Vector& normal = tile.normal;
       
       Real sum = 0.0;
       Real total = 0.0;
@@ -340,15 +341,15 @@
       for (int y_offset=-half_width;y_offset<=half_width;++y_offset) {
         for (int x_offset=-half_width;x_offset<=half_width;++x_offset) {
           
-          TilePacket::Element &neighbor =
-            disco_tile.get( x+x_offset,y+y_offset );
+          TilePacketElement& neighbor =
+            disco_tile.getElement( x+x_offset,y+y_offset );
           
           if (neighbor.wasHit()) {
 
-            Real d = SCIRun::Abs( (p.point-neighbor.point).length2() );
+            Real d = SCIRun::Abs( (tile.point-neighbor.point).length2() );
             Real n = SCIRun::Max((Real)0,Dot( normal, neighbor.normal ));
             Real pixel_dist = SCIRun::Sqrt( x_offset*x_offset +
-                                            y_offset*y_offset ) * p.t;
+                                            y_offset*y_offset ) * tile.t;
             
             if ((n > 0) && (d <= (Real)0.009*pixel_dist)) {
 
@@ -368,9 +369,9 @@
       
       // Color the pixel
       sum = (sum/total);
-      
-      p.color = p.color * Color(RGB(sum,sum,sum));
+
+      tile.color = tile.color * Color(RGB(sum,sum,sum));
     }
-  }  
+  }
 }
 

Modified: trunk/fox/disco_demo/Interface/DiscoTile.cc
==============================================================================
--- trunk/fox/disco_demo/Interface/DiscoTile.cc (original)
+++ trunk/fox/disco_demo/Interface/DiscoTile.cc Mon Feb 13 17:08:57 2006
@@ -37,7 +37,7 @@
   size_t total_pixels = (xtilesize+2*overlap) * (ytilesize+2*overlap);
   
   // Determine amount of space for the tile packet elements.
-  size_t tilepacket_bytes = total_pixels * sizeof(TilePacket::Element);
+  size_t tilepacket_bytes = total_pixels * sizeof(TilePacketElement);
 
   return tilepacket_bytes;
 }
@@ -63,10 +63,10 @@
   total(width * height)
 {
 #if SCI_ASSERTION_LEVEL >= 2
-  size_t total_bytes = total * sizeof(TilePacket::Element);
-  tilepacket_data = (TilePacket::Element*)(allocator.check_fit(total_bytes));
+  size_t total_bytes = total * sizeof(TilePacketElement);
+  tilepacket_data = (TilePacketElement*)(allocator.check_fit(total_bytes));
 #else
-  tilepacket_data = (TilePacket::Element*)(*allocator);
+  tilepacket_data = (TilePacketElement*)(*allocator);
 #endif
 }
 

Modified: trunk/fox/disco_demo/Interface/DiscoTile.h
==============================================================================
--- trunk/fox/disco_demo/Interface/DiscoTile.h  (original)
+++ trunk/fox/disco_demo/Interface/DiscoTile.h  Mon Feb 13 17:08:57 2006
@@ -64,7 +64,7 @@
     
///////////////////////////////////////////////////////////////////////////
     
///////////////////////////////////////////////////////////////////////////
     // Tile coordinate Accessors
-    TilePacket::Element &DiscoTile::get( int x, int y ) {
+    TilePacketElement& DiscoTile::getElement( int x, int y ) {
       
       // Shift so that overlap requires negative coordinates.
       int offset = get_offset( x+overlap, y+overlap );
@@ -108,7 +108,7 @@
     int total;
 
     // Arrays
-    TilePacket::Element *tilepacket_data;
+    TilePacketElement* tilepacket_data;
   };
 };
 

Modified: trunk/fox/disco_demo/Interface/TilePacket.h
==============================================================================
--- trunk/fox/disco_demo/Interface/TilePacket.h (original)
+++ trunk/fox/disco_demo/Interface/TilePacket.h Mon Feb 13 17:08:57 2006
@@ -38,7 +38,41 @@
 
   using namespace Manta;
   
-  class TilePacketData;
+  ///////////////////////////////////////////////////////////////////////////
+  // Tile Element
+  class TilePacketElement {
+    enum { WAS_HIT = 0x01,
+           OVERLAP = 0x02 };
+  public:
+    // Initialized values
+    int tilex, tiley;
+    int flags;
+    int task;
+
+    // Computed by per sampler shader.
+    Real   illuminance;
+    Real   t;
+    Vector normal;
+    Point  point;
+      
+    // Result
+    Color  color;
+
+    // Accessors.
+    bool wasHit()    { return flags & WAS_HIT; }
+    bool isOverlap() { return flags & OVERLAP; }
+  };
+  ///////////////////////////////////////////////////////////////////////////
+
+  class TilePacket;
+  
+  class TilePacketData {
+  private:
+    // This MUST be the same size as is used in RayPacket, since
+    // copying is done back and forth between the two.
+    TilePacketElement data[RayPacket::MaxSize];
+    friend class TilePacket;
+  };
   
   ///////////////////////////////////////////////////////////////////////////
   // TilePacket data structure for accessing neighboring samples and storing
@@ -49,72 +83,77 @@
     enum { WAS_HIT = 0x01,
            OVERLAP = 0x02 };
 
-    
///////////////////////////////////////////////////////////////////////////
-    // Tile Element
-    class Element {
-    public:
-      // Initialized values
-      int tilex, tiley;
-      int flags;
-      int task;
-
-      // Computed by per sampler shader.
-      Real   illuminance;
-      Real   t;
-      Vector normal;
-      Point  point;
-      
-      // Result
-      Color  color;
-
-      // Accessors.
-      bool wasHit()    { return flags & WAS_HIT; }
-      bool isOverlap() { return flags & OVERLAP; }
-    };
-    
///////////////////////////////////////////////////////////////////////////
-
     // Constructor.
-    TilePacket( TilePacketData &tilepacket_data,
-                int size_ );
+    TilePacket( TilePacketData& data, int rayBegin, int rayEnd)
+      : data( &data ),
+        rayBegin(rayBegin), rayEnd(rayEnd)
+    {
+    }
 
     // Sub packet constructor.
-    TilePacket( const TilePacket &packet, int start, int end )
-      : size(end-start), data( &packet.data[start] ) { }
+    TilePacket( const TilePacket& parent, int rayBegin, int rayEnd )
+      : data( parent.data ),
+        rayBegin(rayBegin), rayEnd(rayEnd)
+    {
+    }
 
     // Element Accessors.
-    void setElement( int i, int tilex_, int tiley_, bool overlap_ ) {
-      data[i].tilex = tilex_;
-      data[i].tiley = tiley_;
-      data[i].flags = (overlap_ << 1); }
-    Element &get( int i ) { return data[i]; }
+    void setElement( int which, int tilex_, int tiley_, bool overlap_ ) {
+      data->data[which].tilex = tilex_;
+      data->data[which].tiley = tiley_;
+      data->data[which].flags = (overlap_ << 1); }
+
+    TilePacketElement& getElement( int which ) { return data->data[which]; }
 
     // Accessors
-    int getSize() { return size; }
+    int begin() const {
+      return rayBegin;
+    }
+    int end() const {
+      return rayEnd;
+    }
+    void resize(int newSize)
+    {
+      rayBegin = 0; rayEnd = newSize;
+    }
 
-    bool wasHit( int i )     { return  data[i].wasHit(); }
-    bool isOverlap( int i )  { return  data[i].isOverlap(); }
+    bool wasHit( int which )     { return  data->data[which].wasHit(); }
+    bool isOverlap( int which )  { return  data->data[which].isOverlap(); }
 
-    void resetFlags() {
-      for(int i = 0; i < size; ++i ) {
-        data[i].flags = 0;
+    void resetAllFlags() {
+      for(int i = rayBegin; i < rayEnd; ++i ) {
+        data->data[i].flags = 0;
       }
     }
-  private:
-    // Size member of the ray packet is used.
-    int size;
-    Element *data;
-  };
+    void resetFlag( int which, int flag) {
+      data->data[which].flags &= ~flag;
+    }
+    void setFlag( int which, int flag ) {
+      data->data[which].flags |= flag;
+    }
+    int getAllFlags( int which ) const
+    {
+      return data->data[which].flags;
+    }
 
-  class TilePacketData {
+    bool getFlag( int which, int flag ) const
+    {
+      return (data->data[which].flags & flag) == flag;
+    }
+
+    Color getColor( int which ) const
+    {
+      return data->data[which].color;
+    }
+    void  setColor( int which , const Color& color) const
+    {
+      data->data[which].color = color;
+    }
   private:
-    TilePacket::Element data[RayPacket::MaxSize];
-    friend class TilePacket;
+    TilePacketData* data;
+    // Iterators
+    int rayBegin, rayEnd;
   };
-
-  // Constructor.
-  inline TilePacket::TilePacket( TilePacketData &tilepacket_data, int size_ )
-    : size( size_ ), data( &tilepacket_data.data[0] ) { }
-  
 };
 
 #endif

---

• [MANTA] r937 - in trunk/fox/disco_demo: Engine/ImageTraversers Engine/Shaders Interface, bigler, 02/13/2006

---

Archive powered by MHonArc 2.6.16.