Changeset 3318 for GTP/trunk/App/Demos/Vis/FriendlyCulling/src/AxisAlignedBox3.h

Timestamp:

02/18/09 08:01:56 (15 years ago)

Author:

mattausch

Message:

played around with reprojection, cleaned up code

File:

• GTP/trunk/App/Demos/Vis/FriendlyCulling/src/AxisAlignedBox3.h (modified) (11 diffs)

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

@@ -25 +25 @@
         SimpleRay(const Vector3 &o, const Vector3 &d): mOrigin(o), mDirection(d) {}
 
-        Vector3 Extrap(const float t) const 
+        Vector3 Extrap(float t) const 
         {
                 return mOrigin + mDirection * t;
@@ -41 +41 @@
 /** Axis alignedd box class.
     This is a box in 3-space, defined by min and max
-        corner vectors.  Many useful operations are defined.
+        corner vectors. Many useful operations are defined.
 */
 class AxisAlignedBox3
@@ -70 +70 @@
         /** Computes the mid point in the given axis.
         */
-        float Center(const int axis) const;
+        float Center(int axis) const;
         /** The vertex of the box with the smallest values in all dimensions.
         */
-        float Min(const int axis) const;
+        float Min(int axis) const;
         /** The vertex of the box with the largest values in all dimensions.
         */
-        float Max(const int axis) const;
+        float Max(int axis) const;
         /** The extent of the box in the given axis.
         */
-        float Size(const int axis) const;
+        float Size(int axis) const;
         /** Returns axis where box has largest extent.
         */
@@ -138 +138 @@
         /** Expand the axis-aligned box to include given values in particular axis.
         */
-        void Include(const int &axis, const float &newBound);
+        void Include(int axis, float newBound);
         /** Includes returns true if a includes b (completely)
         */
@@ -243 +243 @@
         /** Returns the supporting plane of this face.
         */
-        Plane3 GetPlane(const int face) const;
+        Plane3 GetPlane(int face) const;
         /** Returns 
                 0 if box intersects plane
@@ -358 +358 @@
 
 
-// --------------------------------------------------------------------------
-// Implementation of inline (member) functions
+
+/////////////////////////////////////////////////////////
+//-- Implementation of inline (member) functions
+
 
 inline float AxisAlignedBox3::Radius() const 
@@ -373 +375 @@
 
 
-inline bool
-Overlap(const AxisAlignedBox3 &x, const AxisAlignedBox3 &y)
+inline bool Overlap(const AxisAlignedBox3 &x,
+                                        const AxisAlignedBox3 &y)
 {
         if (x.mMax.x < y.mMin.x ||
@@ -381 +383 @@
                 x.mMin.y > y.mMax.y ||
                 x.mMax.z < y.mMin.z ||
-                x.mMin.z > y.mMax.z) {
+                x.mMin.z > y.mMax.z)
+        {
                         return false;
         }
+
         return true;
 }
 
-inline bool
-OverlapS(const AxisAlignedBox3 &x, const AxisAlignedBox3 &y)
+
+inline bool OverlapS(const AxisAlignedBox3 &x, 
+                                         const AxisAlignedBox3 &y)
 {
         if (x.mMax.x <= y.mMin.x ||
@@ -395 +400 @@
                 x.mMin.y >= y.mMax.y ||
                 x.mMax.z <= y.mMin.z ||
-                x.mMin.z >= y.mMax.z) {
+                x.mMin.z >= y.mMax.z) 
+        {
                         return false;
         }
+
         return true;
 }
 
-inline bool
-Overlap(const AxisAlignedBox3 &x, const AxisAlignedBox3 &y, float eps)
-{
-        if ( (x.mMax.x - eps) < y.mMin.x ||
+
+inline bool Overlap(const AxisAlignedBox3 &x,
+                                        const AxisAlignedBox3 &y,
+                                        float eps)
+{
+        if ((x.mMax.x - eps) < y.mMin.x ||
                 (x.mMin.x + eps) > y.mMax.x ||
                 (x.mMax.y - eps) < y.mMin.y ||
                 (x.mMin.y + eps) > y.mMax.y ||
                 (x.mMax.z - eps) < y.mMin.z ||
-                (x.mMin.z + eps) > y.mMax.z ) {
+                (x.mMin.z + eps) > y.mMax.z ) 
+        {
                         return false;
         }
+
         return true;
 }
 
-inline AxisAlignedBox3
-Intersect(const AxisAlignedBox3 &x, const AxisAlignedBox3 &y)
-{
-        if (x.Unbounded())
+
+inline AxisAlignedBox3 Intersect(const AxisAlignedBox3 &x,
+                                                                 const AxisAlignedBox3 &y)
+{
+        if (x.Unbounded()) 
+        {
                 return y;
+        }
         else
-                if (y.Unbounded())
-                        return x;
+        {
+                if (y.Unbounded()) return x;
+        }
+
         AxisAlignedBox3 ret = x;
-        if (Overlap(ret, y)) {
+
+        if (Overlap(ret, y)) 
+        {
                 Maximize(ret.mMin, y.mMin);
                 Minimize(ret.mMax, y.mMax);
+
                 return ret;
         }
-        else      // Null intersection.
+        else // Null intersection
+        {
                 return AxisAlignedBox3(Vector3(0), Vector3(0));
-        // return AxisAlignedBox3(Vector3(0), Vector3(-1));
-}
-
-inline AxisAlignedBox3
-Union(const AxisAlignedBox3 &x, const AxisAlignedBox3 &y)
+        }
+}
+
+
+inline AxisAlignedBox3 Union(const AxisAlignedBox3 &x, 
+                                                         const AxisAlignedBox3 &y)
 {
         Vector3 min = x.mMin;
         Vector3 max = x.mMax;
+
         Minimize(min, y.mMin);
         Maximize(max, y.mMax);
+
         return AxisAlignedBox3(min, max);
 }
 
-inline AxisAlignedBox3
-Transform(const AxisAlignedBox3 &box, const Matrix4x4 &tform)
-{
-        Vector3 mmin(MAXFLOAT);
-        Vector3 mmax(-MAXFLOAT);
+
+inline AxisAlignedBox3 Transform(const AxisAlignedBox3 &box, 
+                                                                 const Matrix4x4 &tform)
+{
+        const Vector3 mmin(MAXFLOAT);
+        const Vector3 mmax(-MAXFLOAT);
         
         AxisAlignedBox3 ret(mmin, mmax);
@@ -464 +488 @@
 }
 
-inline float RatioOfOverlap(const AxisAlignedBox3 &box1, const AxisAlignedBox3 &box2)
+
+inline float RatioOfOverlap(const AxisAlignedBox3 &box1,
+                                                        const AxisAlignedBox3 &box2)
 {
         // return ratio of intersection to union
@@ -473 +499 @@
 }
 
-inline int operator==(const AxisAlignedBox3 &A, const AxisAlignedBox3 &B)
+
+inline int operator==(const AxisAlignedBox3 &A, 
+                                          const AxisAlignedBox3 &B)
 {
         return (A.mMin == B.mMin) && (A.mMax == B.mMax);