Text archives Help

---

Author: boulos
Date: Sun Nov  4 22:26:30 2007
New Revision: 1813

Added:
   trunk/Model/Groups/MovingMesh.cc
   trunk/Model/Groups/MovingMesh.h
      - copied, changed from r1808, trunk/Model/Groups/Mesh.h
   trunk/Model/Primitives/MovingKSTriangle.cc
      - copied, changed from r1808, 
trunk/Model/Primitives/KenslerShirleyTriangle.cc
   trunk/Model/Primitives/MovingKSTriangle.h
      - copied, changed from r1808, 
trunk/Model/Primitives/KenslerShirleyTriangle.h
Modified:
   trunk/Interface/MeshTriangle.h
   trunk/Model/Groups/CMakeLists.txt
   trunk/Model/Groups/Mesh.cc
   trunk/Model/Groups/Mesh.h
   trunk/Model/Groups/ObjGroup.cc
   trunk/Model/MiscObjects/KeyFrameAnimation.cc
   trunk/Model/Primitives/CMakeLists.txt
   trunk/Model/Primitives/KenslerShirleyTriangle.cc
   trunk/Model/Textures/ImageTexture.cc
Log:
Interface/MeshTriangle.h

 Making getVertex const and adding MOVING_KS_TRI to the TriangleType
 list.

Model/Groups/Mesh.cc
Model/Groups/Mesh.h

 Making a few functions virtual so that we can subclass from
 Mesh. This results in a slight performance penalty for Mesh users,
 but results in a lot more flexibility in how to arrange a Mesh.


Model/Groups/CMakeLists.txt
Model/Groups/MovingMesh.cc
Model/Groups/MovingMesh.h

 Adding a new "MovingMesh" which represents a pair of timesteps for an
 animation at once. This allows for motion blurred rendering of a
 Mesh.


Model/Groups/ObjGroup.cc

 Adding support for the MOVING_KS_TRIANGLE.

Model/MiscObjects/KeyFrameAnimation.cc

 Making sure that the changed bit is set when the animation updates
 (so that the pipeline knows it needs a reset)

Model/Primitives/CMakeLists.txt
Model/Primitives/MovingKSTriangle.cc
Model/Primitives/MovingKSTriangle.h

 Adding a new moving triangle type based on the KS test.

Model/Primitives/KenslerShirleyTriangle.cc

 Using mesh->getVertex instead of hard coding this.

Model/Textures/ImageTexture.cc

 Letting the user know that OpenEXR is being used.


Modified: trunk/Interface/MeshTriangle.h
==============================================================================
--- trunk/Interface/MeshTriangle.h      (original)
+++ trunk/Interface/MeshTriangle.h      Sun Nov  4 22:26:30 2007
@@ -21,11 +21,10 @@
     }
 
     //which should be 0, 1, or 2.
-    virtual Vector getVertex(unsigned int which)
+    virtual Vector getVertex(unsigned int which) const
     {
       ASSERT(which < 3);
-      const unsigned int index = myID*3;
-      return mesh->vertices[mesh->vertex_indices[index+which]];
+      return mesh->getVertex(myID, which);
     }
 
     virtual void computeBounds(const PreprocessContext& context,
@@ -35,7 +34,11 @@
     }
 
     //List of the triangle classes that implement MeshTriangle.
-    enum TriangleType {WALD_TRI, KENSLER_SHIRLEY_TRI};
+    enum TriangleType {
+      WALD_TRI,
+      KENSLER_SHIRLEY_TRI,
+      MOVING_KS_TRI,
+    };
 
   protected:
     MeshTriangle(): myID(0), mesh(NULL) { }

Modified: trunk/Model/Groups/CMakeLists.txt
==============================================================================
--- trunk/Model/Groups/CMakeLists.txt   (original)
+++ trunk/Model/Groups/CMakeLists.txt   Sun Nov  4 22:26:30 2007
@@ -7,6 +7,8 @@
      Groups/Group.h
      Groups/Mesh.cc
      Groups/Mesh.h
+     Groups/MovingMesh.cc
+     Groups/MovingMesh.h
      Groups/ObjGroup.h
      Groups/ObjGroup.cc
 )

Modified: trunk/Model/Groups/Mesh.cc
==============================================================================
--- trunk/Model/Groups/Mesh.cc  (original)
+++ trunk/Model/Groups/Mesh.cc  Sun Nov  4 22:26:30 2007
@@ -193,10 +193,9 @@
 
 BBox Mesh::getBBox(unsigned int which)
 {
-  const unsigned int index = which*3;
-  const Vector &p1 = vertices[vertex_indices[index+0]];
-  const Vector &p2 = vertices[vertex_indices[index+1]];
-  const Vector &p3 = vertices[vertex_indices[index+2]];
+  const Vector &p1 = getVertex(which, 0);
+  const Vector &p2 = getVertex(which, 1);
+  const Vector &p3 = getVertex(which, 2);
   BBox bbox(p1, p1);
   bbox.extendByPoint(p2);
   bbox.extendByPoint(p3);

Modified: trunk/Model/Groups/Mesh.h
==============================================================================
--- trunk/Model/Groups/Mesh.h   (original)
+++ trunk/Model/Groups/Mesh.h   Sun Nov  4 22:26:30 2007
@@ -47,6 +47,7 @@
     // Should we support having both face_normals and vertex_normals?
 
     Mesh();
+    virtual ~Mesh(){}
 
     virtual Mesh* clone(CloneDepth depth, Clonable* incoming=NULL);
 
@@ -69,15 +70,19 @@
     MeshTriangle* get( size_t i );
     const MeshTriangle* get( size_t i ) const;
 
+    virtual inline Vector getVertex( size_t tri_id, size_t which_vert, Real 
t = 0 ) const {
+      return vertices[vertex_indices[3*tri_id + which_vert]];
+    }
+
     //this only adds the triangle to the group. You still need to add
     //the vertices, materials, etc. to the mesh.
     void addTriangle(MeshTriangle *tri);
 
-    void computeBounds(const PreprocessContext& context, int proc, int 
numProcs) const;
+    virtual void computeBounds(const PreprocessContext& context, int proc, 
int numProcs) const;
 
     // You can't get access to the actual primitive, because it may not
     // actually exist.  You can get the bounds of it, though.
-    BBox getBBox(unsigned int which);
+    virtual BBox getBBox(unsigned int which);
 
     virtual void preprocess(const PreprocessContext& context);
 

Added: trunk/Model/Groups/MovingMesh.cc
==============================================================================
--- (empty file)
+++ trunk/Model/Groups/MovingMesh.cc    Sun Nov  4 22:26:30 2007
@@ -0,0 +1,46 @@
+#include <Model/Groups/MovingMesh.h>
+#include <Core/Util/Preprocessor.h>
+#include <Core/Util/UpdateGraph.h>
+#include <SCIRun/Core/Exceptions/InternalError.h>
+#include <Interface/MeshTriangle.h>
+
+using namespace Manta;
+
+MovingMesh::MovingMesh(Mesh* frame0, Mesh* frame1) :
+  Mesh(),
+  frame0(frame0),
+  frame1(frame1) {
+  vertices = frame0->vertices;
+  vertexNormals = frame0->vertexNormals;
+  texCoords = frame0->texCoords;
+  materials = frame0->materials;
+  vertex_indices = frame0->vertex_indices;
+  normal_indices = frame0->normal_indices;
+  texture_indices = frame0->texture_indices;
+  face_material = frame0->face_material;
+
+  objs = frame0->getVectorOfObjects();
+  for (size_t i = 0; i < objs.size(); i++) {
+    ((MeshTriangle*)objs[i])->attachMesh(this);
+  }
+}
+
+void MovingMesh::computeBounds(const PreprocessContext& context,
+                               int proc, int numProcs) const
+{
+  if (proc == 0) {
+    this->bbox.reset();
+  }
+
+  frame0->computeBounds(context, proc, numProcs);
+  frame1->computeBounds(context, proc, numProcs);
+
+  if (proc == 0) {
+    dirtybbox = false;
+    ((Group*)frame0)->computeBounds(context, bbox);
+    ((Group*)frame1)->computeBounds(context, bbox);
+  }
+
+  //Need to wait for other threads to finish computing bbox
+  barrier.wait(numProcs);
+}

Copied: trunk/Model/Groups/MovingMesh.h (from r1808, 
trunk/Model/Groups/Mesh.h)
==============================================================================
--- trunk/Model/Groups/Mesh.h   (original)
+++ trunk/Model/Groups/MovingMesh.h     Sun Nov  4 22:26:30 2007
@@ -1,5 +1,5 @@
-#ifndef Manta_Model_Groups_Mesh_h
-#define Manta_Model_Groups_Mesh_h
+#ifndef Manta_Model_Groups_MovingMesh_h
+#define Manta_Model_Groups_MovingMesh_h
 
 #include <Core/Geometry/Vector.h>
 #include <Core/Thread/Barrier.h>
@@ -9,83 +9,34 @@
 #include <Interface/RayPacket.h>
 #include <Interface/TexCoordMapper.h>
 #include <Model/Groups/Group.h>
-
+#include <Model/Groups/Mesh.h>
 #include <vector>
 
 namespace Manta
 {
   class MeshTriangle;
   using namespace std;
-  class Mesh : public Group {
+  class MovingMesh : public Mesh {
   public:
+    MovingMesh(Mesh* frame0, Mesh* frame1);
+    virtual ~MovingMesh(){}
 
-    // If a triangle has a vertex without texture coordinates, this
-    // will be its index into the texture_indices array.
-    static const unsigned int kNoTextureIndex;
-
-    vector<Vector> vertices;
-    vector<Vector> vertexNormals;
-    vector<Vector> texCoords;
-//     vector<Vector> faceNormals; //not handled for now
-    vector<Material*> materials;
-
-    //Note: We might want to templatize the indices in case we end up
-    //having lots of meshes with small (less than a short) numbers of
-    //vertices. Most likely though is that we have just one or two
-    //meshes total, so the space savings is minimal and we can just
-    //avoid template ugliness.
-
-    // Per vertex data.  size() == 3*numTriangles;
-    vector<unsigned int> vertex_indices;
-    vector<unsigned int> normal_indices;
-    vector<unsigned int> texture_indices;
-
-    // Per face data.  size() == numTriangles;
-    //vector<unsigned int> face_normals; //not handled for now.
-    vector<unsigned int> face_material;
-
-    // Should we support having both face_normals and vertex_normals?
-
-    Mesh();
-
-    virtual Mesh* clone(CloneDepth depth, Clonable* incoming=NULL);
-
-    virtual InterpErr serialInterpolate(const std::vector<keyframe_t> 
&keyframes);
-    virtual InterpErr parallelInterpolate(const std::vector<keyframe_t> 
&keyframes,
-                                           int proc, int numProc);
-    virtual bool isParallel() const { return true; }
-
-    bool hasVertexNormals() const { return !normal_indices.empty(); }
-    void discardVertexNormals() {
-      normal_indices.clear();
-      vertexNormals.clear();
+    virtual inline Vector getVertex( size_t tri_id, size_t which_vert, Real 
t ) const {
+      return ((1-t)*frame0->getVertex(tri_id, which_vert) +
+                 t *frame1->getVertex(tri_id, which_vert));
     }
-    void interpolateNormals();
-
-    //should not be allowed to use Group's add and set.
-    virtual void add(Object* obj);
-    virtual void set( int i, Object *obj );
-
-    MeshTriangle* get( size_t i );
-    const MeshTriangle* get( size_t i ) const;
-
-    //this only adds the triangle to the group. You still need to add
-    //the vertices, materials, etc. to the mesh.
-    void addTriangle(MeshTriangle *tri);
 
-    void computeBounds(const PreprocessContext& context, int proc, int 
numProcs) const;
+    virtual void computeBounds(const PreprocessContext& context, int proc, 
int numProcs) const;
 
-    // You can't get access to the actual primitive, because it may not
-    // actually exist.  You can get the bounds of it, though.
-    BBox getBBox(unsigned int which);
-
-    virtual void preprocess(const PreprocessContext& context);
-
-    virtual void addToUpdateGraph(ObjectUpdateGraph* graph,
-                                  ObjectUpdateGraphNode* parent);
+    virtual BBox getBBox(unsigned int which) {
+      BBox bbox;
+      bbox.extendByBox(frame0->getBBox(which));
+      bbox.extendByBox(frame1->getBBox(which));
+      return bbox;
+    }
 
-    //removes degenerate triangles from mesh.
-    void removeDegenerateTriangles();
+    Mesh* frame0;
+    Mesh* frame1;
   };
 }
 

Modified: trunk/Model/Groups/ObjGroup.cc
==============================================================================
--- trunk/Model/Groups/ObjGroup.cc      (original)
+++ trunk/Model/Groups/ObjGroup.cc      Sun Nov  4 22:26:30 2007
@@ -3,6 +3,7 @@
 #include <Interface/Texture.h>
 #include <Core/Color/Color.h>
 #include <Core/Color/ColorSpace.h>
+#include <SCIRun/Core/Exceptions/InternalError.h>
 #include <Model/Groups/ObjGroup.h>
 #include <Model/Textures/Constant.h>
 #include <Model/Textures/ImageTexture.h>
@@ -13,6 +14,7 @@
 #include <Model/Materials/Flat.h>
 #include <Model/Primitives/WaldTriangle.h>
 #include <Model/Primitives/KenslerShirleyTriangle.h>
+#include <Model/Primitives/MovingKSTriangle.h>
 
 #include <iostream>
 #include <map>
@@ -205,7 +207,7 @@
 
   WaldTriangle *wald_triangles = NULL;
   KenslerShirleyTriangle *KS_triangles = NULL;
-
+  MovingKSTriangle* MovingKS_triangles = NULL;
   switch (triangleType) {
   case MeshTriangle::WALD_TRI:
     wald_triangles = new WaldTriangle[model->numtriangles];
@@ -213,6 +215,12 @@
   case MeshTriangle::KENSLER_SHIRLEY_TRI:
     KS_triangles = new KenslerShirleyTriangle[model->numtriangles];
     break;
+  case MeshTriangle::MOVING_KS_TRI:
+    MovingKS_triangles = new MovingKSTriangle[model->numtriangles];
+    break;
+  default:
+    throw SCIRun::InternalError("Invalid triangle type", __FILE__, __LINE__);
+    break;
   }
 
   // Read in the groups.
@@ -281,6 +289,9 @@
         break;
       case MeshTriangle::KENSLER_SHIRLEY_TRI:
         addTriangle(&KS_triangles[objs.size()]);
+        break;
+      case MeshTriangle::MOVING_KS_TRI:
+        addTriangle(&MovingKS_triangles[objs.size()]);
         break;
       }
     }

Modified: trunk/Model/MiscObjects/KeyFrameAnimation.cc
==============================================================================
--- trunk/Model/MiscObjects/KeyFrameAnimation.cc        (original)
+++ trunk/Model/MiscObjects/KeyFrameAnimation.cc        Sun Nov  4 22:26:30 
2007
@@ -195,13 +195,14 @@
     return true;
 }
 
-void KeyFrameAnimation::temporaryUpdate(int proc, int numProcs, bool &)
+void KeyFrameAnimation::temporaryUpdate(int proc, int numProcs, bool 
&changed)
 {
   Temp_Callback context;
   context.proc = proc;
   context.numProcs = numProcs;
   context.time = SCIRun::Time::currentSeconds();
   update(context);
+  changed = differentFrame;
 }
 
 void KeyFrameAnimation::intersect(const RenderContext& context, RayPacket& 
rays) const

Modified: trunk/Model/Primitives/CMakeLists.txt
==============================================================================
--- trunk/Model/Primitives/CMakeLists.txt       (original)
+++ trunk/Model/Primitives/CMakeLists.txt       Sun Nov  4 22:26:30 2007
@@ -22,6 +22,8 @@
      Primitives/IsosurfaceOctreeVolume.h
      Primitives/KenslerShirleyTriangle.h
      Primitives/KenslerShirleyTriangle.cc
+     Primitives/MovingKSTriangle.h
+     Primitives/MovingKSTriangle.cc
      Primitives/Parallelogram.cc
      Primitives/Parallelogram.h
      Primitives/Plane.cc

Modified: trunk/Model/Primitives/KenslerShirleyTriangle.cc
==============================================================================
--- trunk/Model/Primitives/KenslerShirleyTriangle.cc    (original)
+++ trunk/Model/Primitives/KenslerShirleyTriangle.cc    Sun Nov  4 22:26:30 
2007
@@ -107,10 +107,9 @@
 
   const sse_t eps4 = set4( T_EPSILON );
 
-  const unsigned int index = myID*3;
-  const Vector p0 = mesh->vertices[mesh->vertex_indices[index+0]];
-  const Vector p1 = mesh->vertices[mesh->vertex_indices[index+1]];
-  const Vector p2 = mesh->vertices[mesh->vertex_indices[index+2]];
+  const Vector p0 = mesh->getVertex(myID, 0);
+  const Vector p1 = mesh->getVertex(myID, 1);
+  const Vector p2 = mesh->getVertex(myID, 2);
 
   const sse_t p1x = set4( p1[ 0 ] );
   const sse_t p1y = set4( p1[ 1 ] );

Copied: trunk/Model/Primitives/MovingKSTriangle.cc (from r1808, 
trunk/Model/Primitives/KenslerShirleyTriangle.cc)
==============================================================================
--- trunk/Model/Primitives/KenslerShirleyTriangle.cc    (original)
+++ trunk/Model/Primitives/MovingKSTriangle.cc  Sun Nov  4 22:26:30 2007
@@ -1,4 +1,4 @@
-#include <Model/Primitives/KenslerShirleyTriangle.h>
+#include <Model/Primitives/MovingKSTriangle.h>
 #include <Interface/Context.h>
 #include <Interface/RayPacket.h>
 #include <Core/Geometry/BBox.h>
@@ -11,18 +11,18 @@
 using namespace Manta;
 using namespace std;
 
-KenslerShirleyTriangle::KenslerShirleyTriangle(Mesh *mesh, unsigned int id):
+MovingKSTriangle::MovingKSTriangle(Mesh *mesh, unsigned int id):
   MeshTriangle(mesh, id)
 {
 }
 
-KenslerShirleyTriangle* KenslerShirleyTriangle::clone(CloneDepth depth, 
Clonable* incoming)
+MovingKSTriangle* MovingKSTriangle::clone(CloneDepth depth, Clonable* 
incoming)
 {
-  KenslerShirleyTriangle *copy;
+  MovingKSTriangle *copy;
   if (incoming)
-    copy = dynamic_cast<KenslerShirleyTriangle*>(incoming);
+    copy = dynamic_cast<MovingKSTriangle*>(incoming);
   else
-    return new KenslerShirleyTriangle(mesh, myID);
+    return new MovingKSTriangle(mesh, myID);
 
   copy->myID = myID;
   copy->mesh = mesh;
@@ -30,13 +30,13 @@
   return copy;
 }
 
-Interpolable::InterpErr KenslerShirleyTriangle::serialInterpolate(const 
std::vector<keyframe_t> &keyframes)
+Interpolable::InterpErr MovingKSTriangle::serialInterpolate(const 
std::vector<keyframe_t> &keyframes)
 {
   //We assume that the mesh has already been interpolated.
   return success;
 }
 
-void KenslerShirleyTriangle::preprocess(const PreprocessContext& context)
+void MovingKSTriangle::preprocess(const PreprocessContext& context)
 {
   if (context.proc != 0) { context.done(); return; }
   //TODO: this materials->preprocess might end up getting called lots
@@ -48,7 +48,7 @@
   context.done();
 }
 
-void KenslerShirleyTriangle::computeTexCoords2(const RenderContext&, 
RayPacket& rays) const
+void MovingKSTriangle::computeTexCoords2(const RenderContext&, RayPacket& 
rays) const
 {
   const int which = myID*3;
 
@@ -97,7 +97,7 @@
     zout = sub4(mul4(x1, y2), mul4(y1, x2));             \
   }
 
-void KenslerShirleyTriangle::intersect( const RenderContext& context, 
RayPacket& rays ) const {
+void MovingKSTriangle::intersect( const RenderContext& context, RayPacket& 
rays ) const {
 
   RayPacketData *data = rays.data;
   const int ray_begin = rays.begin();
@@ -107,35 +107,43 @@
 
   const sse_t eps4 = set4( T_EPSILON );
 
-  const unsigned int index = myID*3;
-  const Vector p0 = mesh->vertices[mesh->vertex_indices[index+0]];
-  const Vector p1 = mesh->vertices[mesh->vertex_indices[index+1]];
-  const Vector p2 = mesh->vertices[mesh->vertex_indices[index+2]];
-
-  const sse_t p1x = set4( p1[ 0 ] );
-  const sse_t p1y = set4( p1[ 1 ] );
-  const sse_t p1z = set4( p1[ 2 ] );
-
-  const sse_t p0x = set4( p0[ 0 ] );
-  const sse_t p0y = set4( p0[ 1 ] );
-  const sse_t p0z = set4( p0[ 2 ] );
-
-  const sse_t edge0x = sub4( p1x, p0x );
-  const sse_t edge0y = sub4( p1y, p0y );
-  const sse_t edge0z = sub4( p1z, p0z );
-
-  const sse_t p2x = set4( p2[ 0 ] );
-  const sse_t p2y = set4( p2[ 1 ] );
-  const sse_t p2z = set4( p2[ 2 ] );
-
-  const sse_t edge1x = sub4( p0x, p2x );
-  const sse_t edge1y = sub4( p0y, p2y );
-  const sse_t edge1z = sub4( p0z, p2z );
+  for ( int ray = sse_begin; ray < sse_end; ray += 4 ) {
 
-  sse_t normalx, normaly, normalz;
-  cross4( normalx, normaly, normalz, edge0x, edge0y, edge0z, edge1x, edge1y, 
edge1z );
+    Vector p0_vec[4];
+    Vector p1_vec[4];
+    Vector p2_vec[4];
+    for (int i = 0; i < 4; i++) {
+      const Vector p0 = mesh->getVertex(myID, 0, rays.getTime(ray + i));
+      const Vector p1 = mesh->getVertex(myID, 1, rays.getTime(ray + i));
+      const Vector p2 = mesh->getVertex(myID, 2, rays.getTime(ray + i));
+      p0_vec[i] = p0;
+      p1_vec[i] = p1;
+      p2_vec[i] = p2;
+    }
 
-  for ( int ray = sse_begin; ray < sse_end; ray += 4 ) {
+    const sse_t p1x = set44( p1_vec[0][0], p1_vec[1][0], p1_vec[2][0], 
p1_vec[3][0] );
+    const sse_t p1y = set44( p1_vec[0][1], p1_vec[1][1], p1_vec[2][1], 
p1_vec[3][1] );
+    const sse_t p1z = set44( p1_vec[0][2], p1_vec[0][2], p1_vec[0][2], 
p1_vec[3][2] );
+
+    const sse_t p0x = set44( p0_vec[0][0], p0_vec[1][0], p0_vec[2][0], 
p0_vec[3][0] );
+    const sse_t p0y = set44( p0_vec[0][1], p0_vec[1][1], p0_vec[2][1], 
p0_vec[3][1] );
+    const sse_t p0z = set44( p0_vec[0][2], p0_vec[0][2], p0_vec[0][2], 
p0_vec[3][2] );
+
+    const sse_t edge0x = sub4( p1x, p0x );
+    const sse_t edge0y = sub4( p1y, p0y );
+    const sse_t edge0z = sub4( p1z, p0z );
+
+    const sse_t p2x = set44( p2_vec[0][0], p2_vec[1][0], p2_vec[2][0], 
p2_vec[3][0] );
+    const sse_t p2y = set44( p2_vec[0][1], p2_vec[1][1], p2_vec[2][1], 
p2_vec[3][1] );
+    const sse_t p2z = set44( p2_vec[0][2], p2_vec[0][2], p2_vec[0][2], 
p2_vec[3][2] );
+
+
+    const sse_t edge1x = sub4( p0x, p2x );
+    const sse_t edge1y = sub4( p0y, p2y );
+    const sse_t edge1z = sub4( p0z, p2z );
+
+    sse_t normalx, normaly, normalz;
+    cross4( normalx, normaly, normalz, edge0x, edge0y, edge0z, edge1x, 
edge1y, edge1z );
 
     const sse_t ox = load44( &data->origin[ 0 ][ ray ] );
     const sse_t oy = load44( &data->origin[ 1 ][ ray ] );
@@ -195,10 +203,15 @@
 
   if ( ray_begin < sse_begin || ray_end > sse_end )
   {
-    const Vector edge0 = p1 - p0;
-    const Vector edge1 = p0 - p2;
-    const Vector normal = Cross( edge0, edge1 );
     for ( int ray = ray_begin; ray < sse_begin; ++ray ) {
+      const Vector p0 = mesh->getVertex(myID, 0, rays.getTime(ray));
+      const Vector p1 = mesh->getVertex(myID, 1, rays.getTime(ray));
+      const Vector p2 = mesh->getVertex(myID, 2, rays.getTime(ray));
+
+      const Vector edge0 = p1 - p0;
+      const Vector edge1 = p0 - p2;
+      const Vector normal = Cross( edge0, edge1 );
+
       const Vector o = Vector( data->origin[ 0 ][ ray ],
                                data->origin[ 1 ][ ray ],
                                data->origin[ 2 ][ ray ] );
@@ -227,6 +240,14 @@
       }
     }
     for ( int ray = sse_end; ray < ray_end; ++ray ) {
+      const Vector p0 = mesh->getVertex(myID, 0, rays.getTime(ray));
+      const Vector p1 = mesh->getVertex(myID, 1, rays.getTime(ray));
+      const Vector p2 = mesh->getVertex(myID, 2, rays.getTime(ray));
+
+      const Vector edge0 = p1 - p0;
+      const Vector edge1 = p0 - p2;
+      const Vector normal = Cross( edge0, edge1 );
+
       const Vector o = Vector( data->origin[ 0 ][ ray ],
                                data->origin[ 1 ][ ray ],
                                data->origin[ 2 ][ ray ] );
@@ -260,20 +281,20 @@
 
 #else // MANTA_SSE
 
-void KenslerShirleyTriangle::intersect( const RenderContext& context, 
RayPacket& rays ) const {
+void MovingKSTriangle::intersect( const RenderContext& context, RayPacket& 
rays ) const {
   RayPacketData *data = rays.data;
   const int ray_begin = rays.begin();
   const int ray_end   = rays.end();
 
-  const unsigned int index = myID*3;
-  const Vector p0 = mesh->vertices[mesh->vertex_indices[index+0]];
-  const Vector p1 = mesh->vertices[mesh->vertex_indices[index+1]];
-  const Vector p2 = mesh->vertices[mesh->vertex_indices[index+2]];
-
-  const Vector edge0 = p1 - p0;
-  const Vector edge1 = p0 - p2;
-  const Vector normal = Cross( edge0, edge1 );
   for ( int ray = ray_begin; ray < ray_end; ++ray ) {
+    const Vector p0 = mesh->getVertex(myID, 0, rays.getTime(ray));
+    const Vector p1 = mesh->getVertex(myID, 1, rays.getTime(ray));
+    const Vector p2 = mesh->getVertex(myID, 2, rays.getTime(ray));
+
+    const Vector edge0 = p1 - p0;
+    const Vector edge1 = p0 - p2;
+    const Vector normal = Cross( edge0, edge1 );
+
     const Vector o = Vector( data->origin[ 0 ][ ray ],
                              data->origin[ 1 ][ ray ],
                              data->origin[ 2 ][ ray ] );
@@ -305,7 +326,7 @@
 
 #endif // MANTA_SSE
 
-void KenslerShirleyTriangle::computeNormal(const RenderContext& context, 
RayPacket &rays) const
+void MovingKSTriangle::computeNormal(const RenderContext& context, RayPacket 
&rays) const
 {
   if (mesh->hasVertexNormals()) {
     for(int ray=rays.begin(); ray<rays.end(); ray++) {
@@ -319,15 +340,15 @@
       rays.setNormal(ray, normal);
     }
   } else {
-    const unsigned int index = myID*3;
-    const Vector p0 = mesh->vertices[mesh->vertex_indices[index+0]];
-    const Vector p1 = mesh->vertices[mesh->vertex_indices[index+1]];
-    const Vector p2 = mesh->vertices[mesh->vertex_indices[index+2]];
-
-    const Vector edge0 = p1 - p0;
-    const Vector edge1 = p2 - p0;
-    const Vector normal = Cross(edge0, edge1);
-    for(int ray=rays.begin(); ray<rays.end(); ray++)
+    for(int ray=rays.begin(); ray<rays.end(); ray++) {
+      const Vector p0 = mesh->getVertex(myID, 0, rays.getTime(ray));
+      const Vector p1 = mesh->getVertex(myID, 1, rays.getTime(ray));
+      const Vector p2 = mesh->getVertex(myID, 2, rays.getTime(ray));
+
+      const Vector edge0 = p1 - p0;
+      const Vector edge1 = p2 - p0;
+      const Vector normal = Cross(edge0, edge1);
       rays.setNormal(ray, normal);
+    }
   }
 }

Copied: trunk/Model/Primitives/MovingKSTriangle.h (from r1808, 
trunk/Model/Primitives/KenslerShirleyTriangle.h)
==============================================================================
--- trunk/Model/Primitives/KenslerShirleyTriangle.h     (original)
+++ trunk/Model/Primitives/MovingKSTriangle.h   Sun Nov  4 22:26:30 2007
@@ -1,5 +1,5 @@
-#ifndef Manta_Model_KenslerShirleyTriangle_h
-#define Manta_Model_KenslerShirleyTriangle_h
+#ifndef Manta_Model_MovingKSTriangle_h
+#define Manta_Model_MovingKSTriangle_h
 
 #include <Interface/MeshTriangle.h>
 #include <Interface/RayPacket.h>
@@ -10,7 +10,7 @@
 
 namespace Manta
 {
-  class KenslerShirleyTriangle : public MeshTriangle, public TexCoordMapper
+  class MovingKSTriangle : public MeshTriangle, public TexCoordMapper
   {
   public:
 
@@ -22,10 +22,10 @@
                    // avoid conflicts.
     };
 
-    KenslerShirleyTriangle() { }
-    KenslerShirleyTriangle(Mesh *mesh, unsigned int id);
+    MovingKSTriangle() { }
+    MovingKSTriangle(Mesh *mesh, unsigned int id);
 
-    virtual KenslerShirleyTriangle* clone(CloneDepth depth, Clonable* 
incoming=NULL);
+    virtual MovingKSTriangle* clone(CloneDepth depth, Clonable* 
incoming=NULL);
     virtual InterpErr serialInterpolate(const std::vector<keyframe_t> 
&keyframes);
 
     virtual void preprocess(const PreprocessContext& context);

Modified: trunk/Model/Textures/ImageTexture.cc
==============================================================================
--- trunk/Model/Textures/ImageTexture.cc        (original)
+++ trunk/Model/Textures/ImageTexture.cc        Sun Nov  4 22:26:30 2007
@@ -62,7 +62,7 @@
     bool isRGBE = ( (file_name.rfind(".hdr") == (file_name.size() - 4) ||
                      file_name.rfind(".pic") == (file_name.size() - 4) ||
                      file_name.rfind(".rgbe") == (file_name.size() - 5)));
-   
+
 
     if (isNrrd) {
       // Check to see if it is a nrrd before trying to read with
@@ -74,7 +74,8 @@
       image = readRGBE(file_name);
       if (stream) (*stream) << "Read by readRGBE\n";
     } else if ( isEXRImage( file_name ) && EXRSupported() ) {
-          image = readEXR( file_name );
+      image = readEXR(file_name);
+      if (stream) (*stream) << "Read by readEXR\n";
     } else if (ImageMagickSupported()) {
       image = readImageMagick( file_name );
       if (stream) (*stream) << "Read by readImageMagick\n";

---

• [Manta] r1813 - in trunk: Interface Model/Groups Model/MiscObjects Model/Primitives Model/Textures, boulos, 11/05/2007

---

Archive powered by MHonArc 2.6.16.