private float RayCastCallbackWrapper(ref RayCastInput input, int proxyId)
{
FixtureProxy proxy = ContactManager.BroadPhase.GetUserData(proxyId);
Fixture fixture = proxy.Fixture;
int index = proxy.ChildIndex;
RayCastOutput output;
bool hit = fixture.RayCast(out output, ref input, index);
if (hit)
{
float fraction = output.Fraction;
Vector2 point = (1.0f - fraction)*input.Point1 + fraction*input.Point2;
return _rayCastCallback(fixture, point, output.Normal, fraction);
}
return input.MaxFraction;
}
// From Real-time Collision Detection, p179.
public bool RayCast(out RayCastOutput output, ref RayCastInput input)
{
output = new RayCastOutput();
float tmin = -Settings.MaxFloat;
float tmax = Settings.MaxFloat;
Vector2 p = input.Point1;
Vector2 d = input.Point2 - input.Point1;
Vector2 absD = MathUtils.Abs(d);
Vector2 normal = Vector2.Zero;
for (int i = 0; i < 2; ++i)
{
float absD_i = i == 0 ? absD.X : absD.Y;
float lowerBound_i = i == 0 ? LowerBound.X : LowerBound.Y;
float upperBound_i = i == 0 ? UpperBound.X : UpperBound.Y;
float p_i = i == 0 ? p.X : p.Y;
if (absD_i < Settings.Epsilon)
{
// Parallel.
if (p_i < lowerBound_i || upperBound_i < p_i)
{
return false;
}
}
else
{
float d_i = i == 0 ? d.X : d.Y;
float inv_d = 1.0f / d_i;
float t1 = (lowerBound_i - p_i) * inv_d;
float t2 = (upperBound_i - p_i) * inv_d;
// Sign of the normal vector.
float s = -1.0f;
if (t1 > t2)
{
MathUtils.Swap(ref t1, ref t2);
s = 1.0f;
}
// Push the min up
if (t1 > tmin)
{
if (i == 0)
{
normal.X = s;
}
else
{
normal.Y = s;
}
tmin = t1;
}
// Pull the max down
tmax = Math.Min(tmax, t2);
if (tmin > tmax)
{
return false;
}
}
}
// Does the ray start inside the box?
// Does the ray intersect beyond the max fraction?
if (tmin < 0.0f || input.MaxFraction < tmin)
{
return false;
}
// Intersection.
output.Fraction = tmin;
output.Normal = normal;
return true;
}
/// <summary>
/// Ray-cast the world for all fixtures in the path of the ray. Your callback
/// controls whether you get the closest point, any point, or n-points.
/// The ray-cast ignores shapes that contain the starting point.
/// </summary>
/// <param name="callback">A user implemented callback class.</param>
/// <param name="point1">The ray starting point.</param>
/// <param name="point2">The ray ending point.</param>
public void RayCast(RayCastCallback callback, Vector2 point1, Vector2 point2)
{
RayCastInput input = new RayCastInput();
input.MaxFraction = 1.0f;
input.Point1 = point1;
input.Point2 = point2;
_rayCastCallback = callback;
ContactManager.BroadPhase.RayCast(_rayCastCallbackWrapper, ref input);
_rayCastCallback = null;
}
public void CheckOnGround()
{
RayCastInput input = new RayCastInput();
input.Point1 = player.PhysObj.Position;
input.Point2 = input.Point1 + 10 * new Vector2((float)Math.Sin(0), (float)Math.Cos(0));
input.MaxFraction = 1;
float closest = 1;
foreach (Body b in world.world.BodyList)
{
if (b.Enabled)
foreach (Fixture f in b.FixtureList)
{
if (f.CollisionCategories == Category.Cat16 || f.CollisionCategories == Category.Cat25)
continue;
RayCastOutput output;
if (!f.RayCast(out output, ref input, 0))
continue;
if (output.Fraction < closest)
{
closest = output.Fraction;
}
}
}
onGround = closest < 0.8f;
}
/// <summary>
/// Ray-cast the world for all fixtures in the path of the ray. Your callback
/// controls whether you get the closest point, any point, or n-points.
/// The ray-cast ignores shapes that contain the starting point.
///
/// Inside the callback:
/// return -1: ignore this fixture and continue
/// return 0: terminate the ray cast
/// return fraction: clip the ray to this point
/// return 1: don't clip the ray and continue
/// </summary>
/// <param name="callback">A user implemented callback class.</param>
/// <param name="point1">The ray starting point.</param>
/// <param name="point2">The ray ending point.</param>
public void RayCast(RayCastCallback callback, Vector2 point1, Vector2 point2)
{
RayCastInput input = new RayCastInput();
input.MaxFraction = 1.0f;
input.Point1 = point1;
input.Point2 = point2;
ContactManager.BroadPhase.RayCast((rayCastInput, proxyId) =>
{
FixtureProxy proxy = ContactManager.BroadPhase.GetProxy(proxyId);
Fixture fixture = proxy.Fixture;
int index = proxy.ChildIndex;
RayCastOutput output;
bool hit = fixture.RayCast(out output, ref rayCastInput, index);
if (hit)
{
float fraction = output.Fraction;
Vector2 point = (1.0f - fraction) * input.Point1 +
fraction * input.Point2;
return callback(fixture, point, output.Normal, fraction);
}
return input.MaxFraction;
}, ref input);
}
/// <summary>
/// Cast a ray against this Shape.
/// </summary>
/// <param name="output">The ray-cast results.</param>
/// <param name="input">The ray-cast input parameters.</param>
/// <param name="childIndex">Index of the child.</param>
/// <returns></returns>
public bool RayCast(out RayCastOutput output, ref RayCastInput input, int childIndex)
{
return Shape.RayCast(out output, ref input, ref Body.Xf, childIndex);
}
public void RayCast(Func<RayCastInput, int, float> callback, ref RayCastInput input)
{
_quadTree.RayCast(TransformRayCallback(callback), ref input);
}
public float RayCastCallback(ref RayCastInput input, int proxyId)
{
FixtureProxy proxy = ContactManager.BroadPhase.GetProxy(proxyId);
Fixture fixture = proxy.Fixture;
int index = proxy.ChildIndex;
RayCastOutput output;
bool hit = fixture.RayCast(out output, ref input, index);
if (hit)
{
float fraction = output.Fraction;
Vector2 point = (1.0f - fraction) * input.Point1 + fraction * input.Point2;
if (rayCastCallback != null)
{
return rayCastCallback(fixture, point, output.Normal, fraction);
}
return PressPlay.FFWD.RaycastHelper.rayCastCallback(fixture, point, output.Normal, fraction);
}
return input.MaxFraction;
}
private float RayCastCallback(ref RayCastInput input, int proxyid)
{
Actor actor = _tree.GetUserData(proxyid);
RayCastOutput output;
bool hit = actor.AABB.RayCast(out output, ref input);
if (hit)
{
_rayCastOutput = output;
_rayActor = actor;
actor.Fraction = output.Fraction;
return output.Fraction;
}
return input.MaxFraction;
}
float rayCastCallbackWrapper( RayCastInput rayCastInput, int proxyId )
{
var proxy = contactManager.broadPhase.getProxy( proxyId );
var fixture = proxy.fixture;
int index = proxy.childIndex;
RayCastOutput output;
bool hit = fixture.rayCast( out output, ref rayCastInput, index );
if( hit )
{
var fraction = output.Fraction;
var point = ( 1.0f - fraction ) * rayCastInput.Point1 + fraction * rayCastInput.Point2;
return _rayCastCallback( fixture, point, output.Normal, fraction );
}
return rayCastInput.MaxFraction;
}
/// <summary>
/// Ray-cast the world for all fixtures in the path of the ray. Your callback
/// controls whether you get the closest point, any point, or n-points.
/// The ray-cast ignores shapes that contain the starting point.
///
/// Inside the callback:
/// return -1: ignore this fixture and continue
/// return 0: terminate the ray cast
/// return fraction: clip the ray to this point
/// return 1: don't clip the ray and continue
/// </summary>
/// <param name="callback">A user implemented callback class.</param>
/// <param name="point1">The ray starting point.</param>
/// <param name="point2">The ray ending point.</param>
public void rayCast( Func<Fixture, Vector2, Vector2, float, float> callback, Vector2 point1, Vector2 point2 )
{
var input = new RayCastInput();
input.MaxFraction = 1.0f;
input.Point1 = point1;
input.Point2 = point2;
_rayCastCallback = callback;
contactManager.broadPhase.rayCast( _rayCastCallbackWrapper, ref input );
_rayCastCallback = null;
}
internal static bool Raycast(Body body, Ray ray, out RaycastHit hitInfo, float distance)
{
RayCastOutput output;
RayCastInput input = new RayCastInput() { Point1 = ray.origin, Point2 = ray.origin + ray.direction, MaxFraction = distance };
hitInfo = new RaycastHit() { body = body };
for (int i = 0; i < body.FixtureList.Count; i++)
{
if (body.FixtureList[i].RayCast(out output, ref input, 0))
{
hitInfo.collider = body.UserData;
hitInfo.transform = body.UserData.transform;
hitInfo.normal = VectorConverter.Convert(output.Normal, body.UserData.to2dMode);
hitInfo.distance = output.Fraction;
hitInfo.point = ray.GetPoint(output.Fraction);
return true;
}
}
return false;
}
/// <summary>
/// Cast a ray against this Shape.
/// </summary>
/// <param name="output">The ray-cast results.</param>
/// <param name="input">The ray-cast input parameters.</param>
/// <param name="childIndex">Index of the child.</param>
/// <returns></returns>
public bool RayCast(out RayCastOutput output, ref RayCastInput input, int childIndex)
{
Transform xf;
Body.GetTransform(out xf);
return Shape.RayCast(out output, ref input, ref xf, childIndex);
}
public void RayCast(Func<RayCastInput, int, float> callback, ref RayCastInput input, Category categories)
{
for (int i = 0, categoryBits = (int)categories; categoryBits != 0; i++, categoryBits >>= 1)
if ((categoryBits & 1) != 0)
_quadTrees[i].RayCast(TransformRayCallback(callback), ref input);
}