Text archives Help

---

Author: boulos
Date: Thu Apr  3 13:09:32 2008
New Revision: 2164

Added:
   trunk/Engine/PixelSamplers/ClusterSampler.cc
      - copied, changed from r2163, 
trunk/Engine/PixelSamplers/JitterSampler.cc
   trunk/Engine/PixelSamplers/ClusterSampler.h
      - copied, changed from r2163, trunk/Engine/PixelSamplers/JitterSampler.h
Modified:
   trunk/Engine/Factory/RegisterKnownComponents.cc
   trunk/Engine/ImageTraversers/DeadlineImageTraverser.cc
   trunk/Engine/PixelSamplers/CMakeLists.txt
Log:
Engine/Factory/RegisterKnownComponents.cc
Engine/PixelSamplers/CMakeLists.txt
Engine/PixelSamplers/ClusterSampler.cc
Engine/PixelSamplers/ClusterSampler.h

 Starting work on a ClusterSampler (shoot lots of geometric
 antialiasing rays, shade less and interpolate). The goal is to use it
 for very complex scenes with lots of geometry (like REYES style
 geometry).

 Resorting the includes for RegisterKnownComponents.

Engine/ImageTraversers/DeadlineImageTraverser.cc

 Cleaning up the allocated memory we use in the destructor.


Modified: trunk/Engine/Factory/RegisterKnownComponents.cc
==============================================================================
--- trunk/Engine/Factory/RegisterKnownComponents.cc     (original)
+++ trunk/Engine/Factory/RegisterKnownComponents.cc     Thu Apr  3 13:09:32 
2008
@@ -26,53 +26,57 @@
   DEALINGS IN THE SOFTWARE.
 */
 
-#include <Engine/Factory/Factory.h>
+
+#include <Engine/Display/FileDisplay.h>
 #include <Engine/Display/NullDisplay.h>
 #if MANTA_ENABLE_X11
 #  include <Engine/Display/OpenGLDisplay.h>
 #endif
-#include <Engine/Display/FileDisplay.h>
+#include <Engine/Factory/Factory.h>
 #include <Engine/IdleModes/ZoomIdleMode.h>
-#include <Engine/ImageTraversers/NullImageTraverser.h>
 #include <Engine/ImageTraversers/DeadlineImageTraverser.h>
-#include <Engine/ImageTraversers/TiledImageTraverser.h>
 #include <Engine/ImageTraversers/DissolveImageTraverser.h>
-#include <Engine/ImageTraversers/DissolveTiledImageTraverser.h>
 #include <Engine/ImageTraversers/DissolveImageTraverser.h>
 #include <Engine/ImageTraversers/DissolveTiledImageTraverser.h>
+#include <Engine/ImageTraversers/DissolveTiledImageTraverser.h>
 #include <Engine/ImageTraversers/FilteredImageTraverser.h>
+#include <Engine/ImageTraversers/NullImageTraverser.h>
+#include <Engine/ImageTraversers/TiledImageTraverser.h>
 #include <Engine/LoadBalancers/CyclicLoadBalancer.h>
 #include <Engine/LoadBalancers/SimpleLoadBalancer.h>
 #include <Engine/LoadBalancers/WQLoadBalancer.h>
+#include <Engine/PixelSamplers/ClusterSampler.h>
 #include <Engine/PixelSamplers/FastSampler.h>
-#include <Engine/PixelSamplers/NullSampler.h>
-#include <Engine/PixelSamplers/SingleSampler.h>
 #include <Engine/PixelSamplers/JitterSampler.h>
+#include <Engine/PixelSamplers/NullSampler.h>
 #include <Engine/PixelSamplers/RegularSampler.h>
+#include <Engine/PixelSamplers/SingleSampler.h>
 #include <Engine/Renderers/KajiyaPathtracer.h>
 #include <Engine/Renderers/Moire.h>
-#include <Engine/Renderers/Noise.h>
 #include <Engine/Renderers/NPREdges.h>
+#include <Engine/Renderers/Noise.h>
 #include <Engine/Renderers/NullRenderer.h>
 #include <Engine/Renderers/RayGen.h>
 #include <Engine/Renderers/Raytracer.h>
 #include <Engine/Shadows/HardShadows.h>
 #include <Engine/Shadows/NoShadows.h>
-#include <Image/Pixel.h>
 #include <Image/NullImage.h>
+#include <Image/Pixel.h>
 #include <Image/SimpleImage.h>
 #include <Model/Cameras/EnvironmentCamera.h>
-#include <Model/Cameras/PinholeCamera.h>
-#include <Model/Cameras/OrthogonalCamera.h>
 #include <Model/Cameras/FisheyeCamera.h>
+#include <Model/Cameras/OrthogonalCamera.h>
+#include <Model/Cameras/PinholeCamera.h>
 #include <Model/Cameras/ThinLensCamera.h>
 #include <Model/Groups/Group.h>
+
+#include <UserInterface/CameraPathAutomator.h>
+#include <UserInterface/NullUI.h>
 // #include <UserInterface/PromptUI.h>
 #if MANTA_ENABLE_X11
 #  include <UserInterface/XWindowUI.h>
 #endif
-#include <UserInterface/NullUI.h>
-#include <UserInterface/CameraPathAutomator.h>
+
 
 // If you add a component that conditionally builds based on how the
 // build is configured, please add it to
@@ -118,6 +122,7 @@
     engine->registerComponent("singlesample", &SingleSampler::create);
     engine->registerComponent("jittersample", &JitterSampler::create);
     engine->registerComponent("regularsample", &RegularSampler::create);
+    engine->registerComponent("cluster", &ClusterSampler::create);
 
     // Register renderers
     engine->registerComponent("pathtracer", &KajiyaPathtracer::create);

Modified: trunk/Engine/ImageTraversers/DeadlineImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/DeadlineImageTraverser.cc      (original)
+++ trunk/Engine/ImageTraversers/DeadlineImageTraverser.cc      Thu Apr  3 
13:09:32 2008
@@ -159,6 +159,8 @@
 }
 
 DeadlineImageTraverser::~DeadlineImageTraverser() {
+  delete[] jitterSamplers;
+  delete[] sampleGenerators;
 }
 
 void DeadlineImageTraverser::setupBegin(SetupContext& context, int 
numChannels)

Modified: trunk/Engine/PixelSamplers/CMakeLists.txt
==============================================================================
--- trunk/Engine/PixelSamplers/CMakeLists.txt   (original)
+++ trunk/Engine/PixelSamplers/CMakeLists.txt   Thu Apr  3 13:09:32 2008
@@ -1,5 +1,7 @@
 
 SET (Manta_PixelSamplers_SRCS
+     PixelSamplers/ClusterSampler.h
+     PixelSamplers/ClusterSampler.cc
      PixelSamplers/FastSampler.h
      PixelSamplers/FastSampler.cc
      PixelSamplers/JitterSampler.h

Copied: trunk/Engine/PixelSamplers/ClusterSampler.cc (from r2163, 
trunk/Engine/PixelSamplers/JitterSampler.cc)
==============================================================================
--- trunk/Engine/PixelSamplers/JitterSampler.cc (original)
+++ trunk/Engine/PixelSamplers/ClusterSampler.cc        Thu Apr  3 13:09:32 
2008
@@ -1,65 +1,75 @@
 
 #include <Core/Exceptions/IllegalArgument.h>
-#include <Engine/PixelSamplers/JitterSampler.h>
+#include <Core/Math/MiscMath.h>
 #include <Core/Util/Args.h>
+#include <Engine/PixelSamplers/ClusterSampler.h>
+#include <Engine/SampleGenerators/Stratified2D.h>
+#include <Interface/Camera.h>
 #include <Interface/Context.h>
 #include <Interface/Fragment.h>
+#include <Interface/Object.h>
 #include <Interface/RayPacket.h>
 #include <Interface/Renderer.h>
 #include <Interface/SampleGenerator.h>
-#include <Core/Math/CheapRNG.h>
-#include <Core/Math/MiscMath.h>
+#include <Interface/Scene.h>
 
 using namespace Manta;
 
 #include <iostream>
 using namespace std;
 
-PixelSampler* JitterSampler::create(const vector<string>& args)
+PixelSampler* ClusterSampler::create(const vector<string>& args)
 {
-
-  return new JitterSampler(args);
+  return new ClusterSampler(args);
 }
 
-JitterSampler::JitterSampler(const vector<string>& args):
-  num_samples(4), use_cheaprng(true), random(0)
+ClusterSampler::ClusterSampler(const vector<string>& args):
+  num_samples(64)
 {
   for(size_t i = 0; i<args.size();i++){
     string arg = args[i];
     if(arg == "-numberOfSamples"){
       if(!getIntArg(i, args, num_samples))
-        throw IllegalArgument("JitterSampler -numberOfSamples", i, args);
+        throw IllegalArgument("ClusterSampler -numberOfSamples", i, args);
       if (num_samples < 1)
         throw IllegalArgument("-numberOfSamples must be greater than 0",
                               i, args);
-    } else if (arg == "-nocheap") {
-      use_cheaprng = false;
     }
 
     else {
-      throw IllegalArgument("JitterSampler", i, args);
+      throw IllegalArgument("ClusterSampler", i, args);
     }
   }
 
   // Compute nx and ny
   findFactorsNearRoot(num_samples, nx, ny);
+
+  maxSqrt = Ceil(Sqrt(static_cast<Real>(num_samples)));
+  antialiasGenerator = new Stratified2D(num_samples);
+  sampleGenerators = new SampleGenerator*[maxSqrt];
+  for (int i = 0; i < maxSqrt; i++) {
+    int samples = (i+1) * (i+1);
+    sampleGenerators[i] = new Stratified2D(samples);
+  }
 }
 
-JitterSampler::~JitterSampler()
+ClusterSampler::~ClusterSampler()
 {
-  if (random) delete[] random;
+
 }
 
-void JitterSampler::setupBegin(const SetupContext& context, int numChannels)
+void ClusterSampler::setupBegin(const SetupContext& context, int numChannels)
 {
   channelInfo.resize(numChannels);
-  if (random) delete[] random;
-  random = new MT_RNG[context.numProcs];
   context.renderer->setupBegin(context, numChannels);
   context.sample_generator->setupBegin(context, numChannels);
+  antialiasGenerator->setupBegin(context, numChannels);
+  for (int i = 0; i < maxSqrt; i++) {
+    sampleGenerators[i]->setupBegin(context, numChannels);
+  }
 }
 
-void JitterSampler::setupDisplayChannel(SetupContext& context)
+void ClusterSampler::setupDisplayChannel(SetupContext& context)
 {
   ChannelInfo& ci = channelInfo[context.channelIndex];
   bool stereo;
@@ -73,170 +83,183 @@
 
   context.renderer->setupDisplayChannel(context);
   context.sample_generator->setupDisplayChannel(context);
+  antialiasGenerator->setupDisplayChannel(context);
+  for (int i = 0; i < maxSqrt; i++) {
+    sampleGenerators[i]->setupDisplayChannel(context);
+  }
 }
 
-void JitterSampler::setupFrame(const RenderContext& context)
+void ClusterSampler::setupFrame(const RenderContext& context)
 {
   context.renderer->setupFrame(context);
   context.sample_generator->setupFrame(context);
+  antialiasGenerator->setupFrame(context);
+  for (int i = 0; i < maxSqrt; i++) {
+    sampleGenerators[i]->setupFrame(context);
+  }
 }
 
-// The fragment, sample_color, and sample_color_size paramters are
-// obvious enough, but the other two need some explaination.
-//
-// samples_collected_return represent the number of samples that have
-// already been used to color a fragment element.  If a fragment
-// element's samples span more than one RayPacket, then we account for
-// that with this variable.
-//
-// current_fragment_return keeps track of which fragment elements have
-// had their color computed.
-void JitterSampler::computeAverages(Fragment& fragment, const RayPacket& 
rays,
-                                    int& samples_collected_return,
-                                    int& current_fragment_return) {
-  // Copy the values, so the we can hopefully use the cache when
-  // assigning the values.
-  int samples_collected = samples_collected_return;
-  int current_fragment = current_fragment_return;
-  Color fragment_color = Color::black();
-  for(int sample_index = rays.begin(); sample_index < rays.end(); 
sample_index++) {
-    fragment_color += rays.getColor(sample_index);
-    samples_collected++;
-    // We've collected enough samples, so compute the average and
-    // assign it to the fragment.
-    if(samples_collected == num_samples) {
-      fragment.addColor(current_fragment, fragment_color / num_samples);
-      // Reset our accumulation variables
-      fragment_color = Color::black();
-      samples_collected = 0;
-      current_fragment++;
-    }
-  }
-  // 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.addColor(current_fragment, fragment_color / num_samples);
-
-  // Assign the values back to the parameters.
-  samples_collected_return = samples_collected;
-  current_fragment_return = current_fragment;
-}
-
-void JitterSampler::renderFragment(const RenderContext& context,
+void ClusterSampler::renderFragment(const RenderContext& context,
                                    Fragment& fragment)
 {
   ChannelInfo& ci = channelInfo[context.channelIndex];
-  int thd_num = context.proc;
 
   int flags = RayPacket::HaveImageCoordinates;
   if(fragment.getFlag(Fragment::ConstantEye))
     flags |= RayPacket::ConstantEye;
 
-  int consecutivex_flag = fragment.getFlag(Fragment::ConsecutiveX);
-
-  CheapRNG rng;
-  if (consecutivex_flag) {
-    int b = fragment.begin();
-    if (use_cheaprng)
-      rng.seed(fragment.getX(b)*ci.xres+fragment.getY(b));
-    else
-      random[thd_num].seed(fragment.getX(b)*ci.xres+fragment.getY(b));
-  }
-
   int depth = 0;
   RayPacketData raydata;
   RayPacket rays(raydata, RayPacket::UnknownShape, 0, RayPacket::MaxSize, 
depth, flags);
 
+  RayPacketData shade_data;
+  RayPacket shading_rays(shade_data, RayPacket::UnknownShape, 0, 
RayPacket::MaxSize, depth, flags);
+
   Real inx = (Real)1/nx;
   Real iny = (Real)1/ny;
+  Real inv_samples = inx * iny;
   Real px, py;
 
-  int sample_count = 0;
-  // No samples accumulated yet.
-  int samples_collected = 0;
-  // Index to the first fragment's element.
-  int current_fragment = 0;
-
-  Packet<Real> r1;
-  Packet<Real> r2;
-  if (use_cheaprng) {
-    rng.nextPacket(r1, rays);
-    rng.nextPacket(r2, rays);
-  } else {
-    random[thd_num].nextPacket(r1, rays);
-    random[thd_num].nextPacket(r2, rays);
-  }
-
-  // We can compute at most RayPacket::MaxSize number of rays at time.
-  for(int frag_index = fragment.begin(); frag_index < fragment.end(); 
frag_index++) {
-    // Initialize the color
-    fragment.setColor(frag_index, Color::black());
-
-    if (!consecutivex_flag) {
-      if (use_cheaprng)
-        
rng.seed(fragment.getX(frag_index)*ci.xres+fragment.getY(frag_index));
-      else
-        
random[thd_num].seed(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.
+  RenderContext& mutable_context = const_cast<RenderContext&>(context);
+  SampleGenerator* original_samplegen = context.sample_generator;
+
+  for (int frag_index = fragment.begin(); frag_index < fragment.end(); 
frag_index++) {
     int fx = fragment.getX(frag_index);
     int fy = fragment.getY(frag_index);
     int pixel_id = fy * ci.xres + fx;
-    // Which sample does this ray packet start at?
 
+    rays.resize(nx * ny);
+    // NOTE(boulos): Setup region_id first
+    int sample_count = 0;
     for(int xs = 0; xs < nx; xs++) {
       for(int ys = 0; ys  < ny; ys++) {
-          Real x_sample = (xs + r1.get(sample_count)) * inx;
-          Real y_sample = (ys + r2.get(sample_count)) * iny;
+        rays.data->sample_id[sample_count] = xs * ny + ys;
+        rays.data->region_id[sample_count] = pixel_id;
+        sample_count++;
+      }
+    }
+
+    mutable_context.sample_generator = antialiasGenerator;
+    context.sample_generator->setupPacket(context, rays);
+    Packet<Real> r1;
+    Packet<Real> r2;
+    context.sample_generator->nextSeeds(context, r1, rays);
+    context.sample_generator->nextSeeds(context, r2, rays);
+    sample_count = 0;
 
-          px = (fx+x_sample)*ci.xscale+ci.xoffset;
-          py = (fy+y_sample)*ci.yscale+ci.yoffset;
-          rays.setPixel(sample_count, 0, px, py);
-          rays.data->sample_id[sample_count] = xs * ny + ys;
-          rays.data->region_id[sample_count] = pixel_id;
-          sample_count++;
-
-          if (sample_count == RayPacket::MaxSize) {
-            // Filled up the ray packet, so send them off!
-            rays.resize(sample_count);
-            context.sample_generator->setupPacket(context, rays);
-            context.renderer->traceEyeRays(context, rays);
-
-            computeAverages(fragment, rays,
-                            samples_collected, current_fragment);
-
-            // Now reset the index, so that we can start filling up
-            // the RayPacket again.
-            sample_count = 0;
-
-            // Make sure we start with a fresh slate
-            rays.resetHits();
-            rays.setAllFlags(flags);
-
-            // Grab more samples
-            if (use_cheaprng) {
-              rng.nextPacket(r1, rays);
-              rng.nextPacket(r2, rays);
-            } else {
-              random[thd_num].nextPacket(r1, rays);
-              random[thd_num].nextPacket(r2, rays);
-            }
-          } // end packet shoot and reset test
+    for(int xs = 0; xs < nx; xs++) {
+      for(int ys = 0; ys  < ny; ys++) {
+        Real x_sample = (xs + r1.get(sample_count)) * inx;
+        Real y_sample = (ys + r2.get(sample_count)) * iny;
+        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++;
       }
-    } // end sample filling loops
-  } // end fragment loop
+    }
 
-  // Pick up any stragling samples
-  if (sample_count > 0) {
     rays.resize(sample_count);
-    context.sample_generator->setupPacket(context, rays);
-    context.renderer->traceEyeRays(context, rays);
 
-    computeAverages(fragment, rays,
-                    samples_collected, current_fragment);
+    // Copied from rayTracer traceEyeRays
+    context.camera->makeRays(context, rays);
+    rays.initializeImportance();
+
+    rays.resetHits();
+    context.scene->getObject()->intersect(context, rays);
+
+    // Build clusters and determine how many shading rays are needed.
+    int uniquePrims = 0;
+    bool visited[RayPacket::MaxSize];
+    int counts[RayPacket::MaxSize];
+    int prim_id[RayPacket::MaxSize];
+    const Primitive* prims[RayPacket::MaxSize];
+
+    bzero(visited, sizeof(bool) * RayPacket::MaxSize);
+    bzero(counts, sizeof(bool) * RayPacket::MaxSize);
+
+    for (int i = rays.begin(); i < rays.end(); i++) {
+      if (visited[i]) continue;
+      const Primitive* prim = rays.getHitPrimitive(i);
+      for (int j = i+1; j < rays.end(); j++) {
+        if (rays.getHitPrimitive(j) == prim) {
+          visited[j] = true;
+          prim_id[j] = uniquePrims;
+          counts[uniquePrims]++;
+        }
+      }
+      visited[i] = true;
+      prim_id[i] = uniquePrims;
+      counts[uniquePrims]++;
+      prims[uniquePrims] = prim;
+      uniquePrims++;
+    }
+
+    int neededRays = Max(min_shading_samples, uniquePrims);
+    int sqrtRays = Ceil(Sqrt(static_cast<Real>(neededRays)));
+    int realNumRays = sqrtRays * sqrtRays;
+
+    mutable_context.sample_generator = sampleGenerators[sqrtRays - 1];
+    shading_rays.resize(realNumRays);
+    sample_count = 0;
+    // Again setup the region id first.
+    for(int xs = 0; xs < sqrtRays; xs++) {
+      for(int ys = 0; ys  < sqrtRays; ys++) {
+        shading_rays.data->sample_id[sample_count] = xs * sqrtRays + ys;
+        rays.data->region_id[sample_count] = pixel_id;
+        sample_count++;
+      }
+    }
+    context.sample_generator->setupPacket(context, shading_rays);
+
+    context.sample_generator->nextSeeds(context, r1, shading_rays);
+    context.sample_generator->nextSeeds(context, r2, shading_rays);
+
+    Real inv_sqrt = 1.f/static_cast<Real>(sqrtRays);
+    sample_count = 0;
+    for(int xs = 0; xs < sqrtRays; xs++) {
+      for(int ys = 0; ys  < sqrtRays; ys++) {
+        Real x_sample = (xs + r1.get(sample_count)) * inv_sqrt;
+        Real y_sample = (ys + r2.get(sample_count)) * inv_sqrt;
+        px = (fx+x_sample)*ci.xscale+ci.xoffset;
+        py = (fy+y_sample)*ci.yscale+ci.yoffset;
+        shading_rays.setPixel(sample_count, 0, px, py);
+        sample_count++;
+      }
+    }
+    context.renderer->traceEyeRays(context, shading_rays);
+
+    // Now the results of our shading_rays have come back, determine
+    // for each unique primitive the average result and then determine
+    // the final average as a weighted sum of those primitives
+    Color primColor[RayPacket::MaxSize];
+    bzero(primColor, sizeof(Color) * uniquePrims);
+    int shade_counts[RayPacket::MaxSize];
+    bzero(shade_counts, sizeof(int) * uniquePrims);
+    for (int i = shading_rays.begin(); i < shading_rays.end(); i++) {
+      int which_prim = -1;
+      const Primitive* prim = shading_rays.getHitPrimitive(i);
+      for (int j = 0; j < uniquePrims; j++) {
+        if (prims[j] == prim) {
+          which_prim = j;
+          break;
+        }
+      }
+      if (which_prim != -1) {
+        shade_counts[which_prim]++;
+        primColor[which_prim] += shading_rays.getColor(i);
+      }
+    }
+    // Go through all the unique prims and determine the average
+    // shading results
+    Color final_color = Color::black();
+
+    for (int i = 0; i < uniquePrims; i++) {
+      if (shade_counts[i]) {
+        final_color += (primColor[i] * counts[i] * inv_samples / 
static_cast<Real>(shade_counts[i]));
+      }
+
+    }
+    fragment.setColor(frag_index, final_color);
   }
+  mutable_context.sample_generator = original_samplegen;
 }

Copied: trunk/Engine/PixelSamplers/ClusterSampler.h (from r2163, 
trunk/Engine/PixelSamplers/JitterSampler.h)
==============================================================================
--- trunk/Engine/PixelSamplers/JitterSampler.h  (original)
+++ trunk/Engine/PixelSamplers/ClusterSampler.h Thu Apr  3 13:09:32 2008
@@ -1,6 +1,6 @@
 
-#ifndef Manta_Engine_JitterSampler_h
-#define Manta_Engine_JitterSampler_h
+#ifndef Manta_Engine_ClusterSampler_h
+#define Manta_Engine_ClusterSampler_h
 
 #include <Interface/PixelSampler.h>
 #include <Core/Math/MT_RNG.h>
@@ -13,33 +13,33 @@
 namespace Manta {
   using namespace std;
   class RayPacket;
-  
-  class JitterSampler : public PixelSampler {
+  class SampleGenerator;
+
+  class ClusterSampler : public PixelSampler {
   public:
-    JitterSampler(const vector<string>& args);
-    JitterSampler( const int nx_, const int ny_, bool cheap_ = false ) :
-      num_samples( nx_ * ny_ ), nx( nx_ ), ny( ny_ ), use_cheaprng( cheap_ ) 
{ }
+    ClusterSampler(const vector<string>& args);
 
-    virtual ~JitterSampler();
+    virtual ~ClusterSampler();
     virtual void setupBegin(const SetupContext&, int numChannels);
     virtual void setupDisplayChannel(SetupContext&);
     virtual void setupFrame(const RenderContext& context);
     virtual void renderFragment(const RenderContext& context,
-                               Fragment& fragment);
+                                Fragment& fragment);
 
     static PixelSampler* create(const vector<string>& args);
   private:
-    JitterSampler(const JitterSampler&);
-    JitterSampler& operator=(const JitterSampler&);
+    ClusterSampler(const ClusterSampler&);
+    ClusterSampler& operator=(const ClusterSampler&);
 
     void computeAverages(Fragment& fragment, const RayPacket& rays,
                          int& samples_collected, int& current_fragment);
-    
+
     int num_samples;
+    int min_shading_samples;
     // nx*ny == num_samples where nx~=ny (or as close as you can get it).
     int nx, ny;
-    bool use_cheaprng;
-    
+    int maxSqrt;
+
     struct ChannelInfo {
       Real xscale;
       Real xoffset;
@@ -48,7 +48,8 @@
       int xres, yres;
     };
 
-    MT_RNG *random;
+    SampleGenerator* antialiasGenerator;
+    SampleGenerator** sampleGenerators; // An array of sample generators for 
each refinement level
     vector<ChannelInfo> channelInfo;
   };
 }

---

• [Manta] r2164 - in trunk/Engine: Factory ImageTraversers PixelSamplers, Solomon Boulos, 04/03/2008

---

Archive powered by MHonArc 2.6.16.