Exemplo n.º 1
0
 /// <summary>
 /// Determines whether any of the fields of the specified bounding sphere evaluates to a value that is not a number.
 /// </summary>
 /// <param name="value">A bounding sphere.</param>
 /// <returns>True if any of the fields of <paramref name="value"/> evaluates to a value that is not a number, otherwise false.</returns>
 public static bool IsNaN(BoundingSphere value)
 {
     return
         Vector3.IsNaN(value.Position) ||
         Number.IsNaN(value.Radius);
 }
Exemplo n.º 2
0
        /// <summary>
        /// Determines whether the specified plane intersects with the specified bounding sphere.
        /// </summary>
        /// <param name="plane">A plane.</param>
        /// <param name="boundingSphere">A bounding sphere.</param>
        /// <param name="intersection">Output variable for the intersection.</param>
        /// <returns>True if the <paramref name="plane"/> and the <paramref name="boundingSphere"/> intersect, otherwise false.</returns>
        public static bool PlaneWithBoundingSphere(Plane plane, BoundingSphere boundingSphere, out Vector3 intersection)
        {
            var distance = Distance.PointToPlane(boundingSphere.Position, plane);

            if (Math.Abs(distance) < boundingSphere.Radius)
            {
                intersection = new Vector3
                {
                    X = boundingSphere.Position.X - plane.A * distance,
                    Y = boundingSphere.Position.Y - plane.B * distance,
                    Z = boundingSphere.Position.Z - plane.C * distance,
                };
                return true;
            }
            else
            {
                intersection = default(Vector3);
                return false;
            }
        }
Exemplo n.º 3
0
 /// <summary>
 /// Determines whether the specified bounding box intersects with the specified bounding sphere.
 /// </summary>
 /// <param name="boundingBox">A bounding box.</param>
 /// <param name="boundingSphere">A bounding sphere.</param>
 /// <returns>True if the <paramref name="boundingBox"/> and the <paramref name="boundingSphere"/> intersect, otherwise false.</returns>
 public static bool BoundingBoxWithBoundingSphere(BoundingBox boundingBox, BoundingSphere boundingSphere)
 {
     var closestPoint = Vector3.Clamp(boundingSphere.Position, boundingBox.Minimum, boundingBox.Maximum);
     return Distance.PointToPointSquared(boundingSphere.Position, closestPoint) <= boundingSphere.Radius * boundingSphere.Radius;
 }
Exemplo n.º 4
0
 /// <summary>
 /// Determines whether the current bounding sphere is equal to the specified bounding sphere.
 /// </summary>
 /// <param name="value">A bounding sphere.</param>
 /// <returns>True if the current bounding sphere is equal to the <paramref name="value"/>, otherwise false.</returns>
 public bool Equals(BoundingSphere value)
 {
     return
         this.Position == value.Position &&
         this.Radius == value.Radius;
 }
Exemplo n.º 5
0
 /// <summary>
 /// Returns the distance between the specified bounding sphere and the specified line segment.
 /// </summary>
 /// <param name="boundingSphere">A bounding sphere.</param>
 /// <param name="lineSegment">A line segment.</param>
 /// <returns>The distance between the <paramref name="boundingSphere"/> and the <paramref name="lineSegment"/>.</returns>
 public static Number BoundingSphereToLineSegment(BoundingSphere boundingSphere, LineSegment lineSegment)
 {
     return Math.Max(0, Distance.PointToLineSegment(boundingSphere.Position, lineSegment) - boundingSphere.Radius);
 }
Exemplo n.º 6
0
 /// <summary>
 /// Attempts to parse the bounding sphere from the specified string.
 /// </summary>
 /// <param name="value">The string to parse.</param>
 /// <param name="result">The output variable for the bounding sphere parsed from the <paramref name="value"/>.</param>
 /// <returns>True if the <paramref name="value"/> was parsed successfully, otherwise false.</returns>
 public static bool TryParse(string value, out BoundingSphere result)
 {
     return TryParse(value, NumberStyles.Float | NumberStyles.AllowThousands, null, out result);
 }
Exemplo n.º 7
0
 /// <summary>
 /// Attempts to parse the bounding sphere from the specified string.
 /// </summary>
 /// <param name="value">The string to parse.</param>
 /// <param name="formatProvider">The format provider for each component.</param>
 /// <param name="result">The output variable for the bounding sphere parsed from the <paramref name="value"/>.</param>
 /// <returns>True if the <paramref name="value"/> was parsed successfully, otherwise false.</returns>
 public static bool TryParse(string value, IFormatProvider formatProvider, out BoundingSphere result)
 {
     return TryParse(value, NumberStyles.Float | NumberStyles.AllowThousands, formatProvider, out result);
 }
Exemplo n.º 8
0
        /// <summary>
        /// Determines whether the specified bounding spheres intersect.
        /// </summary>
        /// <param name="boundingSphere1">A bounding sphere.</param>
        /// <param name="boundingSphere2">A bounding sphere.</param>
        /// <returns>True if the <paramref name="boundingSphere1"/> and the <paramref name="boundingSphere2"/> intersect, otherwise false.</returns>
        public static bool BoundingSphereWithBoundingSphere(BoundingSphere boundingSphere1, BoundingSphere boundingSphere2)
        {
            var distance = Distance.PointToPoint(boundingSphere1.Position, boundingSphere2.Position);

            return distance <= boundingSphere1.Radius + boundingSphere2.Radius;
        }
Exemplo n.º 9
0
        /// <summary>
        /// Determines whether the specified bounding spheres intersect.
        /// </summary>
        /// <param name="boundingSphere1">A bounding sphere.</param>
        /// <param name="boundingSphere2">A bounding sphere.</param>
        /// <param name="intersection">Output variable for the intersection.</param>
        /// <returns>True if the <paramref name="boundingSphere1"/> and the <paramref name="boundingSphere2"/> intersect, otherwise false.</returns>
        public static bool BoundingSphereWithBoundingSphere(BoundingSphere boundingSphere1, BoundingSphere boundingSphere2, out BoundingSphere intersection)
        {
            var x = boundingSphere2.Position.X - boundingSphere1.Position.X;
            var y = boundingSphere2.Position.Y - boundingSphere1.Position.Y;
            var z = boundingSphere2.Position.Z - boundingSphere1.Position.Z;

            var distance = (Number)Math.Sqrt(x * x + y * y + z * z);

            if (distance > boundingSphere1.Radius + boundingSphere2.Radius)
            {
                intersection = default(BoundingSphere);
                return false;
            }
            else if (distance <= boundingSphere1.Radius - boundingSphere2.Radius)
            {
                intersection = boundingSphere2;
                return true;
            }
            else if (distance <= boundingSphere2.Radius - boundingSphere1.Radius)
            {
                intersection = boundingSphere1;
                return true;
            }
            else
            {
                var radius = (Number)(Math.Sqrt(
                    (boundingSphere1.Radius - boundingSphere2.Radius - distance) *
                    (boundingSphere2.Radius - boundingSphere1.Radius - distance) *
                    (boundingSphere1.Radius + boundingSphere2.Radius - distance) *
                    (boundingSphere2.Radius + boundingSphere1.Radius + distance)) / distance);

                var r1 = boundingSphere1.Radius * boundingSphere1.Radius;
                var r2 = boundingSphere2.Radius * boundingSphere2.Radius;
                var d1 = distance * distance;
                var d2 = (d1 + r1 - r2) / (2 * d1);

                intersection.Position.X = boundingSphere1.Position.X + x * d2;
                intersection.Position.Y = boundingSphere1.Position.Y + y * d2;
                intersection.Position.Z = boundingSphere1.Position.Z + z * d2;
                intersection.Radius = radius;
                return true;
            }
        }
Exemplo n.º 10
0
 /// <summary>
 /// Returns the distance between the specified bounding box and the specified bounding sphere.
 /// </summary>
 /// <param name="boundingBox">A bounding box.</param>
 /// <param name="boundingSphere">A bounding sphere.</param>
 /// <returns>The distance between the <paramref name="boundingBox"/> and the <paramref name="boundingSphere"/>.</returns>
 public static Number BoundingBoxToBoundingSphere(BoundingBox boundingBox, BoundingSphere boundingSphere)
 {
     var closestPoint = Vector3.Clamp(boundingSphere.Position, boundingBox.Minimum, boundingBox.Maximum);
     return Distance.PointToBoundingSphere(closestPoint, boundingSphere);
 }
Exemplo n.º 11
0
        /// <summary>
        /// Determines whether the specified bounding box intersects with the specified bounding sphere.
        /// </summary>
        /// <param name="boundingBox">A bounding box.</param>
        /// <param name="boundingSphere">A bounding sphere.</param>
        /// <param name="intersection">Output variable for the intersection.</param>
        /// <returns>True if the <paramref name="boundingBox"/> and the <paramref name="boundingSphere"/> intersect, otherwise false.</returns>
        public static bool BoundingBoxWithBoundingSphere(BoundingBox boundingBox, BoundingSphere boundingSphere, out Vector3 intersection)
        {
            var closestPoint = Vector3.Clamp(boundingSphere.Position, boundingBox.Minimum, boundingBox.Maximum);

            if (Distance.PointToPointSquared(closestPoint, boundingSphere.Position) <= boundingSphere.Radius * boundingSphere.Radius)
            {
                intersection = closestPoint;
                return true;
            }
            else
            {
                intersection = default(Vector3);
                return false;
            }
        }
Exemplo n.º 12
0
 /// <summary>
 /// Returns the distance between the specified point and the specified bounding sphere.
 /// </summary>
 /// <param name="point">A point.</param>
 /// <param name="boundingSphere">A bounding sphere.</param>
 /// <returns>The distance between the <paramref name="point"/> and the <paramref name="boundingSphere"/>.</returns>
 public static Number PointToBoundingSphere(Vector3 point, BoundingSphere boundingSphere)
 {
     return Math.Max(0, Distance.PointToPoint(point, boundingSphere.Position) - boundingSphere.Radius);
 }
Exemplo n.º 13
0
 /// <summary>
 /// Returns the distance between the specified bounding sphere and the specified ray.
 /// </summary>
 /// <param name="boundingSphere">A bounding sphere.</param>
 /// <param name="ray">A ray.</param>
 /// <returns>The distance between the <paramref name="boundingSphere"/> and the <paramref name="ray"/>.</returns>
 public static Number BoundingSphereToRay(BoundingSphere boundingSphere, Ray ray)
 {
     return Math.Max(0, Distance.PointToRay(boundingSphere.Position, ray) - boundingSphere.Radius);
 }
Exemplo n.º 14
0
        /// <summary>
        /// Returns the distance between the specified bounding sphere and the specified plane.
        /// </summary>
        /// <param name="boundingSphere">A bounding sphere.</param>
        /// <param name="plane">A plane.</param>
        /// <returns>The distance between the <paramref name="boundingSphere"/> and the <paramref name="plane"/>.</returns>
        public static Number BoundingSphereToPlane(BoundingSphere boundingSphere, Plane plane)
        {
            var distance = Distance.PointToPlane(boundingSphere.Position, plane);

            if (distance < -boundingSphere.Radius)
            {
                return distance + boundingSphere.Radius;
            }

            if (distance > boundingSphere.Radius)
            {
                return distance - boundingSphere.Radius;
            }

            return 0;
        }
Exemplo n.º 15
0
 /// <summary>
 /// Determines whether any of the fields of the specified bounding sphere evaluates to positive infinity.
 /// </summary>
 /// <param name="value">A bounding sphere.</param>
 /// <returns>True if any of the fields of <paramref name="value"/> evaluates to positive infinity, otherwise false.</returns>
 public static bool IsPositiveInfinity(BoundingSphere value)
 {
     return
         Vector3.IsPositiveInfinity(value.Position) ||
         Number.IsPositiveInfinity(value.Radius);
 }
Exemplo n.º 16
0
 /// <summary>
 /// Determines whether the specified bounding sphere intersects with the specified point.
 /// </summary>
 /// <param name="boundingSphere">A bounding sphere.</param>
 /// <param name="point">A point.</param>
 /// <returns>True if the <paramref name="boundingSphere"/> and the <paramref name="point"/> intersect, otherwise false.</returns>
 public static bool BoundingSphereWithPoint(BoundingSphere boundingSphere, Vector3 point)
 {
     return Distance.PointToPointSquared(point, boundingSphere.Position) <= boundingSphere.Radius * boundingSphere.Radius;
 }
Exemplo n.º 17
0
        /// <summary>
        /// Returns the smallest bounding sphere containing both of the specified bounding spheres.
        /// </summary>
        /// <param name="value1">A bouding sphere.</param>
        /// <param name="value2">A bouding sphere.</param>
        /// <returns>The smallest bounding sphere containing both of the <paramref name="value1"/> and the <paramref name="value2"/>.</returns>
        public static BoundingSphere Merge(BoundingSphere value1, BoundingSphere value2)
        {
            var separation = value2.Position - value1.Position;
            var distance = separation.Magnitude;

            if (value1.Radius - value2.Radius >= distance)
            {
                return value1;
            }
            else if (value2.Radius - value1.Radius >= distance)
            {
                return value2;
            }
            else
            {
                var radius = (distance + value1.Radius + value2.Radius) * 0.5f;
                var d = (radius - value1.Radius) / distance;

                return new BoundingSphere
                {
                    Position = value1.Position + separation * d,
                    Radius = radius,
                };
            }
        }
Exemplo n.º 18
0
        /// <summary>
        /// Determines whether the specified bounding sphere intersects with the specified ray.
        /// </summary>
        /// <param name="boundingSphere">A bounding sphere.</param>
        /// <param name="ray">A ray.</param>
        /// <returns>True if the <paramref name="boundingSphere"/> and the <paramref name="ray"/> intersect, otherwise false.</returns>
        public static bool BoundingSphereWithRay(BoundingSphere boundingSphere, Ray ray)
        {
            var separation = boundingSphere.Position - ray.Position;
            var lengthSquared = separation.MagnitudeSquared;
            var radiusSquared = boundingSphere.Radius * boundingSphere.Radius;

            if (lengthSquared <= radiusSquared)
            {
                return true;
            }
            else
            {
                var dot = Vector3.Dot(ray.Direction, separation);

                if (dot >= 0)
                {
                    var discriminant = lengthSquared - (dot * dot);

                    if (discriminant <= radiusSquared)
                    {
                        return true;
                    }
                }
            }

            return false;
        }
Exemplo n.º 19
0
 /// <summary>
 /// Attempts to parse the bounding sphere from the specified string.
 /// </summary>
 /// <param name="value">The string to parse.</param>
 /// <param name="numberStyle">The number style for each component.</param>
 /// <param name="result">The output variable for the bounding sphere parsed from the <paramref name="value"/>.</param>
 /// <returns>True if the <paramref name="value"/> was parsed successfully, otherwise false.</returns>
 public static bool TryParse(string value, NumberStyles numberStyle, out BoundingSphere result)
 {
     return TryParse(value, numberStyle, null, out result);
 }
Exemplo n.º 20
0
        /// <summary>
        /// Determines whether the specified bounding sphere intersects with the specified ray.
        /// </summary>
        /// <param name="boundingSphere">A bounding sphere.</param>
        /// <param name="ray">A ray.</param>
        /// <param name="intersection">Output variable for the intersection.</param>
        /// <returns>True if the <paramref name="boundingSphere"/> and the <paramref name="ray"/> intersect, otherwise false.</returns>
        public static bool BoundingSphereWithRay(BoundingSphere boundingSphere, Ray ray, out Vector3 intersection)
        {
            var separation = boundingSphere.Position - ray.Position;
            var lengthSquared = separation.MagnitudeSquared;
            var radiusSquared = boundingSphere.Radius * boundingSphere.Radius;

            if (lengthSquared <= radiusSquared)
            {
                intersection = ray.Position;
                return true;
            }
            else
            {
                var dot = Vector3.Dot(ray.Direction, separation);

                if (dot >= 0)
                {
                    var discriminant = lengthSquared - (dot * dot);

                    if (discriminant <= radiusSquared)
                    {
                        var u = dot - (Number)Math.Sqrt(radiusSquared - discriminant);
                        intersection = ray.Position + ray.Direction * u;
                        return true;
                    }
                }
            }

            intersection = default(Vector3);
            return false;
        }
Exemplo n.º 21
0
        /// <summary>
        /// Attempts to parse the bounding sphere from the specified string.
        /// </summary>
        /// <param name="value">The string to parse.</param>
        /// <param name="numberStyle">The number style for each component.</param>
        /// <param name="formatProvider">The format provider for each component.</param>
        /// <param name="result">The output variable for the bounding sphere parsed from the <paramref name="value"/>.</param>
        /// <returns>True if the <paramref name="value"/> was parsed successfully, otherwise false.</returns>
        public static bool TryParse(string value, NumberStyles numberStyle, IFormatProvider formatProvider, out BoundingSphere result)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            var numbers = Float.Parse(value, numberStyle, formatProvider);

            if (numbers.Length == ValueCount)
            {
                result.Position.X = numbers[0];
                result.Position.Y = numbers[1];
                result.Position.Z = numbers[2];
                result.Radius = numbers[3];
                return true;
            }
            else
            {
                result = default(BoundingSphere);
                return false;
            }
        }
Exemplo n.º 22
0
        /// <summary>
        /// Determines whether the specified plane intersects with the specified bounding sphere.
        /// </summary>
        /// <param name="plane">A plane.</param>
        /// <param name="boundingSphere">A bounding sphere.</param>
        /// <returns>True if the <paramref name="plane"/> and the <paramref name="boundingSphere"/> intersect, otherwise false.</returns>
        public static bool PlaneWithBoundingSphere(Plane plane, BoundingSphere boundingSphere)
        {
            var distance =
                plane.A * boundingSphere.Position.X +
                plane.B * boundingSphere.Position.Y +
                plane.C * boundingSphere.Position.Z +
                plane.D;

            return Math.Abs(distance) < boundingSphere.Radius;
        }
Exemplo n.º 23
0
 /// <summary>
 /// Initializes a new instance of the struct.
 /// </summary>
 /// <param name="boundingSphere">Bounding sphere to copy.</param>
 public BoundingSphere(BoundingSphere boundingSphere)
 {
     this.Position = boundingSphere.Position;
     this.Radius = boundingSphere.Radius;
 }
Exemplo n.º 24
0
 /// <summary>
 /// Returns the distance between the specified bounding spheres.
 /// </summary>
 /// <param name="boundingSphere1">A bounding sphere.</param>
 /// <param name="boundingSphere2">A bounding sphere.</param>
 /// <returns>The distance between the <paramref name="boundingSphere1"/> and the <paramref name="boundingSphere2"/>.</returns>
 public static Number BoundingSphereToBoundingSphere(BoundingSphere boundingSphere1, BoundingSphere boundingSphere2)
 {
     return Math.Max(0, Distance.PointToPoint(boundingSphere1.Position, boundingSphere2.Position) - boundingSphere1.Radius - boundingSphere2.Radius);
 }