Text archives Help

---

Author: knolla
Date: Fri May 13 13:00:07 2005
New Revision: 309

Added:
   trunk/Model/Primitives/HeavyTriangle.cc
   trunk/Model/Primitives/HeavyTriangle.h
   trunk/Model/Primitives/TexTriangle.cc
   trunk/Model/Primitives/TexTriangle.h
Modified:
   trunk/Model/Primitives/CMakeLists.txt
   trunk/Model/Primitives/Triangle.cc
   trunk/Model/Primitives/Triangle.h
Log:
Added HeavyTriangle with cached data, and heavier TexTriangle

Modified: trunk/Model/Primitives/CMakeLists.txt
==============================================================================
--- trunk/Model/Primitives/CMakeLists.txt       (original)
+++ trunk/Model/Primitives/CMakeLists.txt       Fri May 13 13:00:07 2005
@@ -7,6 +7,8 @@
      Primitives/Cube.cc
      Primitives/Cone.cc
      Primitives/Triangle.cc
+     Primitives/HeavyTriangle.cc
+     Primitives/TexTriangle.cc
      Primitives/Disk.cc
      Primitives/Hemisphere.cc
 )

Added: trunk/Model/Primitives/HeavyTriangle.cc
==============================================================================
--- (empty file)
+++ trunk/Model/Primitives/HeavyTriangle.cc     Fri May 13 13:00:07 2005
@@ -0,0 +1,78 @@
+#include <Model/Primitives/HeavyTriangle.h>
+#include <Interface/RayPacket.h>
+#include <Core/Geometry/BBox.h>
+#include <sgi_stl_warnings_off.h>
+#include <iostream>
+#include <sgi_stl_warnings_on.h>
+
+using namespace Manta;
+using namespace std;
+
+HeavyTriangle::HeavyTriangle(Material* mat, const Point& _p1, const Point& 
_p2, const Point& _p3)
+  : Triangle(mat, _p1, _p2, _p3)
+{
+  e1 = p2-p1;
+  e2 = p3-p1;
+  n = Cross(e1, e2);
+  n.normalize();
+}
+
+HeavyTriangle::~HeavyTriangle()
+{
+}
+
+void HeavyTriangle::intersect(const RenderContext&, RayPacket& rays) const
+{
+  rays.normalizeDirections();
+
+  for(int i=0; i<rays.getSize(); i++) {
+    RayPacket::Element& e = rays.get(i);
+    const Vector& dir(e.ray.direction());
+    Vector o(p1 - e.ray.origin());
+    
+    double det=Dot(n,dir);
+    if(det>1.e-9 || det < -1.e-9) {
+      double idet = 1./det;
+
+      Vector DX(Cross(dir, o));
+      double A=-Dot(DX, e2)*idet;
+      if(A>0.0 && A<1.0) {
+       double B=Dot(DX, e1)*idet;
+       if(B>0.0 && A+B<1.0) {
+         double t=Dot(n, o)*idet;
+         if (e.hitInfo.hit(t, material, this, tex)){
+             TriangleHit& th = e.hitInfo.scratchpad<TriangleHit>();
+             th.a = A;
+             th.b = B;
+          }
+       }
+      }
+    }
+  }
+}
+
+
+void HeavyTriangle::computeNormal(const RenderContext&, RayPacket& rays) 
const
+{
+  rays.computeHitPositions();
+
+  if (rays.getFlags() & RayPacket::HaveNormals){
+    if (rays.getFlags() & RayPacket::HaveUnitNormals)
+       return;
+
+    int nrays = rays.getSize();
+    for(int i=0; i<nrays; i++){
+       rays.get(i).normal = n;
+    }
+    rays.setFlag(RayPacket::HaveUnitNormals);
+  }
+  else{
+    int nrays = rays.getSize();
+    for(int i=0; i<nrays; i++) {
+      rays.get(i).normal = n;
+    }
+    rays.setFlag(RayPacket::HaveUnitNormals);
+  }
+
+}
+

Added: trunk/Model/Primitives/HeavyTriangle.h
==============================================================================
--- (empty file)
+++ trunk/Model/Primitives/HeavyTriangle.h      Fri May 13 13:00:07 2005
@@ -0,0 +1,22 @@
+
+#ifndef Manta_Model_HeavyTriangle_h
+#define Manta_Model_HeavyTriangle_h
+
+#include <Model/Primitives/Triangle.h>
+
+namespace Manta
+{
+  class HeavyTriangle : public Triangle {
+  public:
+    HeavyTriangle(Material* mat, const Point& _a, const Point& _b, const 
Point& _c);
+    virtual ~HeavyTriangle();
+    
+    virtual void intersect(const RenderContext& context, RayPacket& rays) 
const ;
+    virtual void computeNormal(const RenderContext& context, RayPacket 
&rays) const;    
+    
+  protected:
+    Vector e1,e2,n;
+  };
+}
+
+#endif

Added: trunk/Model/Primitives/TexTriangle.cc
==============================================================================
--- (empty file)
+++ trunk/Model/Primitives/TexTriangle.cc       Fri May 13 13:00:07 2005
@@ -0,0 +1,77 @@
+#include <Model/Primitives/TexTriangle.h>
+#include <Interface/RayPacket.h>
+#include <Core/Geometry/BBox.h>
+#include <sgi_stl_warnings_off.h>
+#include <iostream>
+#include <sgi_stl_warnings_on.h>
+
+using namespace Manta;
+using namespace std;
+
+TexTriangle::TexTriangle(Material* mat, 
+                         const Point& _p1, const Point& _p2, const Point& 
_p3, 
+                         const Vector& _n1, const Vector& _n2, const Vector& 
_n3, 
+                         const Point& _tc1, const Point& _tc2, const Point& 
_tc3)
+  : HeavyTriangle(mat, _p1, _p2, _p3)
+{
+  n1 = _n1;
+  n2 = _n2;
+  n3 = _n3;
+  n1.normalize();
+  n2.normalize();
+  n3.normalize();
+  tc1 = _tc1;
+  tc2 = _tc2;
+  tc3 = _tc3;
+}
+
+TexTriangle::~TexTriangle()
+{
+}
+
+void TexTriangle::computeNormal(const RenderContext&, RayPacket& rays) const
+{
+  int nrays = rays.getSize();
+  for(int i=0; i<nrays; i++) {
+    RayPacket::Element& e = rays.get(i);
+    TriangleHit& th = e.hitInfo.scratchpad<TriangleHit>();
+    double A = th.a;
+    double B = th.b;
+    e.normal = (n1 * A) + (n2 * B) + (n3 * (1.0 - A - B));
+    e.normal.normalize();
+  }
+  rays.setFlag(RayPacket::HaveUnitNormals);
+}
+
+//Performs the exact same operation as computeTexCoords3
+void TexTriangle::computeTexCoords2(const RenderContext& context, RayPacket& 
rays) const
+{
+  int nrays = rays.getSize();
+  for(int i=0; i<nrays; i++) {
+    RayPacket::Element& e = rays.get(i);
+    TriangleHit& th = e.hitInfo.scratchpad<TriangleHit>();
+    double A = th.a;
+    double B = th.b;
+    e.texCoords = tc1.multipliedBy(A);
+    e.texCoords.addTo(tc2.multipliedBy(B));
+    e.texCoords.addTo(tc3.multipliedBy(1.0 - A - B));
+  }
+  rays.setFlag(RayPacket::HaveTexture2|RayPacket::HaveTexture3);
+}
+
+
+void TexTriangle::computeTexCoords3(const RenderContext& context, RayPacket& 
rays) const
+{
+  int nrays = rays.getSize();
+  for(int i=0; i<nrays; i++) {
+    RayPacket::Element& e = rays.get(i);
+    TriangleHit& th = e.hitInfo.scratchpad<TriangleHit>();
+    double A = th.a;
+    double B = th.b;
+    e.texCoords = tc1.multipliedBy(A);
+    e.texCoords.addTo(tc2.multipliedBy(B));
+    e.texCoords.addTo(tc3.multipliedBy(1.0 - A - B));
+  }
+  rays.setFlag(RayPacket::HaveTexture2|RayPacket::HaveTexture3);
+}
+

Added: trunk/Model/Primitives/TexTriangle.h
==============================================================================
--- (empty file)
+++ trunk/Model/Primitives/TexTriangle.h        Fri May 13 13:00:07 2005
@@ -0,0 +1,29 @@
+
+#ifndef Manta_Model_TexTriangle_h
+#define Manta_Model_TexTriangle_h
+
+#include <Model/Primitives/HeavyTriangle.h>
+
+namespace Manta
+{
+  class TexTriangle : public HeavyTriangle {
+  public:
+    TexTriangle(Material* mat, 
+                const Point& _p1, const Point& _p2, const Point& _p3, 
+                const Vector& _n1, const Vector& _n2, const Vector& _n3, 
+                const Point& _tc1, const Point& _tc2, const Point& _tc3);
+    virtual ~TexTriangle();
+    
+    virtual void computeNormal(const RenderContext& context, RayPacket 
&rays) const;    
+
+    virtual void computeTexCoords2(const RenderContext& context, RayPacket& 
rays) const;
+    virtual void computeTexCoords3(const RenderContext& context, RayPacket& 
rays) const;
+    
+  protected:
+    Vector n1,n2,n3;
+    Point tc1,tc2,tc3;
+    Vector e1,e2;
+  };
+}
+
+#endif

Modified: trunk/Model/Primitives/Triangle.cc
==============================================================================
--- trunk/Model/Primitives/Triangle.cc  (original)
+++ trunk/Model/Primitives/Triangle.cc  Fri May 13 13:00:07 2005
@@ -8,19 +8,12 @@
 using namespace Manta;
 using namespace std;
 
-Triangle::Triangle(Material* mat, const Point& _a, const Point& _b, const 
Point& _c)
-  : PrimitiveCommon(mat), a(_a), b(_b), c(_c) 
+Triangle::Triangle(Material* mat, const Point& _p1, const Point& _p2, const 
Point& _p3)
+  : PrimitiveCommon(mat)
 {
-  Vector v1(b-a);
-  Vector v2(c-a);
-  n = Cross(v1, v2);
-  
-  double l = n.normalize();
-  if(l<1.e-8) {
-    cerr << "Bad normal!!!\n";
-    bad = true;
-  }
-  else bad = false;
+  p1 = _p1;
+  p2 = _p2;
+  p3 = _p3;
 }
 
 Triangle::~Triangle()
@@ -29,34 +22,40 @@
 
 void Triangle::computeBounds(const PreprocessContext&, BBox& bbox) const
 {
-  bbox.extendByPoint(a);
-  bbox.extendByPoint(b);
-  bbox.extendByPoint(c);
+  bbox.extendByPoint(p1);
+  bbox.extendByPoint(p2);
+  bbox.extendByPoint(p3);
 }
 
 void Triangle::intersect(const RenderContext&, RayPacket& rays) const
 {
-  if(bad) return;
   rays.normalizeDirections();
+
+  Vector _e1 = p2-p1;
+  Vector _e2 = p3-p1;
+  Vector _n = Cross(_e1, _e2);
+  _n.normalize();
+
   for(int i=0; i<rays.getSize(); i++) {
     RayPacket::Element& e = rays.get(i);
-    Vector e1(b-a);
-    Vector e2(c-a);
     const Vector& dir(e.ray.direction());
-    Vector o(a - e.ray.origin());
+    Vector o(p1 - e.ray.origin());
     
-    Vector normal(Cross(e1, e2));
-    double det=Dot(normal,dir);
+    double det=Dot(_n,dir);
     if(det>1.e-9 || det < -1.e-9) {
       double idet = 1./det;
 
       Vector DX(Cross(dir, o));
-      double A=-Dot(DX, e2)*idet;
+      double A =-Dot(DX, _e2)*idet;
       if(A>0.0 && A<1.0) {
-       double B=Dot(DX, e1)*idet;
+       double B = Dot(DX, _e1)*idet;
        if(B>0.0 && A+B<1.0) {
-         double t=Dot(normal, o)*idet;
-         e.hitInfo.hit(t, material, this, tex);
+         double t=Dot(_n, o)*idet;
+         if (e.hitInfo.hit(t, material, this, tex)){
+             TriangleHit& th = e.hitInfo.scratchpad<TriangleHit>();
+             th.a = A;
+             th.b = B;
+          }
        }
       }
     }
@@ -66,8 +65,7 @@
 
 void Triangle::computeNormal(const RenderContext&, RayPacket& rays) const
 {
-  if (rays.getFlags() & RayPacket::HaveHitPositions)
-    rays.computeHitPositions();
+  rays.computeHitPositions();
 
   if (rays.getFlags() & RayPacket::HaveNormals){
     if (rays.getFlags() & RayPacket::HaveUnitNormals)
@@ -77,15 +75,17 @@
     for(int i=0; i<nrays; i++){
        rays.get(i).normal.normalize();
     }
+    rays.setFlag(RayPacket::HaveUnitNormals);
   }
   else{
     int nrays = rays.getSize();
     for(int i=0; i<nrays; i++) {
       RayPacket::Element& e = rays.get(i);
-      e.normal = Cross((c-a),(b-a));
+      e.normal = Cross((p3-p1),(p2-p1));
       e.normal.normalize();
     }
+    rays.setFlag(RayPacket::HaveUnitNormals);
   }
-
 }
+
 

Modified: trunk/Model/Primitives/Triangle.h
==============================================================================
--- trunk/Model/Primitives/Triangle.h   (original)
+++ trunk/Model/Primitives/Triangle.h   Fri May 13 13:00:07 2005
@@ -10,20 +10,20 @@
 {
   class Triangle : public PrimitiveCommon {
   public:
-    Triangle(Material* mat, const Point& _a, const Point& _b, const Point& 
_c);
-    ~Triangle();
+    struct TriangleHit{
+      double a,b;
+    };
+
+    Triangle(Material* mat, const Point& _p1, const Point& _p2, const Point& 
_p3);
+    virtual ~Triangle();
     
-    bool isbad() const
-    { return bad; }
     virtual void computeBounds(const PreprocessContext& context,
                                BBox& bbox) const;
     virtual void intersect(const RenderContext& context, RayPacket& rays) 
const ;
     virtual void computeNormal(const RenderContext& context, RayPacket 
&rays) const;    
     
-  private:
-    Point a,b,c;
-    Vector n;
-    bool bad;
+  protected:
+    Point p1,p2,p3;
   };
 }
 

---

• [MANTA] r309 - trunk/Model/Primitives, knolla, 05/13/2005

---

Archive powered by MHonArc 2.6.16.