Text archives Help

---

Author: cgribble
Date: Tue May 30 13:14:35 2006
New Revision: 1090

Added:
   trunk/Model/Primitives/DynPLTGridSpheres.cc
   trunk/Model/Primitives/DynPLTGridSpheres.h
Modified:
   trunk/Engine/Control/DynPLTWorker.cc
   trunk/Engine/Control/DynPLTWorker.h
   trunk/Model/Primitives/CMakeLists.txt
   trunk/Model/Primitives/GridSpheres.cc
   trunk/Model/Primitives/GridSpheres.h
   trunk/scenes/dynplt.cc
   trunk/scenes/pnrrd.cc
Log:
Model/Primitives/DynPLTGridSpheres.cc
Model/Primitives/DynPLTGridSpheres.h
Model/Primitives/CMakeLists.txt
  Added GridSpheres version of particle with dynamic PLTS
  Works well, but there's some flickering under Linux and MacOS X; not sure 
where
    it's it's coming from yet

Model/Primitives/GridSpheres.cc
Model/Primitives/GridSpheres.h
  Made shade virtual (so DynPLTGridSpheres can override it)
  Made private variable protected (so DynPLTGridSpheres can access them)

Engine/Control/DynPLTWorker.cc
Engine/Control/DynPLTWorker.h
  Changed code to work with DynPLTGridSpheres
  Note that old version (with DynPLTMaterial, etc.) will no longer work

scenes/dynplt.cc
  Now uses DynPLTGridSpheres


Modified: trunk/Engine/Control/DynPLTWorker.cc
==============================================================================
--- trunk/Engine/Control/DynPLTWorker.cc        (original)
+++ trunk/Engine/Control/DynPLTWorker.cc        Tue May 30 13:14:35 2006
@@ -4,6 +4,7 @@
 #include <Interface/Scene.h>
 #include <Engine/Control/DynPLTWorker.h>
 #include <Engine/Shadows/HardShadows.h>
+#include <Model/Primitives/DynPLTGridSpheres.h>
 #include <Model/Materials/DynPLTMaterial.h>
 #include <Model/Primitives/Sphere.h>
 #include <SCIRun/Core/Math/MiscMath.h>
@@ -17,7 +18,7 @@
 // XXX:  the exit strategy only works occasionally (no segfault) when the 
queue
 //       isn't empty, and never when it is empty
 
-DynPLTContext::DynPLTContext(SCIRun::Mailbox<const Sphere*>* queue,
+DynPLTContext::DynPLTContext(SCIRun::Mailbox<DynPLTMessage>* queue,
                              Scene* scene, unsigned int ngroups,
                              unsigned int nsamples, unsigned int max_depth,
                              bool dilate) :
@@ -97,17 +98,20 @@
   //               const Camera*, const Scene*, ThreadStorage*);
   RenderContext rctx(0, 0, 0, 0, 0, 0, 0, 0, &shadowAlgorithm, 0, scene, 0);
 
-  const Sphere* particle;
-  while (particle=context->queue->receive()) {
-    if (exitSem) {
-      exitSem->up();
-      return;
-    }
-
-    DynPLTMaterial* 
dynplt=dynamic_cast<DynPLTMaterial*>(particle->getMaterial());
-    if (!dynplt || dynplt->valid)
+  DynPLTMessage msg=context->queue->receive();
+  while (msg.particle>=0) {
+    // Grab message data
+    int particle=msg.particle;
+    const DynPLTGridSpheres* grid=msg.grid;
+    
+    // Allocate new texture, if necessary
+    if (grid->plts[particle])
       continue;
 
+    grid->plts[particle]=new DynPLT();
+
+    // Determine texture resolution
+    DynPLT* dynplt=grid->plts[particle];
     unsigned int xres=dynplt->getXRes();
     unsigned int yres=dynplt->getYRes();
     // Real inv_width=1/static_cast<Real>(xres - 1);
@@ -121,8 +125,8 @@
     bool dilateTexture=false;
 
     // Generate particle's texture
-    Vector center=particle->getCenter();
-    Real radius=particle->getRadius();
+    Vector center=grid->getCenter(particle);
+    Real radius=grid->getRadius(particle);
 
     for (unsigned int v=0; v<yres; ++v) {
       for (unsigned int u=0; u<xres; ++u) {
@@ -179,7 +183,7 @@
                          RayPacket::HaveUnitNormals);
 
             // Compute direct lighting at current hit positions
-            const LightSet* activeLights=dynplt->getActiveLights();
+            const LightSet* activeLights=grid->getActiveLights();
             ShadowAlgorithm::StateBuffer stateBuffer;
             bool firstTime=true;
             bool done;
@@ -339,8 +343,14 @@
 
     // XXX:  maybe use a transaction to mark the texture as valid and prevent
     //       tearing in the middle of a frame
-    dynplt->valid=true;
+    grid->valid[particle]=true;
+
+    // Receive next message
+    msg=context->queue->receive();
   }
+
+  if (exitSem)
+    exitSem->up();
 }
 
 void DynPLTWorker::terminate(MantaInterface*)
@@ -349,9 +359,9 @@
 
   // Notify worker to exit
   exitSem=&semaphore;
-  const Sphere* fake=0;
+  DynPLTMessage fake(-1, 0);
   context->queue->send(fake);
 
-  // Block the calling thread until it does...
+  // Block the calling thread until the worker's done
   semaphore.down();
 }

Modified: trunk/Engine/Control/DynPLTWorker.h
==============================================================================
--- trunk/Engine/Control/DynPLTWorker.h (original)
+++ trunk/Engine/Control/DynPLTWorker.h Tue May 30 13:14:35 2006
@@ -4,6 +4,7 @@
 
 #include <Core/Math/MT_RNG.h>
 #include <Core/Math/vector2d.h>
+#include <Model/Primitives/DynPLTGridSpheres.h>
 #include <SCIRun/Core/Containers/Array1.h>
 #include <SCIRun/Core/Containers/Array2.h>
 #include <SCIRun/Core/Thread/Mailbox.h>
@@ -20,13 +21,13 @@
   class DynPLTContext
   {
   public:
-    DynPLTContext(SCIRun::Mailbox<const Sphere*>* queue, Scene* scene,
+    DynPLTContext(SCIRun::Mailbox<DynPLTMessage>* queue, Scene* scene,
                   unsigned int ngroups, unsigned int nsamples,
                   unsigned int max_depth, bool dilate);
     ~DynPLTContext(void) { }
 
     // DynPLT work queue
-    SCIRun::Mailbox<const Sphere*>* queue;
+    SCIRun::Mailbox<DynPLTMessage>* queue;
 
     // Manta scene
     Scene* scene;

Modified: trunk/Model/Primitives/CMakeLists.txt
==============================================================================
--- trunk/Model/Primitives/CMakeLists.txt       (original)
+++ trunk/Model/Primitives/CMakeLists.txt       Tue May 30 13:14:35 2006
@@ -10,6 +10,8 @@
      Primitives/Cylinder.h
      Primitives/Disk.cc
      Primitives/Disk.h
+     Primitives/DynPLTGridSpheres.cc
+     Primitives/DynPLTGridSpheres.h
      Primitives/GridSpheres.cc
      Primitives/GridSpheres.h
      Primitives/HeavyTriangle.cc

Added: trunk/Model/Primitives/DynPLTGridSpheres.cc
==============================================================================
--- (empty file)
+++ trunk/Model/Primitives/DynPLTGridSpheres.cc Tue May 30 13:14:35 2006
@@ -0,0 +1,217 @@
+
+#include <Interface/RayPacket.h>
+#include <Engine/Control/DynPLTWorker.h>
+#include <Model/Primitives/DynPLTGridSpheres.h>
+
+#include <iostream>
+using std::cerr;
+
+using namespace Manta;
+using namespace SCIRun;
+
+void DynPLTGridSpheres::init(int nspheres)
+{
+  cerr<<"Initializing DynPLTGridSpheres\n";
+  plts.resize(nspheres);
+  valid.resize(nspheres);
+  requested.resize(nspheres);
+  for (unsigned int i=0; i<nspheres; ++i) {
+    plts[i]=0;
+    valid[i]=false;
+    requested[i]=false;
+  }
+}
+
+DynPLTGridSpheres::DynPLTGridSpheres(SCIRun::Mailbox<DynPLTMessage>* queue,
+                                     const Color& color, float* spheres,
+                                     int nspheres, int nvars, int ncells,
+                                     int depth, float radius, int ridx) :
+  queue(queue), GridSpheres(color, spheres, nspheres, nvars, ncells, depth,
+                            radius, ridx)
+{
+  init(nspheres);
+}
+
+DynPLTGridSpheres::DynPLTGridSpheres(SCIRun::Mailbox<DynPLTMessage>* queue,
+                                     const Texture<Color>* colorfn,
+                                     float* spheres, int nspheres, int nvars,
+                                     int ncells, int depth, float radius,
+                                     int ridx) :
+  queue(queue), GridSpheres(colorfn, spheres, nspheres, nvars, ncells, depth,
+                            radius, ridx)
+{
+  init(nspheres);
+}
+
+DynPLTGridSpheres::~DynPLTGridSpheres(void)
+{
+  // Do nothing
+}
+
+void DynPLTGridSpheres::shade(const RenderContext& context,
+                              RayPacket& rays) const
+{
+  for (unsigned int i=rays.begin(); i<rays.end(); ++i) {
+    // Find a run of rays that hit the same particle
+    int offset=rays.scratchpad<int>(i);
+    unsigned int end=i + 1;
+    while (end < rays.end() && rays.scratchpad<int>(end)==offset)
+      ++end;
+
+    int particle=offset/nvars;
+
+    // Shade the rays
+    RayPacket sub(rays, i, end);
+    if (valid[particle]) {
+      // Compute diffuse colors
+      Packet<Color> diffuse;
+      colortex->mapValues(diffuse, context, sub);
+    
+      // Compute textured luminance
+      sub.computeTextureCoordinates2(context);
+
+      for (unsigned int i=sub.begin(); i < sub.end(); ++i) {
+        // Wrap in x (assumes xres is a power of two)
+        Real x=sub.getTexCoords2(i, 0)*XRES;
+        int lx=static_cast<int>(x) & (XRES - 1);
+        int hx=(lx + 1) & (XRES - 1);
+        Real wx=x - lx;
+      
+        // Clamp in y
+        Real y=sub.getTexCoords2(i, 1);
+        int ly;
+        Real wy;
+        if (y < 0) {
+          ly=0;
+          wy=0;
+        } else {
+          y *= YRES - 1;
+          ly=static_cast<int>(y);
+          if (ly > YRES - 1) {
+            ly=YRES - 1;
+            wy=0;
+          } else {
+            wy=y - ly;
+          }
+        }
+
+        int hy=ly + 1;
+
+        // Interpolate
+        Real a=(plts[particle]->texture[lx][ly]*(1 - wx) +
+                plts[particle]->texture[hx][ly]*wx);
+        Real b=(plts[particle]->texture[lx][hy]*(1 - wx) +
+                plts[particle]->texture[hx][hy]*wx);
+        Real luminance=a*(1 - wy) + b*wy;
+
+        sub.setColor(i, diffuse.get(i)*luminance);
+      }
+    } else {
+      // Request texture generation, if necessary
+      if (!requested[particle]) {
+        // Look up center, radius data for current particle
+        float* data=spheres + particle;
+        float current_radius;
+        if (ridx>0) {
+          if (data[ridx] <= 0)
+            current_radius=radius;
+          else
+            current_radius=data[ridx];
+        } else {
+          current_radius=radius;
+        }
+
+        // Create and post message
+        DynPLTMessage msg(particle, this);
+        if (queue->trySend(msg))
+          requested[particle]=true;
+      }
+
+      // Use Lambertian shading while texture is invalid
+      GridSpheres::shade(context, sub);
+    }
+
+    i=end;
+  }
+}
+
+void DynPLT::dilate(const DynPLTContext* context)
+{
+  // Compute the min and max of inside texture
+  unsigned int width=XRES;
+  unsigned int height=YRES;
+  Real min=inside[0][0];
+  Real max=inside[0][0];
+  for (unsigned int y=1; y<height; ++y) {
+    for (unsigned int x=1; x<width; ++x) {
+      Real tmp=inside[x][y];
+      if (tmp < min)
+       min=tmp;
+      if (tmp > max)
+       max=tmp;
+    }
+  }
+
+  // Normalize the inside texture
+  Real inv_maxmin=1/(max-min);
+  for (unsigned int y=0; y<height; ++y)
+    for (unsigned int x=0; x<width; ++x)
+      inside[x][y]=(inside[x][y] - min)*inv_maxmin;
+
+  // Initialize the dilated texture
+  Real dilated[XRES][YRES];
+  for (unsigned int y=0; y<height; ++y)
+    for (unsigned int x=0; x<width; ++x)
+      dilated[x][y]=texture[x][y];
+  
+  // Dilate any necessary pixels
+  unsigned int support=context->support;
+  unsigned int use_weighted_avg=context->use_weighted_avg;
+  Real threshold=context->threshold;
+  
+  for (unsigned int y=0; y < height;  ++y) {
+    for (unsigned int x=0; x < width;  ++x) {
+      // Determine if the pixel should be dilated
+      Real value=inside[x][y];
+      if (value<=0)
+        continue;
+      
+      // Loop over each neighbor
+      Real avg=0;
+      Real contribution_total=0;
+      for (unsigned int j=y-support; j <= y+support; j++) {
+        for (unsigned int i=x-support; i <= x+support; i++) {
+          // Check boundary conditions
+          unsigned int newi=i;
+          if (newi >= width)
+            newi=newi - width;
+          else if (newi < 0)
+            newi += width;
+
+          unsigned int newj=j;
+          if (newj >= height)
+            newj=height - 1;
+          else if (newj < 0)
+            newj=0;
+
+          // Determine neighbor's contribution
+          Real contributer=inside[newi][newj];
+          if (contributer < threshold) {
+            contributer *= use_weighted_avg;
+            avg += texture[newi][newj]*(1 - contributer);
+            contribution_total += (1 - contributer);
+          }
+        }
+      }
+
+      // Dilate the pixel
+      if (contribution_total > 0)
+        dilated[x][y]=avg/contribution_total;
+    }
+  }
+  
+  // Update texture with dilated results
+  for (unsigned int y=0; y<height; ++y)
+    for (unsigned int x=0; x<width; ++x)
+      texture[x][y]=dilated[x][y];
+}

Added: trunk/Model/Primitives/DynPLTGridSpheres.h
==============================================================================
--- (empty file)
+++ trunk/Model/Primitives/DynPLTGridSpheres.h  Tue May 30 13:14:35 2006
@@ -0,0 +1,95 @@
+
+#ifndef Manta_Model_DynPLTGridSpheres_h
+#define Manta_Model_DynPLTGridSpheres_h
+
+#include <Model/Primitives/GridSpheres.h>
+#include <SCIRun/Core/Thread/Mailbox.h>
+
+#include <vector>
+using std::vector;
+
+#define XRES 16
+#define YRES 16
+
+namespace Manta {
+  class DynPLTContext;
+  class DynPLTGridSpheres;
+
+  class DynPLT {
+  public:
+    DynPLT(void) { }
+    ~DynPLT(void) { }
+
+    unsigned int getXRes(void) const { return XRES; }
+    unsigned int getYRes(void) const { return YRES; }
+
+    void dilate(const DynPLTContext* context);
+
+    // Luminance texture data    
+    Real texture[XRES][YRES];
+    Real inside[XRES][YRES];
+  };
+
+  struct DynPLTMessage {
+    DynPLTMessage(int particle, const DynPLTGridSpheres* grid) :
+      particle(particle), grid(grid)
+    {
+      // Do nothing
+    }
+    DynPLTMessage(void) :
+      particle(-1), grid(0)
+    {
+      // Do nothing
+    }
+
+    int particle;
+    const DynPLTGridSpheres* grid;
+  };
+
+  class DynPLTGridSpheres : public GridSpheres
+  {
+  public:
+    DynPLTGridSpheres(SCIRun::Mailbox<DynPLTMessage>* queue, const Color& 
color,
+                      float* spheres, int nspheres, int nvars, int ncells,
+                      int depth, float radius, int ridx);
+    DynPLTGridSpheres(SCIRun::Mailbox<DynPLTMessage>* queue,
+                      const Texture<Color>* colorfn, float* spheres,
+                      int nspheres, int nvars, int ncells, int depth,
+                      float radius, int ridx);
+    ~DynPLTGridSpheres(void);
+
+    void shade(const RenderContext& context, RayPacket& rays) const;
+
+    const LightSet* getActiveLights(void) const { return activeLights; }
+
+    Vector getCenter(int particle) const
+    {
+      float* data=spheres + particle*nvars;
+      return Vector(data[0], data[1], data[2]);
+    }
+
+    Real getRadius(int particle) const
+    {
+      float* data=spheres + particle*nvars;
+      if (ridx>0) {
+        if (data[ridx] <= 0)
+          return radius;
+        else
+          return data[ridx];
+      }
+
+      return radius;
+    }
+
+    mutable vector<bool> valid;
+    mutable vector<DynPLT*> plts;
+
+  private:
+    void init(int);
+
+    SCIRun::Mailbox<DynPLTMessage>* queue;
+    mutable vector<bool> requested;
+  };
+}
+
+#endif

Modified: trunk/Model/Primitives/GridSpheres.cc
==============================================================================
--- trunk/Model/Primitives/GridSpheres.cc       (original)
+++ trunk/Model/Primitives/GridSpheres.cc       Tue May 30 13:14:35 2006
@@ -813,28 +813,22 @@
 void GridSpheres::intersectSphere(RayPacket& rays, int ray_idx, int idx,
                                   const Vector& center, float radius2) const
 {
-  Vector CO=center - rays.getOrigin(ray_idx);
-  Real tca=Dot(CO, rays.getDirection(ray_idx));
-  Real l2oc=CO.length2();
-  if (l2oc <= radius2) {
-    // Ray origin is inside the sphere
-    Real t2hc=radius2 - l2oc + tca*tca;
-    Real thc=Sqrt(t2hc);
-    Real t=tca + thc;
-    if (rays.hit(ray_idx, tca - thc, this, this, this))
-      rays.scratchpad<int>(ray_idx)=cells[idx];
-  } else {
-    if (tca>=0) {
-      Real t2hc=radius2 - l2oc + tca*tca;
-      if (t2hc>0) {
-        Real thc=sqrt(t2hc);
-        if (rays.hit(ray_idx, tca - thc, this, this, this))
-          rays.scratchpad<int>(ray_idx)=cells[idx];
-      } else {
-        // Ray misses, no intersection
-      }
+  Vector O(rays.getOrigin(ray_idx) - center);
+  Vector D(rays.getDirection(ray_idx));
+  Real A=Dot(D, D);
+  Real B=Dot(O, D);
+  Real C=Dot(O, O) - radius2;
+  Real disc=B*B - A*C;
+  if (disc >= 0){
+    Real r=Sqrt(disc);
+    Real t0=-(r + B)/A;
+    if (t0 > T_EPSILON) {
+      if (rays.hit(ray_idx, t0, this, this, this))
+        rays.scratchpad<int>(ray_idx)=cells[idx];
     } else {
-      // Sphere is behind the ray origin
+      Real t1=(r - B)/A;
+      if (rays.hit(ray_idx, t1, this, this, this))
+        rays.scratchpad<int>(ray_idx)=cells[idx];
     }
   }
 }

Modified: trunk/Model/Primitives/GridSpheres.h
==============================================================================
--- trunk/Model/Primitives/GridSpheres.h        (original)
+++ trunk/Model/Primitives/GridSpheres.h        Tue May 30 13:14:35 2006
@@ -29,14 +29,14 @@
     void intersect(const RenderContext& context, RayPacket& rays) const;
     void computeNormal(const RenderContext& context, RayPacket& rays) const;
 
-    void shade(const RenderContext& context, RayPacket& rays) const;
+    virtual void shade(const RenderContext& context, RayPacket& rays) const;
 
     void computeTexCoords2(const RenderContext& context,
                                   RayPacket& rays) const;
     void computeTexCoords3(const RenderContext& context,
                                   RayPacket& rays) const;
 
-  private:
+  protected:
     struct MCell {
       int nspheres;
       float* max;

Modified: trunk/scenes/dynplt.cc
==============================================================================
--- trunk/scenes/dynplt.cc      (original)
+++ trunk/scenes/dynplt.cc      Tue May 30 13:14:35 2006
@@ -11,6 +11,7 @@
 #include <Model/Groups/Group.h>
 #include <Model/Lights/PointLight.h>
 #include <Model/Materials/DynPLTMaterial.h>
+#include <Model/Primitives/DynPLTGridSpheres.h>
 #include <Model/Primitives/Sphere.h>
 #include <Model/Readers/ParticleNRRD.h>
 #include <SCIRun/Core/Thread/Mailbox.h>
@@ -31,8 +32,10 @@
 {
   Group* world=0;
   string fname="";
+  int depth=1;
   bool dilate=false;
   int max_depth=3;
+  int ncells=2;
   int ngroups=100;
   int nsamples=32;
   int nthreads=1;
@@ -45,11 +48,16 @@
   int argc=static_cast<int>(args.size());
   for(int i=0; i<argc; ++i) {
     string arg=args[i];
+#if 0
     if (arg=="-bv") {
       string s;
       if (!getStringArg(i, args, s))
         throw IllegalArgument("scene dynplt -bv", i, args);
       world=context.manta_interface->makeGroup(s);
+#endif
+    if (arg=="-depth") {
+      if (!getIntArg(i, args, depth))
+        throw IllegalArgument("scene dynplt -depth", i, args);
     } else if (arg=="-dilate") {
       dilate=true;
     } else if (arg=="-i") {
@@ -59,6 +67,9 @@
       if (!getIntArg(i, args, max_depth))
         throw IllegalArgument("scene dynplt -nbounces", i, args);
       ++max_depth;
+    } else if (arg=="-ncells") {
+      if (!getIntArg(i, args, ncells))
+        throw IllegalArgument("scene dynplt -ncells", i, args);
     } else if (arg=="-ngroups") {
       if (!getIntArg(i, args, ngroups))
         throw IllegalArgument("scene dynplt -ngroups", i, args);
@@ -79,10 +90,12 @@
         throw IllegalArgument("scene dynplt -qsize", i, args);
     } else {
       cerr<<"Valid options for scene dynplt:\n";
-      cerr<<"  -bv <string>      bounding volume {bvh|grid|group}\n";
+      // cerr<<"  -bv <string>      bounding volume {bvh|grid|group}\n";
+      cerr<<"  -depth <int>      grid depth\n";
       cerr<<"  -dilate           dilate textures during generation\n";
       cerr<<"  -i <string>       particle data filename\n";
       cerr<<"  -nbounces <int>   number of indirect nbounces\n";
+      cerr<<"  -ncells <int>     grid resolution\n";
       cerr<<"  -ngroups <int>    number of sample groups\n";
       cerr<<"  -nsamples <int>   number of samples/texel\n";
       cerr<<"  -nthreads <int>   number of dynplt workers\n";
@@ -100,7 +113,7 @@
   Scene* scene=new Scene();
 
   // Create DynPLT work queue
-  Mailbox<const Sphere*>* queue=new Mailbox<const Sphere*>("DynPLT Work 
Queue",
+  Mailbox<DynPLTMessage>* queue=new Mailbox<DynPLTMessage>("DynPLT Work 
Queue",
                                                            nthreads*qsize);
   
   // Create DynPLTContext
@@ -124,6 +137,14 @@
 
   // Load particle data, add particles to group
   ParticleNRRD pnrrd(fname);
+#if 1
+  DynPLTGridSpheres* spheres=new DynPLTGridSpheres(queue, Color(RGB(0, 1, 
0)),
+                                                   pnrrd.getParticleData(),
+                                                   pnrrd.getNParticles(),
+                                                   pnrrd.getNVars(),
+                                                   ncells, depth, radius, 
ridx);
+  world->add(spheres);
+#else
   float* pdata=pnrrd.getParticleData();
   for (unsigned int i=0; i<pnrrd.getNParticles(); ++i) {
     unsigned int idx=i*pnrrd.getNVars();
@@ -134,10 +155,10 @@
     if (ridx>=0)
       radius=pdata[idx + ridx];
     
-    // Material* dynplt=new DynPLTMaterial(queue, Color(RGB(1, 1, 1)));
     Material* dynplt=new DynPLTMaterial(queue, Color(RGB(0, 1, 0)));
     world->add(new Sphere(dynplt, Vector(x, y, z), radius));
   }
+#endif
 
   // Initialize the scene
   scene->setBackground(new ConstantBackground(Color(RGB(0, 0, 0))));
@@ -149,6 +170,8 @@
   lights->setAmbientLight(new ConstantAmbient(Color(RGB(0.4, 0.4, 0.4))));
   scene->setLights(lights);
 
+  scene->addBookmark("debug 0", Vector(0.06, 26.9721, 0.06),
+                     Vector(0.06, 0.06, 0.06), Vector(0, 0, 1), 0.59);
   scene->addBookmark("view 0", Vector(0.02, 1.02, 0.20),
                      Vector(0.02, 0.02, 0.20), Vector(0, 0, 1),
                      0.59);

Modified: trunk/scenes/pnrrd.cc
==============================================================================
--- trunk/scenes/pnrrd.cc       (original)
+++ trunk/scenes/pnrrd.cc       Tue May 30 13:14:35 2006
@@ -78,7 +78,7 @@
                                        pnrrd.getParticleData(),
                                        pnrrd.getNParticles(), 
pnrrd.getNVars(),
                                        ncells, depth, radius, ridx);
-    world->add(spheres);
+  world->add(spheres);
 #else
   float* pdata=pnrrd.getParticleData();
   for (unsigned int i=0; i<pnrrd.getNParticles(); ++i) {

---

• [MANTA] r1090 - in trunk: Engine/Control Model/Primitives scenes, cgribble, 05/30/2006

---

Archive powered by MHonArc 2.6.16.