Changeset 1903

Timestamp:

11/18/09 19:12:34 (3 months ago)

Author:

bostich1983

Message:

-2 new Math/Utility.cs functions (Intersects and BoundingRadiusFromAABB)

Files:

• branches/ogre_1.7_update/Projects/Axiom/Engine/Math/Utility.cs (modified) (2 diffs)

branches/ogre_1.7_update/Projects/Axiom/Engine/Math/Utility.cs

@@ -81 +81 @@
         private Utility()
         {
+        }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="aabb"></param>
+        /// <returns></returns>
+        public static Real BoundingRadiusFromAABB(AxisAlignedBox aabb)
+        {
+            Vector3 max = aabb.Maximum;
+            Vector3 min = aabb.Minimum;
+
+            Vector3 magnitude = max;
+            magnitude.Ceil(-max);
+            magnitude.Ceil(min);
+            magnitude.Ceil(-min);
+
+            return magnitude.Length;
         }
 
@@ -1148 +1165 @@
             return Utility.Abs( plane.Normal.Dot( sphere.Center ) ) <= sphere.Radius;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="ray"></param>
+        /// <param name="box"></param>
+        /// <param name="d1"></param>
+        /// <param name="d2"></param>
+        /// <returns></returns>
+        public static bool Intersects(Ray ray, AxisAlignedBox box, ref Real d1, ref Real d2)
+        {
+            if (box.IsNull)
+                return false;
+
+            if (box.IsInfinite)
+            {
+                if (d1 != 0) d1 = 0;
+                if (d2 != 0) d2 = Real.PositiveInfinity;
+                return true;
+            }
+
+            Vector3 min = box.Minimum;
+            Vector3 max = box.Maximum;
+            Vector3 rayorig = ray.origin;
+            Vector3 rayDir = ray.Direction;
+
+            Vector3 absDir = Vector3.Zero;
+            absDir[0] = Abs(rayDir[0]);
+            absDir[1] = Abs(rayDir[1]);
+            absDir[2] = Abs(rayDir[2]);
+
+            // Sort the axis, ensure check minimise floating error axis first
+            int imax = 0, imid = 1, imin = 2;
+            if (absDir[0] < absDir[2])
+            {
+                imax = 2;
+                imin = 0;
+            }
+            if (absDir[1] < absDir[imin])
+            {
+                imid = imin;
+                imin = 1;
+            }
+            else if (absDir[1] > absDir[imax])
+            {
+                imid = imax;
+                imax = 1;
+            }
+
+            Real start = 0, end = Real.PositiveInfinity;
+            // Check each axis in turn
+
+            if (!CalcAxis(imax, rayDir, rayorig, min, max, ref end, ref start))
+                return false;
+
+            if (absDir[imid] < Real.Epsilon)
+            {
+                // Parallel with middle and minimise axis, check bounds only
+                if (rayorig[imid] < min[imid] || rayorig[imid] > max[imid] ||
+                    rayorig[imin] < min[imin] || rayorig[imin] > max[imin])
+                    return false;
+            }
+            else
+            {
+                if (!CalcAxis(imid, rayDir, rayorig, min, max, ref end, ref start))
+                    return false;
+
+                if (absDir[imin] < Real.Epsilon)
+                {
+                    // Parallel with minimise axis, check bounds only
+                    if (rayorig[imin] < min[imin] || rayorig[imin] > max[imin])
+                        return false;
+                }
+                else
+                {
+                    if (!CalcAxis(imin, rayDir, rayorig, min, max, ref end, ref start))
+                        return false;
+                }
+            }
+
+            if (d1 != 0) d1 = start;
+            if (d2 != 0) d2 = end;
+
+            return true;
+        }
+        static bool CalcAxis(int i, Vector3 raydir, Vector3 rayorig, Vector3 min, Vector3 max
+            , ref Real end, ref Real start)
+        {
+            Real denom = 1 / raydir[i];
+            Real newstart = (min[i] - rayorig[i]) * denom;
+            Real newend = (max[i] - rayorig[i]) * denom;
+            if (newstart > newend) Swap<Real>(ref newstart, ref newend);
+            if (newstart > end || newend < start) return false;
+            if (newstart > start) start = newstart;
+            if (newend < end) end = newend;
+
+            return true;
+        }
         /// <summary>
         ///    Ray/PlaneBoundedVolume intersection test.