using System;
using ANX.Framework.NonXNA.Development;
// This file is part of the ANX.Framework created by the
// "ANX.Framework developer group" and released under the Ms-PL license.
// For details see: http://anxframework.codeplex.com/license
namespace ANX.Framework
{
[PercentageComplete(100)]
[Developer("floAr")]
[TestState(TestStateAttribute.TestState.InProgress)]
public struct Ray : IEquatable<Ray>
{
#region fields
/// <summary>
/// The direction this ray is pointing to.
/// </summary>
public Vector3 Direction;
/// <summary>
/// Starting position of the ray.
/// </summary>
public Vector3 Position;
#endregion
#region constructors
/// <summary>
/// Initializes a new instance of the <see cref="Ray"/> struct.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="direction">The direction.</param>
public Ray(Vector3 position, Vector3 direction)
{
this.Direction = direction;
this.Position = position;
}
#endregion
#region public methods
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
/// <returns>
/// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
/// </returns>
public override int GetHashCode()
{
return Position.GetHashCode() + Direction.GetHashCode();
}
/*
* Source for implementation :
* http://www-gs.informatik.tu-cottbus.de/projektstudium2006/doku/Strahlen_in_der_CG.pdf
*/
/// <summary>
/// Test if this <see cref="Ray"/> intersects with the specified <see cref="BoundingBox"/>.
/// </summary>
/// <param name="box">The box.</param>
/// <returns>Distance from <see cref="Ray"/> start to interesection points</returns>
public Nullable<float> Intersects(BoundingBox box)
{
Nullable<float> result;
this.Intersects(ref box, out result);
return result;
}
/// <summary>
/// Test if this <see cref="Ray"/> intersects with the specified <see cref="BoundingBox"/>.
/// </summary>
/// <param name="box">The box.</param>
/// <param name="result">The result.</param>
public void Intersects(ref BoundingBox box, out Nullable<float> result)
{
box.Intersects(ref this, out result);
}
/// <summary>
/// Test if this <see cref="Ray"/> intersects with the specified <see cref="BoundingFrustum"/>.
/// </summary>
/// <param name="frustum">The box.</param>
/// <returns>Distance from <see cref="Ray"/> start to interesection points</returns>
public Nullable<float> Intersects(BoundingFrustum frustum)
{
if (frustum == null)
{
throw new ArgumentNullException("frustum");
}
return frustum.Intersects(this);
}
/// <summary>
/// Test if this <see cref="Ray"/> intersects with the specified <see cref="BoundingSphere"/>.
/// </summary>
/// <param name="sphere">The sphere.</param>
/// <returns>
/// Distance from <see cref="Ray"/> start to interesection points
/// </returns>
public Nullable<float> Intersects(BoundingSphere sphere)
{
Nullable<float> result;
this.Intersects(ref sphere, out result);
return result;
}
/// <summary>
/// Test if this <see cref="Ray"/> intersects with the specified <see cref="BoundingSphere"/>.
/// </summary>
/// <param name="sphere">The sphere.</param>
/// <param name="result">The result.</param>
public void Intersects(ref BoundingSphere sphere, out Nullable<float> result)
{
Vector3 toSphere = Vector3.Subtract(sphere.Center, this.Position);
float lengthSquaredToSphere = toSphere.LengthSquared();
float sphereRadiusSquared = sphere.Radius * sphere.Radius;
//project the distance to the Sphere onto the Ray
float toSphereOnRay = Vector3.Dot(this.Direction, toSphere);
//ray starts in sphere
if (lengthSquaredToSphere <= sphereRadiusSquared)
{
result = 0;
return;
}
//if toSphere and this.Direction pointing in different directions
if (toSphereOnRay < 0)
{
result = null;
return;
}
float dist = sphereRadiusSquared + toSphereOnRay * toSphereOnRay - lengthSquaredToSphere;
result = (dist < 0) ? null : toSphereOnRay - (float?)Math.Sqrt(dist);
}
/// <summary>
/// Test if this <see cref="Ray"/> intersects with the specified <see cref="Plane"/>.
/// </summary>
/// <param name="plane">The plane.</param>
/// <returns>
/// Distance from <see cref="Ray"/> start to interesection points
/// </returns>
public Nullable<float> Intersects(Plane plane)
{
Nullable<float> result;
this.Intersects(ref plane, out result);
return result;
}
/// <summary>
/// Test if this <see cref="Ray"/> intersects with the specified <see cref="Plane"/>.
/// </summary>
/// <param name="plane">The plane.</param>
/// <param name="result">The result.</param>
public void Intersects(ref Plane plane, out Nullable<float> result)
{
//http://www.cs.toronto.edu/~smalik/418/tutorial8_ray_primitive_intersections.pdf
float vd = Vector3.Dot(plane.Normal, this.Direction);
//As plane and Ray are infinitiv it intersects in every case, except the ray is parrales to the plane
//no intersection if ray direction and plane normal are orthogional to each other
if (vd == 0)
{
result = null;
return;
}
float v0 = -Vector3.Dot(plane.Normal, this.Position) + plane.D;
float t = v0 / vd;
result=(this.Direction*t).Length();
}
/// <summary>
/// Returns a <see cref="System.String"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="System.String"/> that represents this instance.
/// </returns>
public override string ToString()
{
// This may look a bit more ugly, but String.Format should
// be avoided cause of it's bad performance!
return "{Position:" + Position.ToString() +
" Direction:" + Direction.ToString() + "}";
}
#endregion
#region operator overloading
/// <summary>
/// Implements the operator ==.
/// </summary>
/// <param name="a">First value</param>
/// <param name="b">Second value</param>
/// <returns>
/// The result of the operator.
/// </returns>
public static bool operator ==(Ray a, Ray b)
{
return a.Direction == b.Direction && a.Position == b.Position;
}
/// <summary>
/// Implements the operator !=.
/// </summary>
/// <param name="a">First value</param>
/// <param name="b">Second value</param>
/// <returns>
/// The result of the operator.
/// </returns>
public static bool operator !=(Ray a, Ray b)
{
return a.Direction != b.Direction || a.Position != b.Position;
}
#endregion
#region IEquatable implementation
/// <summary>
/// Determines whether the specified <see cref="System.Object"/> is equal to this instance.
/// </summary>
/// <param name="obj">The <see cref="System.Object"/> to compare with this instance.</param>
/// <returns>
/// <c>true</c> if the specified <see cref="System.Object"/> is equal to this instance; otherwise, <c>false</c>.
/// </returns>
public override bool Equals(Object obj)
{
if (obj is Ray)
{
return this.Equals((Ray)obj);
}
return false;
}
/// <summary>
/// Determines whether the specified <see cref="Ray"/> is equal to this instance.
/// </summary>
/// <param name="obj">The <see cref="Ray"/> to compare with this instance.</param>
/// <returns>
/// <c>true</c> if the specified <see cref="Ray"/> is equal to this instance; otherwise, <c>false</c>.
/// </returns>
public bool Equals(Ray other)
{
return this.Direction == other.Direction && this.Position == other.Position;
}
#endregion
}
}