public override bool Raycast(JRay ray, out JRaycastHit hitData)
{
hitData = new JRaycastHit();
Vector3 directionToSphere = transform.position - ray.origin;
float radiusSquared = Radius * Radius;
float dotProduct = Vector3.Dot(directionToSphere, ray.direction);
float offset = directionToSphere.sqrMagnitude - (dotProduct * dotProduct);
float lengthFromSphereSurfaceToOffset = Mathf.Sqrt(radiusSquared - offset);
hitData.hit = false;
hitData.origin = ray.origin;
if (radiusSquared - offset < 0)
{
return(false);
}
hitData.hit = true;
hitData.hitCollider = this;
if (directionToSphere.sqrMagnitude < radiusSquared) // If it's inside the sphere
{
hitData.distance = dotProduct + lengthFromSphereSurfaceToOffset;
}
else
{
hitData.distance = dotProduct - lengthFromSphereSurfaceToOffset;
}
hitData.hitPoint = ray.origin + (ray.direction * hitData.distance);
return(true);
}
public bool Raycast(JRay ray, out JRaycastHit hitData)
{
List <JRaycastHit> hits = new List <JRaycastHit>();
for (int i = 0; i < _bodies.Count; i++)
{
JCollider[] colliders = _bodies[i].GetColliders();
for (int j = 0; j < colliders.Length; j++)
{
if (colliders[j].Raycast(ray, out hitData))
{
hits.Add(hitData);
}
}
}
if (hits.Count > 0)
{
JRaycastHit bestHit = hits[0];
for (int i = 1; i < hits.Count; i++)
{
if (hits[i].distance < bestHit.distance)
{
bestHit = hits[i];
}
}
hitData = bestHit;
return(true);
}
else
{
hitData = new JRaycastHit();
hitData.hit = false;
return(false);
}
}
public abstract bool Raycast(JRay ray, out JRaycastHit hitData);
public override bool Raycast(JRay ray, out JRaycastHit hitData)
{
hitData = new JRaycastHit();
hitData.hit = false;
Vector3 directionToCuboid = transform.position - ray.origin;
Vector3 rayDirectionDots = new Vector3(
Vector3.Dot(transform.right, ray.direction) + 0.0001f, // Super hacky cheat to make sure we don't divide by 0 later
Vector3.Dot(transform.up, ray.direction) + 0.0001f,
Vector3.Dot(transform.forward, ray.direction) + 0.0001f
);
Vector3 cuboidDirectionDots = new Vector3(
Vector3.Dot(transform.right, directionToCuboid),
Vector3.Dot(transform.up, directionToCuboid),
Vector3.Dot(transform.forward, directionToCuboid)
);
float[] distances = new float[6];
for (int i = 0; i < 3; i++)
{
/*if(-cuboidDirectionDots[i] - Extents[i] > 0 || -cuboidDirectionDots[i] + Extents[i] < 0)
* {
* return false;
* }*/
distances[i * 2 + 0] = (cuboidDirectionDots[i] + Extents[i]) / rayDirectionDots[i];
distances[i * 2 + 1] = (cuboidDirectionDots[i] - Extents[i]) / rayDirectionDots[i];
}
float largestMinimumDistance = Mathf.Max(
Mathf.Min(distances[0], distances[1]),
Mathf.Min(distances[2], distances[3]),
Mathf.Min(distances[4], distances[5])
);
float smallestMaximumDistance = Mathf.Min(
Mathf.Max(distances[0], distances[1]),
Mathf.Max(distances[2], distances[3]),
Mathf.Max(distances[4], distances[5])
);
if (smallestMaximumDistance < 0) // This means our best point is behind the origin, and that doesn't make sense, so we'll cull it.
{
return(false);
}
if (largestMinimumDistance > smallestMaximumDistance)
{
return(false);
}
hitData.hit = true;
hitData.hitCollider = this;
hitData.origin = ray.origin;
if (largestMinimumDistance < 0)
{
hitData.distance = smallestMaximumDistance;
}
else
{
hitData.distance = largestMinimumDistance;
}
hitData.hitPoint = ray.origin + (ray.direction * hitData.distance);
return(true);
}
public override bool Raycast(JRay ray, out JRaycastHit hitData)
{
hitData = new JRaycastHit();
return(false);
}
