/// <summary>
/// Computes an intersection of the line and the sphere
/// </summary>
public static bool IntersectLineSphere(Vector3 origin, Vector3 direction, Vector3 center, float radius,
out Vector3 pointA, out Vector3 pointB)
{
Vector3 toCenter = center - origin;
float toCenterOnLine = Vector3.Dot(toCenter, direction);
float sqrDistanceToLine = toCenter.sqrMagnitude - toCenterOnLine * toCenterOnLine;
float sqrRadius = radius * radius;
if (sqrDistanceToLine > sqrRadius)
{
pointA = Vector3.zero;
pointB = Vector3.zero;
return(false);
}
float fromClosestPointToIntersection = Mathf.Sqrt(sqrRadius - sqrDistanceToLine);
float intersectionA = toCenterOnLine - fromClosestPointToIntersection;
float intersectionB = toCenterOnLine + fromClosestPointToIntersection;
if (intersectionA > intersectionB)
{
PTUtils.Swap(ref intersectionA, ref intersectionB);
}
pointA = origin + intersectionA * direction;
pointB = origin + intersectionB * direction;
return(true);
}
public void Simulate()
{
PTUtils.Swap(ref _cells, ref copy);
for (int x = 0; x < config.width; x++)
{
for (int y = 0; y < config.height; y++)
{
int aliveCells = CountAliveNeighbourCells(x, y);
if (!copy[x, y])
{
if (config.ruleset.CanSpawn(aliveCells))
{
cells[x, y] = true;
}
else
{
cells[x, y] = false;
}
}
else
{
if (!config.ruleset.CanSurvive(aliveCells))
{
cells[x, y] = false;
}
else
{
cells[x, y] = true;
}
}
}
}
}
/// <summary>
/// Draws aliased line and calls <paramref name="draw"/> on every pixel
/// </summary>
/// <remarks>
/// https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
/// </remarks>
public static void RasterLine(int x0, int y0, int x1, int y1, Action <int, int> draw)
{
bool steep = Math.Abs(y1 - y0) > Math.Abs(x1 - x0);
if (steep)
{
PTUtils.Swap(ref x0, ref y0);
PTUtils.Swap(ref x1, ref y1);
}
if (x0 > x1)
{
PTUtils.Swap(ref x0, ref x1);
PTUtils.Swap(ref y0, ref y1);
}
int dx = x1 - x0;
int dy = Math.Abs(y1 - y0);
int error = dx / 2;
int ystep = (y0 < y1) ? 1 : -1;
int y = y0;
for (int x = x0; x <= x1; x++)
{
draw(steep ? y : x, steep ? x : y);
error -= dy;
if (error < 0)
{
y += ystep;
error += dx;
}
}
}
/// <summary>
/// Reverses winding order of mesh triangles
/// </summary>
public static void FlipTriangles(this Mesh mesh)
{
for (int i = 0; i < mesh.subMeshCount; i++)
{
var triangles = mesh.GetTriangles(i);
for (int j = 0; j < triangles.Length; j += 3)
{
PTUtils.Swap(ref triangles[j], ref triangles[j + 1]);
}
mesh.SetTriangles(triangles, i);
}
}
/// <summary>
/// Reverses winding order of mesh triangles
/// </summary>
public static void FlipTriangles(this Mesh mesh)
{
if (mesh == null)
{
throw new ArgumentNullException("mesh");
}
for (int i = 0; i < mesh.subMeshCount; i++)
{
var triangles = mesh.GetTriangles(i);
for (int j = 0; j < triangles.Length; j += 3)
{
PTUtils.Swap(ref triangles[j], ref triangles[j + 1]);
}
mesh.SetTriangles(triangles, i);
}
}
/// <summary>
/// Draws anti-aliased line and calls <paramref name="draw"/> on every pixel
/// </summary>
/// <remarks>
/// https://en.wikipedia.org/wiki/Xiaolin_Wu%27s_line_algorithm
/// </remarks>
public static void RasterAALine(int x0, int y0, int x1, int y1, Action <int, int, float> draw)
{
bool steep = Math.Abs(y1 - y0) > Math.Abs(x1 - x0);
if (steep)
{
PTUtils.Swap(ref x0, ref y0);
PTUtils.Swap(ref x1, ref y1);
}
if (x0 > x1)
{
PTUtils.Swap(ref x0, ref x1);
PTUtils.Swap(ref y0, ref y1);
}
if (steep)
{
draw(y0, x0, 1);
draw(y1, x1, 1);
}
else
{
draw(x0, y0, 1);
draw(x1, y1, 1);
}
float dx = x1 - x0;
float dy = y1 - y0;
float gradient = dy / dx;
float y = y0 + gradient;
for (var x = x0 + 1; x <= x1 - 1; x++)
{
if (steep)
{
draw((int)y, x, 1 - (y - (int)y));
draw((int)y + 1, x, y - (int)y);
}
else
{
draw(x, (int)y, 1 - (y - (int)y));
draw(x, (int)y + 1, y - (int)y);
}
y += gradient;
}
}
/// <summary>
/// Returns the distance between the closest points on the segments
/// </summary>
public static float SegmentSegment(Vector2 segment1A, Vector2 segment1B, Vector2 segment2A, Vector2 segment2B)
{
Vector2 from2ATo1A = segment1A - segment2A;
Vector2 direction1 = segment1B - segment1A;
Vector2 direction2 = segment2B - segment2A;
float segment1Length = direction1.magnitude;
float segment2Length = direction2.magnitude;
bool segment1IsAPoint = segment1Length < Geometry.Epsilon;
bool segment2IsAPoint = segment2Length < Geometry.Epsilon;
if (segment1IsAPoint && segment2IsAPoint)
{
return(Vector2.Distance(segment1A, segment2A));
}
if (segment1IsAPoint)
{
direction2.Normalize();
return(PointSegment(segment1A, segment2A, segment2B, direction2, segment2Length));
}
if (segment2IsAPoint)
{
direction1.Normalize();
return(PointSegment(segment2A, segment1A, segment1B, direction1, segment1Length));
}
direction1.Normalize();
direction2.Normalize();
float denominator = VectorE.PerpDot(direction1, direction2);
float perpDot1 = VectorE.PerpDot(direction1, from2ATo1A);
float perpDot2 = VectorE.PerpDot(direction2, from2ATo1A);
if (Mathf.Abs(denominator) < Geometry.Epsilon)
{
// Parallel
if (Mathf.Abs(perpDot1) > Geometry.Epsilon || Mathf.Abs(perpDot2) > Geometry.Epsilon)
{
// Not collinear
float segment2AProjection = -Vector2.Dot(direction1, from2ATo1A);
if (segment2AProjection > -Geometry.Epsilon &&
segment2AProjection < segment1Length + Geometry.Epsilon)
{
float distanceSqr = from2ATo1A.sqrMagnitude - segment2AProjection * segment2AProjection;
// distanceSqr can be negative
return(distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr));
}
Vector2 from1ATo2B = segment2B - segment1A;
float segment2BProjection = Vector2.Dot(direction1, from1ATo2B);
if (segment2BProjection > -Geometry.Epsilon &&
segment2BProjection < segment1Length + Geometry.Epsilon)
{
float distanceSqr = from1ATo2B.sqrMagnitude - segment2BProjection * segment2BProjection;
// distanceSqr can be negative
return(distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr));
}
if (segment2AProjection < 0 && segment2BProjection < 0)
{
if (segment2AProjection > segment2BProjection)
{
return(Vector2.Distance(segment1A, segment2A));
}
return(Vector2.Distance(segment1A, segment2B));
}
if (segment2AProjection > 0 && segment2BProjection > 0)
{
if (segment2AProjection < segment2BProjection)
{
return(Vector2.Distance(segment1B, segment2A));
}
return(Vector2.Distance(segment1B, segment2B));
}
float segment1AProjection = Vector2.Dot(direction2, from2ATo1A);
Vector2 segment2Point = segment2A + direction2 * segment1AProjection;
return(Vector2.Distance(segment1A, segment2Point));
}
// Collinear
bool codirected = Vector2.Dot(direction1, direction2) > 0;
if (codirected)
{
// Codirected
float segment2AProjection = -Vector2.Dot(direction1, from2ATo1A);
if (segment2AProjection > -Geometry.Epsilon)
{
// 1A------1B
// 2A------2B
return(SegmentSegmentCollinear(segment1A, segment1B, segment2A));
}
else
{
// 1A------1B
// 2A------2B
return(SegmentSegmentCollinear(segment2A, segment2B, segment1A));
}
}
else
{
// Contradirected
float segment2BProjection = Vector2.Dot(direction1, segment2B - segment1A);
if (segment2BProjection > -Geometry.Epsilon)
{
// 1A------1B
// 2B------2A
return(SegmentSegmentCollinear(segment1A, segment1B, segment2B));
}
else
{
// 1A------1B
// 2B------2A
return(SegmentSegmentCollinear(segment2B, segment2A, segment1A));
}
}
}
// Not parallel
float distance1 = perpDot2 / denominator;
float distance2 = perpDot1 / denominator;
if (distance1 < -Geometry.Epsilon || distance1 > segment1Length + Geometry.Epsilon ||
distance2 < -Geometry.Epsilon || distance2 > segment2Length + Geometry.Epsilon)
{
// No intersection
bool codirected = Vector2.Dot(direction1, direction2) > 0;
Vector2 from1ATo2B;
if (!codirected)
{
PTUtils.Swap(ref segment2A, ref segment2B);
direction2 = -direction2;
from1ATo2B = -from2ATo1A;
from2ATo1A = segment1A - segment2A;
distance2 = segment2Length - distance2;
}
else
{
from1ATo2B = segment2B - segment1A;
}
Vector2 segment1Point;
Vector2 segment2Point;
float segment2AProjection = -Vector2.Dot(direction1, from2ATo1A);
float segment2BProjection = Vector2.Dot(direction1, from1ATo2B);
bool segment2AIsAfter1A = segment2AProjection > -Geometry.Epsilon;
bool segment2BIsBefore1B = segment2BProjection < segment1Length + Geometry.Epsilon;
bool segment2AOnSegment1 = segment2AIsAfter1A && segment2AProjection < segment1Length + Geometry.Epsilon;
bool segment2BOnSegment1 = segment2BProjection > -Geometry.Epsilon && segment2BIsBefore1B;
if (segment2AOnSegment1 && segment2BOnSegment1)
{
if (distance2 < -Geometry.Epsilon)
{
segment1Point = segment1A + direction1 * segment2AProjection;
segment2Point = segment2A;
}
else
{
segment1Point = segment1A + direction1 * segment2BProjection;
segment2Point = segment2B;
}
}
else if (!segment2AOnSegment1 && !segment2BOnSegment1)
{
if (!segment2AIsAfter1A && !segment2BIsBefore1B)
{
segment1Point = distance1 < -Geometry.Epsilon ? segment1A : segment1B;
}
else
{
// Not on segment
segment1Point = segment2AIsAfter1A ? segment1B : segment1A;
}
float segment1PointProjection = Vector2.Dot(direction2, segment1Point - segment2A);
segment1PointProjection = Mathf.Clamp(segment1PointProjection, 0, segment2Length);
segment2Point = segment2A + direction2 * segment1PointProjection;
}
else if (segment2AOnSegment1)
{
if (distance2 < -Geometry.Epsilon)
{
segment1Point = segment1A + direction1 * segment2AProjection;
segment2Point = segment2A;
}
else
{
segment1Point = segment1B;
float segment1PointProjection = Vector2.Dot(direction2, segment1Point - segment2A);
segment1PointProjection = Mathf.Clamp(segment1PointProjection, 0, segment2Length);
segment2Point = segment2A + direction2 * segment1PointProjection;
}
}
else
{
if (distance2 > segment2Length + Geometry.Epsilon)
{
segment1Point = segment1A + direction1 * segment2BProjection;
segment2Point = segment2B;
}
else
{
segment1Point = segment1A;
float segment1PointProjection = Vector2.Dot(direction2, segment1Point - segment2A);
segment1PointProjection = Mathf.Clamp(segment1PointProjection, 0, segment2Length);
segment2Point = segment2A + direction2 * segment1PointProjection;
}
}
return(Vector2.Distance(segment1Point, segment2Point));
}
// Point intersection
return(0);
}
/// <summary>
/// Returns the distance between the closest points on the ray and the segment
/// </summary>
public static float RaySegment(Vector2 rayOrigin, Vector2 rayDirection, Vector2 segmentA, Vector2 segmentB)
{
Vector2 segmentAToOrigin = rayOrigin - segmentA;
Vector2 segmentDirection = segmentB - segmentA;
float denominator = VectorE.PerpDot(rayDirection, segmentDirection);
float perpDotA = VectorE.PerpDot(rayDirection, segmentAToOrigin);
// Normalized direction gives more stable results
float perpDotB = VectorE.PerpDot(segmentDirection.normalized, segmentAToOrigin);
if (Mathf.Abs(denominator) < Geometry.Epsilon)
{
// Parallel
float segmentAProjection = -Vector2.Dot(rayDirection, segmentAToOrigin);
Vector2 originToSegmentB = segmentB - rayOrigin;
float segmentBProjection = Vector2.Dot(rayDirection, originToSegmentB);
if (Mathf.Abs(perpDotA) > Geometry.Epsilon || Mathf.Abs(perpDotB) > Geometry.Epsilon)
{
// Not collinear
if (segmentAProjection > -Geometry.Epsilon)
{
float distanceSqr = segmentAToOrigin.sqrMagnitude - segmentAProjection * segmentAProjection;
// distanceSqr can be negative
return(distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr));
}
if (segmentBProjection > -Geometry.Epsilon)
{
float distanceSqr = originToSegmentB.sqrMagnitude - segmentBProjection * segmentBProjection;
// distanceSqr can be negative
return(distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr));
}
if (segmentAProjection > segmentBProjection)
{
return(Vector2.Distance(rayOrigin, segmentA));
}
return(Vector2.Distance(rayOrigin, segmentB));
}
// Collinear
if (segmentAProjection > -Geometry.Epsilon || segmentBProjection > -Geometry.Epsilon)
{
// Point or segment intersection
return(0);
}
// No intersection
return(segmentAProjection > segmentBProjection ? -segmentAProjection : -segmentBProjection);
}
// Not parallel
float rayDistance = perpDotB / denominator;
float segmentDistance = perpDotA / denominator;
if (rayDistance < -Geometry.Epsilon ||
segmentDistance < -Geometry.Epsilon || segmentDistance > 1 + Geometry.Epsilon)
{
// No intersection
bool codirected = Vector2.Dot(rayDirection, segmentDirection) > 0;
Vector2 segmentBToOrigin;
if (!codirected)
{
PTUtils.Swap(ref segmentA, ref segmentB);
segmentDirection = -segmentDirection;
segmentBToOrigin = segmentAToOrigin;
segmentAToOrigin = rayOrigin - segmentA;
segmentDistance = 1 - segmentDistance;
}
else
{
segmentBToOrigin = rayOrigin - segmentB;
}
float segmentAProjection = -Vector2.Dot(rayDirection, segmentAToOrigin);
float segmentBProjection = -Vector2.Dot(rayDirection, segmentBToOrigin);
bool segmentAOnRay = segmentAProjection > -Geometry.Epsilon;
bool segmentBOnRay = segmentBProjection > -Geometry.Epsilon;
if (segmentAOnRay && segmentBOnRay)
{
if (segmentDistance < 0)
{
Vector2 rayPoint = rayOrigin + rayDirection * segmentAProjection;
Vector2 segmentPoint = segmentA;
return(Vector2.Distance(rayPoint, segmentPoint));
}
else
{
Vector2 rayPoint = rayOrigin + rayDirection * segmentBProjection;
Vector2 segmentPoint = segmentB;
return(Vector2.Distance(rayPoint, segmentPoint));
}
}
else if (!segmentAOnRay && segmentBOnRay)
{
if (segmentDistance < 0)
{
Vector2 rayPoint = rayOrigin;
Vector2 segmentPoint = segmentA;
return(Vector2.Distance(rayPoint, segmentPoint));
}
else if (segmentDistance > 1 + Geometry.Epsilon)
{
Vector2 rayPoint = rayOrigin + rayDirection * segmentBProjection;
Vector2 segmentPoint = segmentB;
return(Vector2.Distance(rayPoint, segmentPoint));
}
else
{
Vector2 rayPoint = rayOrigin;
float originProjection = Vector2.Dot(segmentDirection, segmentAToOrigin);
Vector2 segmentPoint = segmentA + segmentDirection * originProjection / segmentDirection.sqrMagnitude;
return(Vector2.Distance(rayPoint, segmentPoint));
}
}
else
{
// Not on ray
Vector2 rayPoint = rayOrigin;
float originProjection = Vector2.Dot(segmentDirection, segmentAToOrigin);
float sqrSegmentLength = segmentDirection.sqrMagnitude;
if (originProjection < 0)
{
return(Vector2.Distance(rayPoint, segmentA));
}
else if (originProjection > sqrSegmentLength)
{
return(Vector2.Distance(rayPoint, segmentB));
}
else
{
Vector2 segmentPoint = segmentA + segmentDirection * originProjection / sqrSegmentLength;
return(Vector2.Distance(rayPoint, segmentPoint));
}
}
}
// Point intersection
return(0);
}
