Text archives Help

---

Author: boulos
Date: Tue Aug 21 12:06:36 2007
New Revision: 1676

Modified:
   trunk/Model/Instances/Instance.cc
   trunk/Model/Instances/MPT.h
Log:
Model/Instances/Instance.cc
Model/Instances/MPT.h

 Fixing instances by forcing computation of shading data.  Also adding
 a new struct to MPT called InstanceShadingData (how original)


Modified: trunk/Model/Instances/Instance.cc
==============================================================================
--- trunk/Model/Instances/Instance.cc   (original)
+++ trunk/Model/Instances/Instance.cc   Tue Aug 21 12:06:36 2007
@@ -31,6 +31,7 @@
 #include <Interface/Context.h>
 #include <Interface/RayPacket.h>
 #include <Core/Exceptions/BadPrimitive.h>
+#include <Core/Exceptions/InternalError.h>
 #include <Core/Geometry/BBox.h>
 #include <Core/Math/MiscMath.h>
 #include <Core/Util/Preprocessor.h>
@@ -90,17 +91,23 @@
   }
   RayPacketData raydata;
   RayPacket instance_rays(raydata, RayPacket::UnknownShape, rays.begin(), 
rays.end(),
-                          rays.getDepth(), rays.getAllFlags());
+                          rays.getDepth(), 0);
   // TODO(boulos): Make this a lot cleaner and try to easily maintain
   // ray packet properties (probably best to just do so in specialized
   // instance classes though)
 
-  // We don't know if we have a constant scale
-  instance_rays.resetFlag(RayPacket::NormalizedDirections |
-                          RayPacket::HaveInverseDirections |
-                          RayPacket::HaveSigns |
-                          RayPacket::ConstantSigns |
-                          RayPacket::HaveCornerRays);
+
+  // We setup the instance_rays to be normalized (makes it so we don't
+  // need to worry about someone calling normalize directions for us
+  // underneath us and then requiring a scaling on the end).
+  //
+  // Since we're an affine transform, the constant origin property
+  // should be transferred as well.
+  //
+  // Finally, if the parent is a debug packet, we should be too.
+  instance_rays.setFlag(
+    RayPacket::NormalizedDirections &
+    (rays.getAllFlags() & (RayPacket::ConstantOrigin | 
RayPacket::DebugPacket)));
 
   Real scales[RayPacket::MaxSize];
   Real inv_scales[RayPacket::MaxSize];
@@ -140,143 +147,71 @@
   }
 
   instance->intersect(context, instance_rays);
-  for(int i=rays.begin();i<rays.end();i++){
+  for(int i=instance_rays.begin();i<instance_rays.end();i++){
     if(instance_rays.wasHit(i)){
-      // Instance was hit
-      Real s = scales[i];
-      if(rays.hit(i, instance_rays.getMinT(i)*s, material, this, tex)){
-        // Instance is now the closest
-        rays.scratchpad<MPTscale>(i) = 
MPTscale(instance_rays.getHitMaterial(i),
-                                                
instance_rays.getHitPrimitive(i),
-                                                
instance_rays.getHitTexCoordMapper(i),
-                                                s, inv_scales[i]);
+      int end = i+1;
+      // NOTE(boulos): We are almost guaranteed to hit the underlying
+      // primitive if we hit the instance due to the way we setup the
+      // instance minT value. (numerical errors might get us, but
+      // that's a small chance)
+      while (end < instance_rays.end() && instance_rays.wasHit(end))
+        end++;
+      // Compute a group of normals and texcoords
+      RayPacket sub_packet(instance_rays, i, end);
+      sub_packet.computeNormals(context);
+      // NOTE(boulos): Once the texcoords are separated, there will be
+      // another call to texcoords 3 here
+      sub_packet.computeTextureCoordinates2(context);
+
+      for (int j = i; j < end; j++) {
+        Real s = scales[j];
+        if(rays.hit(j,
+                    instance_rays.getMinT(j)*s,
+                    instance_rays.getHitMaterial(j),
+                    this,
+                    this)) {
+          // NOTE(boulos): We're deferring the normal transform until
+          // requested
+          rays.scratchpad<InstanceShadingData>(j) =
+            InstanceShadingData(sub_packet.getNormal(j),
+                                sub_packet.getTexCoords2(j));
+        }
       }
+      i = end;
     }
   }
 }
 
 void Instance::computeNormal(const RenderContext& context, RayPacket& rays) 
const
 {
-  Real old_minT[RayPacket::MaxSize];
-  Ray old_rays[RayPacket::MaxSize];
-
-  // Save the original rays
-  for(int i=rays.begin();i<rays.end();i++){
-    old_rays[i] = rays.getRay(i);
-
-    Vector o = transform_inv.multiply_point(old_rays[i].origin());
-    Vector dir = transform_inv.multiply_vector(old_rays[i].direction());
-
-    Real scale = rays.scratchpad<MPTscale>(i).scale;
-    rays.setRay(i, o, dir*scale);
-    old_minT[i] = rays.getMinT(i);
-    Real inv_scale = rays.scratchpad<MPTscale>(i).inv_scale;
-    rays.scaleMinT(i, inv_scale);
-  }
-  rays.resetFlag(RayPacket::HaveHitPositions);
-
-  // Try to create a ray packet that all use the same child primitive
-  // to compute normals.
-  for(int i=rays.begin();i<rays.end();){
-    const Primitive* prim = rays.scratchpad<MPT>(i).primitive;
-    int end = i+1;
-    while(end < rays.end() && rays.scratchpad<MPT>(end).primitive == prim)
-      end++;
-    RayPacket subPacket(rays, i, end);
-    prim->computeNormal(context, subPacket);
-    i = end;
-  }
-
-  // Put the rays and minT back, scale normal
-  for(int i=rays.begin();i<rays.end();i++){
-    rays.setRay(i, old_rays[i]);
-    rays.overrideMinT(i, old_minT[i]);
-
-    rays.setNormal(i, 
transform_inv.transpose_mult_vector(rays.getNormal(i)));
+  for (int i = rays.begin(); i < rays.end(); i++) {
+    rays.setNormal(i, transform_inv.transpose_mult_vector(
+                     rays.scratchpad<InstanceShadingData>(i).normal));
   }
-  rays.resetFlag(RayPacket::HaveHitPositions);
+  rays.setFlag(RayPacket::HaveNormals);
 }
 
 void Instance::setTexCoordMapper(const TexCoordMapper* new_tex)
 {
-  tex = new_tex;
+  string me(MANTA_FUNC);
+  throw SCIRun::InternalError(me + " shouldn't be called", __FILE__, 
__LINE__);
 }
 
 void Instance::computeTexCoords2(const RenderContext& context,
                                RayPacket& rays) const
 {
-  Real old_minT[RayPacket::MaxSize];
-  Ray old_rays[RayPacket::MaxSize];
-
-  // Save the original rays
-  for(int i=rays.begin();i<rays.end();i++){
-    old_rays[i] = rays.getRay(i);
-
-    Vector o = transform_inv.multiply_point(old_rays[i].origin());
-    Vector dir = transform_inv.multiply_vector(old_rays[i].direction());
-
-    Real scale = rays.scratchpad<MPTscale>(i).scale;
-    rays.setRay(i, o, dir*scale);
-    old_minT[i] = rays.getMinT(i);
-    Real inv_scale = rays.scratchpad<MPTscale>(i).inv_scale;
-    rays.scaleMinT(i, inv_scale);
-  }
-  rays.resetFlag(RayPacket::HaveHitPositions);
-
-  for(int i=rays.begin();i<rays.end();){
-    const TexCoordMapper* tex = rays.scratchpad<MPT>(i).tex;
-    int end = i+1;
-    while(end < rays.end() && rays.scratchpad<MPT>(end).tex == tex)
-      end++;
-    RayPacket subPacket(rays, i, end);
-    tex->computeTexCoords2(context, subPacket);
-    i = end;
-  }
-
-  // Put the rays and minT back
-  for(int i=rays.begin();i<rays.end();i++){
-    rays.setRay(i, old_rays[i]);
-    rays.overrideMinT(i, old_minT[i]);
+  for (int i = rays.begin(); i < rays.end(); i++) {
+    rays.setTexCoords(i, rays.scratchpad<InstanceShadingData>(i).texcoord2);
   }
-  rays.resetFlag(RayPacket::HaveHitPositions);
+  rays.setFlag(RayPacket::HaveTexture2);
 }
 
 void Instance::computeTexCoords3(const RenderContext& context,
-                               RayPacket& rays) const
+                                 RayPacket& rays) const
 {
-  Real old_minT[RayPacket::MaxSize];
-  Ray old_rays[RayPacket::MaxSize];
-
-  // Save the original rays
-  for(int i=rays.begin();i<rays.end();i++){
-    old_rays[i] = rays.getRay(i);
-
-    Vector o = transform_inv.multiply_point(old_rays[i].origin());
-    Vector dir = transform_inv.multiply_vector(old_rays[i].direction());
-
-    Real scale = rays.scratchpad<MPTscale>(i).scale;
-    rays.setRay(i, o, dir*scale);
-    old_minT[i] = rays.getMinT(i);
-    Real inv_scale = rays.scratchpad<MPTscale>(i).inv_scale;
-    rays.scaleMinT(i, inv_scale);
-  }
-  rays.resetFlag(RayPacket::HaveHitPositions);
-
-  for(int i=rays.begin();i<rays.end();){
-    const TexCoordMapper* tex = rays.scratchpad<MPT>(i).tex;
-    int end = i+1;
-    while(end < rays.end() && rays.scratchpad<MPT>(end).tex == tex)
-      end++;
-    RayPacket subPacket(rays, i, end);
-    tex->computeTexCoords3(context, subPacket);
-    i = end;
-  }
-
-  // Put the rays and minT back, scale normal
-  for(int i=rays.begin();i<rays.end();i++){
-    rays.setRay(i, old_rays[i]);
-    rays.overrideMinT(i, old_minT[i]);
+  for (int i = rays.begin(); i < rays.end(); i++) {
+    rays.setTexCoords(i, Vector(0,0,0));
   }
-  rays.resetFlag(RayPacket::HaveHitPositions);
+  rays.setFlag(RayPacket::HaveTexture3);
 }
 

Modified: trunk/Model/Instances/MPT.h
==============================================================================
--- trunk/Model/Instances/MPT.h (original)
+++ trunk/Model/Instances/MPT.h Tue Aug 21 12:06:36 2007
@@ -7,24 +7,26 @@
  * more general spot
  */
 #include <MantaTypes.h>
+#include <Core/Geometry/Vector.h>
+#include <Core/Geometry/VectorT.h>
 
 namespace Manta {
   class Material;
   class Primitive;
   class TexCoordMapper;
-       
+
   // Convenience struct to hold a material, primitive and texcoordmapper
   struct MPT {
     const Material* material;
     const Primitive* primitive;
     const TexCoordMapper* tex;
     MPT(const Material* material, const Primitive* primitive,
-                               const TexCoordMapper* tex)
+                                const TexCoordMapper* tex)
       : material(material), primitive(primitive), tex(tex)
     {
     }
   };
-       
+
   // Convenience struct to hold a material, primitive and texcoordmapper
   // and a scale/inverse scale
   struct MPTscale {
@@ -34,12 +36,28 @@
     Real scale;
     Real inv_scale;
     MPTscale(const Material* material, const Primitive* primitive,
-                                                const TexCoordMapper* tex, 
Real scale, Real inv_scale)
+                                                 const TexCoordMapper* tex, 
Real scale, Real inv_scale)
       : material(material), primitive(primitive), tex(tex),
-                       scale(scale), inv_scale(inv_scale)
+                        scale(scale), inv_scale(inv_scale)
     {
     }
   };
+
+  // Convenience struct to hold normal, texcoord, etc to avoid
+  // stomping useful data in the scratchpad.
+  struct InstanceShadingData {
+    Vector normal;
+    VectorT<Real, 2> texcoord2;
+    // NOTE(boulos): When we update texture coordinates to be
+    // separated add this one too.
+    //
+    //Vector texcoord3;
+
+    InstanceShadingData(const Vector& normal,
+                        const VectorT<Real, 2>& tex2)
+      : normal(normal), texcoord2(tex2) {
+    }
+  };
 }
-       
+
 #endif

---

• [Manta] r1676 - trunk/Model/Instances, boulos, 08/21/2007

---

Archive powered by MHonArc 2.6.16.