static void GenerateJoining(JoiningInfo joinInfo, PathCorner corner, float halfThickness, float tippedCornerLimit, TessellationOptions tessellateOptions, List <Vector2> verts, List <UInt16> inds)
{
// The joining generates the vertices at both ends as well as the joining itself
if (verts.Count == 0)
{
// Starting a path with a joining (meaning a loop)
verts.Add(joinInfo.RoundPosThickness ? joinInfo.PosThicknessEnd : joinInfo.InnerCornerVertex);
verts.Add(joinInfo.RoundPosThickness ? joinInfo.InnerCornerVertex : joinInfo.NegThicknessEnd);
}
System.Diagnostics.Debug.Assert(verts.Count >= 2);
int indexStart = verts.Count - 2; // Using the last two vertices
// Convert a tipped corner to a beveled one if tippedCornerLimit ratio is reached
if (corner == PathCorner.Tipped && tippedCornerLimit >= 1.0f)
{
var theta = Vector2.Angle(-joinInfo.TanAtEnd, joinInfo.TanAtStart) * Mathf.Deg2Rad;
var ratio = 1.0f / Mathf.Sin(theta / 2.0f);
if (ratio > tippedCornerLimit)
{
corner = PathCorner.Beveled;
}
}
if (joinInfo.SimpleJoin)
{
// TODO
}
else if (corner == PathCorner.Tipped)
{
verts.Add(joinInfo.PosThicknessClosingPoint);
verts.Add(joinInfo.NegThicknessClosingPoint);
verts.Add(joinInfo.RoundPosThickness ? joinInfo.PosThicknessStart : joinInfo.InnerCornerVertex);
verts.Add(joinInfo.RoundPosThickness ? joinInfo.InnerCornerVertex : joinInfo.NegThicknessStart);
// Ending to tip
inds.Add((UInt16)(indexStart + 0));
inds.Add((UInt16)(indexStart + 3));
inds.Add((UInt16)(indexStart + 1));
inds.Add((UInt16)(indexStart + 0));
inds.Add((UInt16)(indexStart + 2));
inds.Add((UInt16)(indexStart + 3));
// Tip to starting
inds.Add((UInt16)(indexStart + 4));
inds.Add((UInt16)(indexStart + 3));
inds.Add((UInt16)(indexStart + 2));
inds.Add((UInt16)(indexStart + 4));
inds.Add((UInt16)(indexStart + 5));
inds.Add((UInt16)(indexStart + 3));
return;
}
else if (corner == PathCorner.Beveled)
{
verts.Add(joinInfo.RoundPosThickness ? joinInfo.PosThicknessEnd : joinInfo.InnerCornerVertex); // 2
verts.Add(joinInfo.RoundPosThickness ? joinInfo.InnerCornerVertex : joinInfo.NegThicknessEnd); // 3
verts.Add(joinInfo.RoundPosThickness ? joinInfo.PosThicknessStart : joinInfo.InnerCornerVertex); // 4
verts.Add(joinInfo.RoundPosThickness ? joinInfo.InnerCornerVertex : joinInfo.NegThicknessStart); // 5
// Ending to tip
inds.Add((UInt16)(indexStart + 0));
inds.Add((UInt16)(indexStart + 2));
inds.Add((UInt16)(indexStart + 1));
inds.Add((UInt16)(indexStart + 1));
inds.Add((UInt16)(indexStart + 2));
inds.Add((UInt16)(indexStart + 3));
// Bevel
if (joinInfo.RoundPosThickness)
{
inds.Add((UInt16)(indexStart + 2));
inds.Add((UInt16)(indexStart + 4));
inds.Add((UInt16)(indexStart + 3));
}
else
{
inds.Add((UInt16)(indexStart + 3));
inds.Add((UInt16)(indexStart + 2));
inds.Add((UInt16)(indexStart + 5));
}
return;
}
if (corner == PathCorner.Round)
{
float sweepAngle = Mathf.Acos(Vector2.Dot(joinInfo.NormAtEnd, joinInfo.NormAtStart));
bool flipArc = false;
if (!PointOnTheLeftOfLine(Vector2.zero, joinInfo.NormAtEnd, joinInfo.NormAtStart))
{
sweepAngle = -sweepAngle;
flipArc = true;
}
UInt16 innerCornerVertexIndex = (UInt16)verts.Count;
verts.Add(joinInfo.InnerCornerVertex);
int arcSegments = CalculateArcSteps(halfThickness, 0, sweepAngle, tessellateOptions);
for (int i = 0; i <= arcSegments; i++)
{
float angle = sweepAngle * (i / (float)arcSegments);
Vector2 nrm = Matrix2D.RotateLH(angle) * joinInfo.NormAtEnd;
if (flipArc)
{
nrm = -nrm;
}
verts.Add(nrm * halfThickness + joinInfo.JoinPos);
if (i == 0)
{
inds.Add((UInt16)(indexStart + 0));
inds.Add((UInt16)(indexStart + 3));
inds.Add((UInt16)(indexStart + (joinInfo.RoundPosThickness ? 2 : 1)));
inds.Add((UInt16)(indexStart + 0));
inds.Add((UInt16)(indexStart + 2));
inds.Add((UInt16)(indexStart + (joinInfo.RoundPosThickness ? 1 : 3)));
}
else
{
if (joinInfo.RoundPosThickness)
{
inds.Add((UInt16)(indexStart + i + (flipArc ? 3 : 2)));
inds.Add((UInt16)(indexStart + i + (flipArc ? 2 : 3)));
inds.Add(innerCornerVertexIndex);
}
else
{
inds.Add((UInt16)(indexStart + i + (flipArc ? 3 : 2)));
inds.Add((UInt16)(indexStart + i + (flipArc ? 2 : 3)));
inds.Add(innerCornerVertexIndex);
}
}
}
// Manually add the last segment, maintain the expected vertex positioning
int endingVerticesIndex = verts.Count;
if (joinInfo.RoundPosThickness)
{
verts.Add(joinInfo.PosThicknessStart);
verts.Add(joinInfo.InnerCornerVertex);
}
else
{
verts.Add(joinInfo.InnerCornerVertex);
verts.Add(joinInfo.NegThicknessStart);
}
inds.Add((UInt16)(endingVerticesIndex - 1));
inds.Add((UInt16)(endingVerticesIndex + 0));
inds.Add(innerCornerVertexIndex);
}
}
/// <summary>
/// Tessellates a path.
/// </summary>
/// <param name="contour">The path to tessellate</param>
/// <param name="pathProps">The path properties</param>
/// <param name="tessellateOptions">The tessellation options</param>
/// <param name="vertices">The resulting vertices</param>
/// <param name="indices">The resulting triangles</param>
/// <remarks>
/// The individual line segments generated during tessellation are made out of a set of ordered vertices. It is important
/// to honor this ordering so joining and and capping connect properly with the existing vertices without generating dupes.
/// The ordering assumed is as follows:
/// The last two vertices of a piece must be such that the first is generated at the end with a positive half-thickness
/// while the second vertex is at the end too but at a negative half-thickness.
/// No assumptions are enforced for other vertices before the two last vertices.
/// </remarks>
public static void TessellatePath(BezierContour contour, PathProperties pathProps, TessellationOptions tessellateOptions, out Vector2[] vertices, out UInt16[] indices)
{
if (tessellateOptions.StepDistance < Epsilon)
{
throw new Exception("stepDistance too small");
}
if (contour.Segments.Length < 2)
{
vertices = new Vector2[0];
indices = new UInt16[0];
return;
}
UnityEngine.Profiling.Profiler.BeginSample("TessellatePath");
float[] segmentLengths = VectorUtils.SegmentsLengths(contour.Segments, contour.Closed);
// Approximate the number of vertices/indices we need to store the results so we reduce memory reallocations during work
float approxTotalLength = 0.0f;
foreach (var s in segmentLengths)
{
approxTotalLength += s;
}
int approxStepCount = Math.Max((int)(approxTotalLength / tessellateOptions.StepDistance + 0.5f), 2);
if (pathProps.Stroke.Pattern != null)
{
approxStepCount += pathProps.Stroke.Pattern.Length * 2;
}
List <Vector2> verts = new List <Vector2>(approxStepCount * 2 + 32); // A little bit possibly for the endings
List <UInt16> inds = new List <UInt16>((int)(verts.Capacity * 1.5f)); // Usually every 4 verts represent a quad that uses 6 indices
var patternIt = new PathPatternIterator(pathProps.Stroke.Pattern, pathProps.Stroke.PatternOffset);
var pathIt = new PathDistanceForwardIterator(contour.Segments, contour.Closed, tessellateOptions.MaxCordDeviationSquared, tessellateOptions.MaxTanAngleDeviationCosine, tessellateOptions.SamplingStepSize);
JoiningInfo[] joiningInfo = new JoiningInfo[2];
HandleNewSegmentJoining(pathIt, patternIt, joiningInfo, pathProps.Stroke.HalfThickness, segmentLengths);
int rangeIndex = 0;
while (!pathIt.Ended)
{
if (patternIt.IsSolid)
{
TessellateRange(patternIt.SegmentLength, pathIt, patternIt, pathProps, tessellateOptions, joiningInfo, segmentLengths, approxTotalLength, rangeIndex++, verts, inds);
}
else
{
SkipRange(patternIt.SegmentLength, pathIt, patternIt, pathProps, joiningInfo, segmentLengths);
}
patternIt.Advance();
}
vertices = verts.ToArray();
indices = inds.ToArray();
UnityEngine.Profiling.Profiler.EndSample();
}
static JoiningInfo ForeseeJoining(BezierSegment end, BezierSegment start, float halfThickness, float endSegmentLength)
{
JoiningInfo joinInfo = new JoiningInfo();
// The joining generates the vertices at both ends as well as the joining itself
joinInfo.JoinPos = end.P3;
joinInfo.TanAtEnd = VectorUtils.EvalTangent(end, 1.0f);
joinInfo.NormAtEnd = Vector2.Perpendicular(joinInfo.TanAtEnd);
joinInfo.TanAtStart = VectorUtils.EvalTangent(start, 0.0f);
joinInfo.NormAtStart = Vector2.Perpendicular(joinInfo.TanAtStart);
// If the tangents are continuous at the join location, we don't have
// to generate a corner, we do a "simple" join by just connecting the vertices
// from the two segments directly
float cosAngleBetweenTans = Vector2.Dot(joinInfo.TanAtEnd, joinInfo.TanAtStart);
joinInfo.SimpleJoin = Mathf.Approximately(Mathf.Abs(cosAngleBetweenTans), 1.0f);
if (joinInfo.SimpleJoin)
{
return(null);
}
joinInfo.PosThicknessEnd = joinInfo.JoinPos + joinInfo.NormAtEnd * halfThickness;
joinInfo.NegThicknessEnd = joinInfo.JoinPos - joinInfo.NormAtEnd * halfThickness;
joinInfo.PosThicknessStart = joinInfo.JoinPos + joinInfo.NormAtStart * halfThickness;
joinInfo.NegThicknessStart = joinInfo.JoinPos - joinInfo.NormAtStart * halfThickness;
if (joinInfo.SimpleJoin)
{
joinInfo.PosThicknessClosingPoint = Vector2.LerpUnclamped(joinInfo.PosThicknessEnd, joinInfo.PosThicknessStart, 0.5f);
joinInfo.NegThicknessClosingPoint = Vector2.LerpUnclamped(joinInfo.NegThicknessEnd, joinInfo.NegThicknessStart, 0.5f);
}
else
{
joinInfo.PosThicknessClosingPoint = VectorUtils.IntersectLines(joinInfo.PosThicknessEnd, joinInfo.PosThicknessEnd + joinInfo.TanAtEnd, joinInfo.PosThicknessStart, joinInfo.PosThicknessStart + joinInfo.TanAtStart);
joinInfo.NegThicknessClosingPoint = VectorUtils.IntersectLines(joinInfo.NegThicknessEnd, joinInfo.NegThicknessEnd + joinInfo.TanAtEnd, joinInfo.NegThicknessStart, joinInfo.NegThicknessStart + joinInfo.TanAtStart);
if (float.IsInfinity(joinInfo.PosThicknessClosingPoint.x) || float.IsInfinity(joinInfo.PosThicknessClosingPoint.y))
{
joinInfo.PosThicknessClosingPoint = joinInfo.JoinPos;
}
if (float.IsInfinity(joinInfo.NegThicknessClosingPoint.x) || float.IsInfinity(joinInfo.NegThicknessClosingPoint.y))
{
joinInfo.NegThicknessClosingPoint = joinInfo.JoinPos;
}
}
// Should we round the positive thickness side or the negative thickness side?
joinInfo.RoundPosThickness = PointOnTheLeftOfLine(Vector2.zero, joinInfo.TanAtEnd, joinInfo.TanAtStart);
// Inner corner vertex should be calculated by intersection of the inner segments
Vector2[] startTrail = null, endTrail = null;
Vector2 intersectionOnStart = Vector2.zero, intersectionOnEnd = Vector2.zero;
if (!joinInfo.SimpleJoin)
{
BezierSegment endFlipped = VectorUtils.FlipSegment(end);
Vector2 thicknessClosingPoint = joinInfo.RoundPosThickness ? joinInfo.PosThicknessClosingPoint : joinInfo.NegThicknessClosingPoint;
Vector2 meetingPoint = end.P3;
Vector2 thicknessDiagonalEnd = meetingPoint + (thicknessClosingPoint - meetingPoint) * 10.0f;
startTrail = LineBezierThicknessIntersect(
start, joinInfo.RoundPosThickness ? -halfThickness : halfThickness, meetingPoint, thicknessDiagonalEnd,
out joinInfo.InnerCornerDistFromStart, out intersectionOnStart);
endTrail = LineBezierThicknessIntersect(
endFlipped, joinInfo.RoundPosThickness ? halfThickness : -halfThickness, meetingPoint, thicknessDiagonalEnd,
out joinInfo.InnerCornerDistToEnd, out intersectionOnEnd);
}
bool intersectionFound = false;
if ((startTrail != null) && (endTrail != null))
{
var intersect = VectorUtils.IntersectLines(startTrail[0], startTrail[1], endTrail[0], endTrail[1]);
var isOnStartTrail = PointOnLineIsWithinSegment(startTrail[0], startTrail[1], intersect);
var isOnEndTrail = PointOnLineIsWithinSegment(endTrail[0], endTrail[1], intersect);
if (!float.IsInfinity(intersect.x) && isOnStartTrail && isOnEndTrail)
{
var vStart = intersectionOnStart - intersect;
var vEnd = intersectionOnEnd - intersect;
joinInfo.InnerCornerDistFromStart += (vStart == Vector2.zero) ? 0.0f : vStart.magnitude;
joinInfo.InnerCornerDistToEnd += (vEnd == Vector2.zero) ? 0.0f : vEnd.magnitude;
joinInfo.InnerCornerDistToEnd = endSegmentLength - joinInfo.InnerCornerDistToEnd;
joinInfo.InnerCornerVertex = intersect; // Found it!
intersectionFound = true;
}
}
if (!intersectionFound)
{
joinInfo.InnerCornerVertex = joinInfo.JoinPos + ((joinInfo.TanAtStart - joinInfo.TanAtEnd) / 2.0f).normalized * halfThickness;
joinInfo.InnerCornerDistFromStart = 0;
joinInfo.InnerCornerDistToEnd = endSegmentLength;
}
return(joinInfo);
}