static void SkipRange(
float distance, PathDistanceForwardIterator pathIt, PathPatternIterator patternIt,
PathProperties pathProps, JoiningInfo[] joiningInfo, float[] segmentLengths)
{
float unitsRemaining = distance;
while (unitsRemaining > Epsilon)
{
var result = pathIt.AdvanceBy(unitsRemaining, out unitsRemaining);
switch (result)
{
case PathDistanceForwardIterator.Result.Ended:
return;
case PathDistanceForwardIterator.Result.Stepped:
if (unitsRemaining < Epsilon)
{
return;
}
break;
case PathDistanceForwardIterator.Result.NewSegment:
HandleNewSegmentJoining(pathIt, patternIt, joiningInfo, pathProps.Stroke.HalfThickness, segmentLengths);
break;
}
}
}
static void TessellateRange(
float distance, PathDistanceForwardIterator pathIt, PathPatternIterator patternIt, PathProperties pathProps,
TessellationOptions tessellateOptions, JoiningInfo[] joiningInfo, float[] segmentLengths, float totalLength, int rangeIndex, List <Vector2> verts, List <UInt16> inds)
{
bool startOfLoop = pathIt.Closed && (pathIt.CurrentSegment == 0) && (pathIt.CurrentT == 0.0f);
if (startOfLoop && (joiningInfo[0] != null))
{
GenerateJoining(joiningInfo[0], pathProps.Corners, pathProps.Stroke.HalfThickness, pathProps.Stroke.TippedCornerLimit, tessellateOptions, verts, inds);
}
else
{
var pathEnding = pathProps.Head;
// If pattern at the end will overlap with beginning, use a chopped ending to allow merging
if (pathIt.Closed && rangeIndex == 0 && patternIt.IsSolidAt(pathIt.CurrentT) && patternIt.IsSolidAt(totalLength))
{
pathEnding = PathEnding.Chop;
}
GenerateTip(VectorUtils.PathSegmentAtIndex(pathIt.Segments, pathIt.CurrentSegment), true, pathIt.CurrentT, pathEnding, pathProps.Stroke.HalfThickness, tessellateOptions, verts, inds);
}
float startingLength = pathIt.LengthSoFar;
float unitsRemaining = Mathf.Min(tessellateOptions.StepDistance, distance);
bool endedEntirePath = false;
for (;;)
{
var result = pathIt.AdvanceBy(unitsRemaining, out unitsRemaining);
if (result == PathDistanceForwardIterator.Result.Ended)
{
endedEntirePath = true;
break;
}
else if (result == PathDistanceForwardIterator.Result.NewSegment)
{
if (joiningInfo[1] != null)
{
GenerateJoining(joiningInfo[1], pathProps.Corners, pathProps.Stroke.HalfThickness, pathProps.Stroke.TippedCornerLimit, tessellateOptions, verts, inds);
}
else
{
AddSegment(VectorUtils.PathSegmentAtIndex(pathIt.Segments, pathIt.CurrentSegment), pathIt.CurrentT, pathProps.Stroke.HalfThickness, null, pathIt.SegmentLengthSoFar, verts, inds);
}
HandleNewSegmentJoining(pathIt, patternIt, joiningInfo, pathProps.Stroke.HalfThickness, segmentLengths);
}
if ((unitsRemaining <= Epsilon) &&
!TryGetMoreRemainingUnits(ref unitsRemaining, pathIt, startingLength, distance, tessellateOptions.StepDistance))
{
break;
}
if (result == PathDistanceForwardIterator.Result.Stepped)
{
AddSegment(VectorUtils.PathSegmentAtIndex(pathIt.Segments, pathIt.CurrentSegment), pathIt.CurrentT, pathProps.Stroke.HalfThickness, joiningInfo, pathIt.SegmentLengthSoFar, verts, inds);
}
}
// Ending
if (endedEntirePath && pathIt.Closed)
{
// No joining needed, the start and end of the path should just connect
inds.Add(0);
inds.Add(1);
inds.Add((UInt16)(verts.Count - 2));
inds.Add((UInt16)(verts.Count - 1));
inds.Add((UInt16)(verts.Count - 2));
inds.Add(1);
}
else
{
AddSegment(VectorUtils.PathSegmentAtIndex(pathIt.Segments, pathIt.CurrentSegment), pathIt.CurrentT, pathProps.Stroke.HalfThickness, joiningInfo, pathIt.SegmentLengthSoFar, verts, inds);
GenerateTip(VectorUtils.PathSegmentAtIndex(pathIt.Segments, pathIt.CurrentSegment), false, pathIt.CurrentT, pathProps.Tail, pathProps.Stroke.HalfThickness, tessellateOptions, verts, inds);
}
}
static Vector2[] TraceShape(BezierContour contour, Stroke stroke, TessellationOptions tessellateOptions)
{
if (tessellateOptions.StepDistance < Epsilon)
{
throw new Exception("stepDistance too small");
}
if (contour.Segments.Length < 2)
{
return(new Vector2[0]);
}
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);
var strokePattern = stroke != null ? stroke.Pattern : null;
var strokePatternOffset = stroke != null ? stroke.PatternOffset : 0.0f;
if (strokePattern != null)
{
approxStepCount += strokePattern.Length * 2;
}
List <Vector2> verts = new List <Vector2>(approxStepCount); // A little bit possibly for the endings
var patternIt = new PathPatternIterator(strokePattern, strokePatternOffset);
var pathIt = new PathDistanceForwardIterator(contour.Segments, true, tessellateOptions.MaxCordDeviationSquared, tessellateOptions.MaxTanAngleDeviationCosine, tessellateOptions.SamplingStepSize);
verts.Add(pathIt.EvalCurrent());
while (!pathIt.Ended)
{
float distance = patternIt.SegmentLength;
float startingLength = pathIt.LengthSoFar;
float unitsRemaining = Mathf.Min(tessellateOptions.StepDistance, distance);
bool endedEntirePath = false;
for (;;)
{
var result = pathIt.AdvanceBy(unitsRemaining, out unitsRemaining);
if (result == PathDistanceForwardIterator.Result.Ended)
{
endedEntirePath = true;
break;
}
else if (result == PathDistanceForwardIterator.Result.NewSegment)
{
verts.Add(pathIt.EvalCurrent());
}
if ((unitsRemaining <= Epsilon) &&
!TryGetMoreRemainingUnits(ref unitsRemaining, pathIt, startingLength, distance, tessellateOptions.StepDistance))
{
break;
}
if (result == PathDistanceForwardIterator.Result.Stepped)
{
verts.Add(pathIt.EvalCurrent());
}
}
// Ending
if (endedEntirePath)
{
break;
}
else
{
verts.Add(pathIt.EvalCurrent());
}
patternIt.Advance();
}
if ((verts[0] - verts[verts.Count - 1]).sqrMagnitude < Epsilon)
{
verts.RemoveAt(verts.Count - 1);
}
return(verts.ToArray()); // Why not return verts itself?
}
