alysbrooks-public » games » isometric-park-fna

Location: alysbrooks-public/games/isometric-park-fna/FNA/src/Ray.cs

Show More
Commit Description:
Add timers for Simulation and various engines...
Commit Description:
Add timers for Simulation and various engines Starting to add additional timers for different stages of the process of updating in order to get more insight into what is slowing it down. The update takes 9ms, which is much longer than it used to. Engine-specific timers are coming later.
References:
r588:3b7b6298ad9c m6-tiles-and-trees
File last commit:
r0:e33f209de7e5 default
Show/Diff file:
Action:
FNA/src/Ray.cs
300 lines | 6.2 KiB | text/x-csharp | CSharpLexer
History | Annotation | Raw | Download
#region License
/* FNA - XNA4 Reimplementation for Desktop Platforms
* Copyright 2009-2020 Ethan Lee and the MonoGame Team
*
* Released under the Microsoft Public License.
* See LICENSE for details.
*/
/* Derived from code by the Mono.Xna Team (Copyright 2006).
* Released under the MIT License. See monoxna.LICENSE for details.
*/
#endregion
#region Using Statements
using System;
using System.ComponentModel;
using System.Diagnostics;
using Microsoft.Xna.Framework.Design;
#endregion
namespace Microsoft.Xna.Framework
{
[Serializable]
[TypeConverter(typeof(RayConverter))]
[DebuggerDisplay("{DebugDisplayString,nq}")]
public struct Ray : IEquatable<Ray>
{
#region Internal Properties
internal string DebugDisplayString
{
get
{
return string.Concat(
"Pos( ", Position.DebugDisplayString, " ) \r\n",
"Dir( ", Direction.DebugDisplayString, " )"
);
}
}
#endregion
#region Public Fields
public Vector3 Position;
public Vector3 Direction;
#endregion
#region Public Constructors
public Ray(Vector3 position, Vector3 direction)
{
Position = position;
Direction = direction;
}
#endregion
#region Public Methods
public override bool Equals(object obj)
{
return (obj is Ray) && Equals((Ray) obj);
}
public bool Equals(Ray other)
{
return ( this.Position.Equals(other.Position) &&
this.Direction.Equals(other.Direction) );
}
public override int GetHashCode()
{
return Position.GetHashCode() ^ Direction.GetHashCode();
}
// Adapted from http://www.scratchapixel.com/lessons/3d-basic-lessons/lesson-7-intersecting-simple-shapes/ray-box-intersection/
public float? Intersects(BoundingBox box)
{
float? tMin = null, tMax = null;
if (MathHelper.WithinEpsilon(Direction.X, 0.0f))
{
if (Position.X < box.Min.X || Position.X > box.Max.X)
{
return null;
}
}
else
{
tMin = (box.Min.X - Position.X) / Direction.X;
tMax = (box.Max.X - Position.X) / Direction.X;
if (tMin > tMax)
{
float? temp = tMin;
tMin = tMax;
tMax = temp;
}
}
if (MathHelper.WithinEpsilon(Direction.Y, 0.0f))
{
if (Position.Y < box.Min.Y || Position.Y > box.Max.Y)
{
return null;
}
}
else
{
float tMinY = (box.Min.Y - Position.Y) / Direction.Y;
float tMaxY = (box.Max.Y - Position.Y) / Direction.Y;
if (tMinY > tMaxY)
{
float temp = tMinY;
tMinY = tMaxY;
tMaxY = temp;
}
if ( (tMin.HasValue && tMin > tMaxY) ||
(tMax.HasValue && tMinY > tMax) )
{
return null;
}
if (!tMin.HasValue || tMinY > tMin) tMin = tMinY;
if (!tMax.HasValue || tMaxY < tMax) tMax = tMaxY;
}
if (MathHelper.WithinEpsilon(Direction.Z, 0.0f))
{
if (Position.Z < box.Min.Z || Position.Z > box.Max.Z)
{
return null;
}
}
else
{
float tMinZ = (box.Min.Z - Position.Z) / Direction.Z;
float tMaxZ = (box.Max.Z - Position.Z) / Direction.Z;
if (tMinZ > tMaxZ)
{
float temp = tMinZ;
tMinZ = tMaxZ;
tMaxZ = temp;
}
if ( (tMin.HasValue && tMin > tMaxZ) ||
(tMax.HasValue && tMinZ > tMax) )
{
return null;
}
if (!tMin.HasValue || tMinZ > tMin) tMin = tMinZ;
if (!tMax.HasValue || tMaxZ < tMax) tMax = tMaxZ;
}
/* Having a positive tMin and a negative tMax means the ray is inside the
* box we expect the intesection distance to be 0 in that case.
*/
if ((tMin.HasValue && tMin < 0) && tMax > 0) return 0;
/* A negative tMin means that the intersection point is behind the ray's
* origin. We discard these as not hitting the AABB.
*/
if (tMin < 0) return null;
return tMin;
}
public void Intersects(ref BoundingBox box, out float? result)
{
result = Intersects(box);
}
public float? Intersects(BoundingSphere sphere)
{
float? result;
Intersects(ref sphere, out result);
return result;
}
public float? Intersects(Plane plane)
{
float? result;
Intersects(ref plane, out result);
return result;
}
public float? Intersects(BoundingFrustum frustum)
{
float? result;
frustum.Intersects(ref this, out result);
return result;
}
public void Intersects(ref Plane plane, out float? result)
{
float den = Vector3.Dot(Direction, plane.Normal);
if (Math.Abs(den) < 0.00001f)
{
result = null;
return;
}
result = (-plane.D - Vector3.Dot(plane.Normal, Position)) / den;
if (result < 0.0f)
{
if (result < -0.00001f)
{
result = null;
return;
}
result = 0.0f;
}
}
public void Intersects(ref BoundingSphere sphere, out float? result)
{
// Find the vector between where the ray starts the the sphere's center.
Vector3 difference = sphere.Center - this.Position;
float differenceLengthSquared = difference.LengthSquared();
float sphereRadiusSquared = sphere.Radius * sphere.Radius;
float distanceAlongRay;
/* If the distance between the ray start and the sphere's center is less than
* the radius of the sphere, it means we've intersected. Checking the
* LengthSquared is faster.
*/
if (differenceLengthSquared < sphereRadiusSquared)
{
result = 0.0f;
return;
}
Vector3.Dot(ref this.Direction, ref difference, out distanceAlongRay);
// If the ray is pointing away from the sphere then we don't ever intersect.
if (distanceAlongRay < 0)
{
result = null;
return;
}
/* Next we kinda use Pythagoras to check if we are within the bounds of the
* sphere.
* if x = radius of sphere
* if y = distance between ray position and sphere centre
* if z = the distance we've travelled along the ray
* if x^2 + z^2 - y^2 < 0, we do not intersect
*/
float dist = (
sphereRadiusSquared +
(distanceAlongRay * distanceAlongRay) -
differenceLengthSquared
);
result = (dist < 0) ? null : distanceAlongRay - (float?) Math.Sqrt(dist);
}
#endregion
#region Public Static Methods
public static bool operator !=(Ray a, Ray b)
{
return !a.Equals(b);
}
public static bool operator ==(Ray a, Ray b)
{
return a.Equals(b);
}
public override string ToString()
{
return (
"{{Position:" + Position.ToString() +
" Direction:" + Direction.ToString() +
"}}"
);
}
#endregion
}
}