Changeset 2913 for GTP/trunk/App/Demos/Vis/FriendlyCulling/src/AxisAlignedBox3.cpp

Timestamp:

09/08/08 00:52:31 (16 years ago)

Author:

mattausch

Message:

 

File:

• GTP/trunk/App/Demos/Vis/FriendlyCulling/src/AxisAlignedBox3.cpp (modified) (4 diffs)

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/AxisAlignedBox3.cpp

@@ -1153 +1153 @@
 
 
-Plane3 AxisAlignedBox3::GetPlane(const int face) const
+Plane3 AxisAlignedBox3::GetPlane(int face) const
 {
         switch (face) 
         {
-        
         case 0:
+                return Plane3(Vector3(0, -1, 0), mMin);
+        case 1:
+                return Plane3(Vector3(0, 1, 0), mMax);
+        case 2:
                 return Plane3(Vector3(-1, 0, 0), mMin);
-        case 1: 
+        case 3: 
                 return Plane3(Vector3(1, 0, 0), mMax);
-        case 2:
-                return Plane3(Vector3(0, -1, 0), mMin);
-        case 3:
-                return Plane3(Vector3(0, 1, 0), mMax);
         case 4:
                 return Plane3(Vector3(0, 0, -1), mMin);
@@ -1176 +1175 @@
 }
 
+
+/*int AxisAlignedBox3::Side(const Plane3 &plane) const
+{
+        Vector3 v;
+        int i, m=3, M=-3, s;
+
+        for (i=0;i<8;i++) 
+        {
+                GetVertex(i, v);
+        
+                if((s = plane.Side(v)) < m) m=s;
+                if(s > M) M=s;
+                if (m && m==-M) return 0;
+        }
+
+        return (m == M) ? m : m + M;
+}
+*/
 
 int AxisAlignedBox3::Side(const Plane3 &plane) const
@@ -1203 +1220 @@
 
 
-Polyhedron *AxisAlignedBox3::CalcIntersection(Polyhedron *polyhedron) const
-{
-        Polyhedron *oldPolyhedron = new Polyhedron(*polyhedron);
-
+Polyhedron *AxisAlignedBox3::CalcIntersection(const Polyhedron &polyhedron) const
+{
+        Polyhedron *oldPolyhedron = new Polyhedron(polyhedron);
+
+        if (!oldPolyhedron->Valid()) cerr << "******************* not valid!! ************* " << endl;
+        
         Polyhedron *newPolyhedron = NULL;
 
         for (int i = 0; i < 6; ++ i)
         {
-                Polyhedron *newPolyhedron = oldPolyhedron->CalcIntersection(GetPlane(i));
+                newPolyhedron = oldPolyhedron->CalcIntersection(GetPlane(i));
+
+                if (!newPolyhedron || !newPolyhedron->Valid())
+                {
+                        DEL_PTR(newPolyhedron);
+                        cerr << "polyhedron not valid or NULL!" << endl; 
+
+                        return NULL;    
+                }
+
                 DEL_PTR(oldPolyhedron);
-
-                if (!newPolyhedron)
-                        return NULL;
+                oldPolyhedron = newPolyhedron;
         }
 
@@ -1222 +1248 @@
 
 
-}
-
+
+bool AxisAlignedBox3::Intersects(const SimpleRay &ray, float &tnear, float &tfar) const
+{
+        tnear = -1e20f;
+        tfar = 1e20f;
+
+        const Vector3 origin = ray.mOrigin;
+        const Vector3 dir = ray.mDirection;
+
+        float t1, t2;
+
+        // ray is parallel to the planes
+        if (dir.x == 0) 
+        {
+                if ((origin.x < mMin.x) || (origin.x > mMax.x)) 
+                        return false; // origin not between planes
+        }
+        else
+        {
+                // time at which ray intersects minimum X plane
+                t1 = (mMin.x - origin.x) / dir.x;
+                // time at which ray intersects maximum X plane
+                t2 = (mMax.x - origin.x) / dir.x;
+                
+                if (t1 > t2)
+                        swap(t1, t2);
+                
+                if (t1 > tnear)
+                        tnear = t1;
+                
+                if (t2 < tfar)
+                        tfar = t2;
+                
+                if (tnear > tfar)
+                        return false;
+                
+                if (tfar < 0)
+                        return false;
+        }
+
+        if (dir.y == 0) // ray is parallel to the planes
+        {
+                if ((origin.y < mMin.y) || (origin.y > mMax.y)) 
+                        return false; // origin not between planes)
+        }
+        else
+        {
+                t1 = (mMin.y - origin.y) / dir.y; 
+                t2 = (mMax.y - origin.y) / dir.y; 
+                
+                if (t1 > t2)
+                        swap(t1, t2);
+                
+                if (t1 > tnear)
+                        tnear = t1;
+                
+                if (t2 < tfar)
+                        tfar = t2;
+                
+                if (tnear > tfar)
+                        return false;
+                
+                if (tfar < 0)
+                        return false;
+        }
+
+        if (dir.z == 0) // ray is parallel to the planes
+        {
+                if ((origin.z < mMin.z) || (origin.z > mMax.z)) 
+                        return false; // origin not between planes)
+        }
+        else
+        {
+                t1 = (mMin.z - origin.z) / dir.z; 
+                t2 = (mMax.z - origin.z) / dir.z; 
+                
+                if (t1 > t2)
+                        swap(t1, t2);
+                
+                if (t1 > tnear)
+                        tnear = t1;
+                
+                if (t2 < tfar)
+                        tfar = t2;
+                
+                if (tnear > tfar)
+                        return false;
+                
+                if (tfar < 0)
+                        return false;
+        }
+
+        return true;
+}
+
+
+}
+