public static Mesh StrokeMesh(List<StrokeSegment[]> segments, float thickness, Color32 color, StrokeLineJoin lineJoin, StrokeLineCap lineCap, float miterLimit = 4f, float[] dashArray = null, float dashOffset = 0f, ClosePathRule closeLine = ClosePathRule.NEVER, float roundQuality = 10f)
{
List<List<Vector2>> finalPoints = StrokeShape(segments, thickness, color, lineJoin, lineCap, miterLimit, dashArray, dashOffset, closeLine, roundQuality);
return TessellateStroke(finalPoints, color);
}
public static List<Vector2> Stroke(StrokeSegment[] segments, float thickness, Color32 color, StrokeLineJoin lineJoin, StrokeLineCap lineCap, float miterLimit = 4f, ClosePathRule closeLine = ClosePathRule.NEVER, float roundQuality = 10f)
{
if(segments == null || segments.Length == 0)
return null;
if(segments.Length == 1)
{
closeLine = ClosePathRule.NEVER;
} else if (closeLine == ClosePathRule.AUTO)
{
if(segments[0].startPoint == segments[segments.Length-1].endPoint)
{
closeLine = ClosePathRule.ALWAYS;
} else {
closeLine = ClosePathRule.NEVER;
}
}
if(segments[0].startPoint == segments[segments.Length-1].endPoint)
{
List<StrokeSegment> tempSegments = new List<StrokeSegment>(segments);
tempSegments.RemoveAt(tempSegments.Count - 1);
segments = tempSegments.ToArray();
}
List<Vector2> innerPoints = new List<Vector2>();
List<Vector2> outerPoints = new List<Vector2>();
if(closeLine == ClosePathRule.ALWAYS)
{
List<StrokeSegment> tempSegments = new List<StrokeSegment>(segments);
tempSegments.Add(new StrokeSegment(segments[segments.Length -1].endPoint, segments[0].startPoint));
tempSegments.Add(new StrokeSegment(segments[0].startPoint, segments[0].endPoint));
segments = tempSegments.ToArray();
}
miterLimit = (miterLimit - 1f) * thickness * 2f;
if(miterLimit < 1f) miterLimit = 1f;
int i, i1, j, segmentsLength = segments.Length;
float segmentsAngle, segmentsAngleRotated, halfWidth = thickness * 0.5f,
angleProgress, radAngle = 0f, miterClipHalf = miterLimit * 0.5f, miterClipHalfDouble = miterClipHalf * miterClipHalf;
Vector2 segmentLeftStartA, segmentLeftEndA = Vector2.zero, segmentRightStartA, segmentRightEndA = Vector2.zero,
segmentLeftEndB, segmentRightEndB,
intersectionLeft, intersectionRight, segmentStartCenter;
Matrix4x4 rotationMatrix = Matrix4x4.TRS(Vector2.zero, Quaternion.Euler(0f, 0f, 90f), Vector2.one);
if(lineCap == StrokeLineCap.butt || closeLine == ClosePathRule.ALWAYS)
{
innerPoints.AddRange(new Vector2[]{
segments[0].startPoint - segments[0].directionNormalizedRotated * halfWidth,
segments[0].startPoint + segments[0].directionNormalizedRotated * halfWidth,
});
} else if(lineCap == StrokeLineCap.round)
{
segmentStartCenter = Vector2.Lerp(segments[0].startPoint - segments[0].directionNormalizedRotated * halfWidth,
segments[0].startPoint + segments[0].directionNormalizedRotated * halfWidth, 0.5f);
radAngle = Mathf.Atan2(segments[0].directionNormalizedRotated.y, segments[0].directionNormalizedRotated.x);
float roundSegmentsfAlt = roundQuality * thickness;
float roundSegmentsfAltMinusOne = roundSegmentsfAlt - 1;
if(roundSegmentsfAltMinusOne > 0)
{
for(j = 0; j <= roundSegmentsfAlt; j++)
{
angleProgress = 1f - Mathf.Clamp01(j / roundSegmentsfAltMinusOne);
innerPoints.Add(segmentStartCenter + new Vector2(Mathf.Cos(radAngle + angleProgress * Mathf.PI) * halfWidth, Mathf.Sin(radAngle + angleProgress * Mathf.PI) * halfWidth));
}
}
innerPoints.AddRange(new Vector2[]{
segments[0].startPoint + segments[0].directionNormalizedRotated * halfWidth,
});
outerPoints.AddRange(new Vector2[]{
segments[0].startPoint - segments[0].directionNormalizedRotated * halfWidth,
});
} else if(lineCap == StrokeLineCap.square)
{
innerPoints.AddRange(new Vector2[]{
segments[0].startPoint - segments[0].directionNormalized * halfWidth - segments[0].directionNormalizedRotated * halfWidth,
segments[0].startPoint - segments[0].directionNormalized * halfWidth + segments[0].directionNormalizedRotated * halfWidth,
});
}
if(segmentsLength > 1)
{
for(i = 1; i < segmentsLength; i++)
{
i1 = i - 1;
/*
if(segments[i1].length == 0f || segments[i].length == 0)
{
continue;
}
*/
segmentsAngle = Vector2.Dot(segments[i].directionNormalized, segments[i1].directionNormalized);
segmentsAngleRotated = Vector2.Dot(segments[i].directionNormalized, segments[i1].directionNormalizedRotated);
float miterLength = (1f / Mathf.Sin((Mathf.PI - Mathf.Acos(segmentsAngle)) * 0.5f)) * thickness;
float miterLengthHalf = miterLength * 0.5f;
Vector2 miterVector = Vector2.Lerp(segments[i1].directionNormalizedRotated, segments[i].directionNormalizedRotated, 0.5f).normalized;
Vector2 miterVectorLengthHalf = miterVector * miterLengthHalf;
Vector2 miterVectorRotated = rotationMatrix.MultiplyVector(miterVector);
segmentLeftStartA = segments[i].startPoint - segments[i].directionNormalizedRotated * halfWidth;
segmentLeftEndA = segments[i].endPoint - segments[i].directionNormalizedRotated * halfWidth;
segmentRightStartA = segments[i].startPoint + segments[i].directionNormalizedRotated * halfWidth;
segmentRightEndA = segments[i].endPoint + segments[i].directionNormalizedRotated * halfWidth;
//segmentLeftStartB = segments[i1].startPoint - segments[i1].directionNormalizedRotated * halfWidth;
segmentLeftEndB = segments[i1].endPoint - segments[i1].directionNormalizedRotated * halfWidth;
//segmentRightStartB = segments[i1].startPoint + segments[i1].directionNormalizedRotated * halfWidth;
segmentRightEndB = segments[i1].endPoint + segments[i1].directionNormalizedRotated * halfWidth;
if(lineJoin == StrokeLineJoin.miter)
{
if(miterLimit < miterLength)
lineJoin = StrokeLineJoin.bevel;
}
if(lineJoin == StrokeLineJoin.miter || lineJoin == StrokeLineJoin.miterClip)
{
if(segmentsAngle == 1f || segmentsAngle == -1f)
{
innerPoints.AddRange(new Vector2[]{
segmentRightEndB,
segmentRightStartA,
});
outerPoints.AddRange(new Vector2[]{
segmentLeftEndB,
segmentLeftStartA,
});
} else {
if(segmentsAngleRotated < 0)
{
if(miterLimit <= miterLength)
{
Vector2 a = segments[i1].endPoint + miterVector * miterClipHalf;
Vector2 b = segments[i1].endPoint + miterVectorLengthHalf;
Vector2 c = a + miterVectorRotated;
SVGMath.LineLineIntersection(out intersectionLeft, b, segmentRightEndB, a, c);
SVGMath.LineLineIntersection(out intersectionRight, b, segmentRightStartA, a, c);
if(miterClipHalfDouble <= (Vector2.Lerp(segmentRightEndB, segmentRightStartA, 0.5f) - segments[i1].endPoint).sqrMagnitude)
{
intersectionLeft = segmentRightEndB;
intersectionRight = segmentRightStartA;
}
innerPoints.AddRange(new Vector2[]{
intersectionLeft,
intersectionRight,
});
outerPoints.AddRange(new Vector2[]{
segmentLeftEndB,
segmentLeftStartA,
});
} else {
intersectionRight = segments[i1].endPoint + miterVectorLengthHalf;
innerPoints.AddRange(new Vector2[]{
intersectionRight,
});
outerPoints.AddRange(new Vector2[]{
segmentLeftEndB,
segmentLeftStartA,
});
}
} else {
if(miterLimit <= miterLength)
{
Vector2 a = segments[i1].endPoint - miterVector * miterClipHalf;
Vector2 b = segments[i1].endPoint - miterVectorLengthHalf;
Vector2 c = a + miterVectorRotated;
SVGMath.LineLineIntersection(out intersectionLeft, b, segmentLeftStartA, a, c);
SVGMath.LineLineIntersection(out intersectionRight, b, segmentLeftEndB, a, c);
if(miterClipHalfDouble <= (Vector2.Lerp(segmentLeftStartA, segmentLeftEndB, 0.5f) - segments[i1].endPoint).sqrMagnitude)
{
intersectionLeft = segmentLeftStartA;
intersectionRight = segmentLeftEndB;
}
outerPoints.AddRange(new Vector2[]{
intersectionRight,
intersectionLeft,
});
innerPoints.AddRange(new Vector2[]{
segmentRightEndB,
segmentRightStartA,
});
} else {
intersectionLeft = segments[i1].endPoint - miterVectorLengthHalf;
outerPoints.AddRange(new Vector2[]{
intersectionLeft,
});
innerPoints.AddRange(new Vector2[]{
segmentRightEndB,
segmentRightStartA,
});
}
}
}
} else if(lineJoin == StrokeLineJoin.bevel) {
innerPoints.AddRange(new Vector2[]{
segmentRightEndB,
segmentRightStartA,
});
outerPoints.AddRange(new Vector2[]{
segmentLeftEndB,
segmentLeftStartA,
});
} else if(lineJoin == StrokeLineJoin.round)
{
if(segmentsAngle == 1f)
{
innerPoints.AddRange(new Vector2[]{
segmentRightEndB,
segmentRightStartA,
});
outerPoints.AddRange(new Vector2[]{
segmentLeftEndB,
segmentLeftStartA,
});
} else {
if(segmentsAngleRotated < 0)
{
innerPoints.AddRange(new Vector2[]{
segmentRightEndB,
});
outerPoints.AddRange(new Vector2[]{
segmentLeftEndB,
segmentLeftStartA,
});
segmentStartCenter = segments[i].startPoint;
Vector2 dir = segments[i1].directionNormalizedRotated;
float angle = Mathf.Acos(Vector2.Dot(segments[i1].directionNormalized, segments[i].directionNormalized));
radAngle = Mathf.Atan2(dir.y, dir.x);
float roundSegmentsfAlt = roundQuality * thickness * (Mathf.Acos(segmentsAngle)/ Mathf.PI);
if(roundSegmentsfAlt < 1) roundSegmentsfAlt = 1f;
float roundSegmentsfAltMinusOne = roundSegmentsfAlt;
if(roundSegmentsfAltMinusOne > 0)
{
for(j = 0; j < roundSegmentsfAlt; j++)
{
angleProgress = Mathf.Clamp01(j / roundSegmentsfAltMinusOne);
innerPoints.Add(segmentStartCenter + new Vector2(Mathf.Cos(radAngle - angleProgress * angle) * halfWidth, Mathf.Sin(radAngle - angleProgress * angle) * halfWidth));
}
}
innerPoints.AddRange(new Vector2[]{
segmentRightStartA,
});
} else {
innerPoints.AddRange(new Vector2[]{
segmentRightEndB,
segmentRightStartA,
});
outerPoints.AddRange(new Vector2[]{
segmentLeftEndB,
});
segmentStartCenter = segments[i].startPoint;
Vector2 dir = -segments[i].directionNormalizedRotated;
float angle = Mathf.Acos(Vector2.Dot(segments[i1].directionNormalized, segments[i].directionNormalized));
radAngle = Mathf.Atan2(dir.y, dir.x);
float roundSegmentsfAlt = roundQuality * thickness * (Mathf.Acos(segmentsAngle)/ Mathf.PI);
if(roundSegmentsfAlt < 1) roundSegmentsfAlt = 1f;
float roundSegmentsfAltMinusOne = roundSegmentsfAlt;
if(roundSegmentsfAltMinusOne > 0)
{
for(j = 0; j < roundSegmentsfAlt; j++)
{
angleProgress = Mathf.Clamp01(1f -(j / roundSegmentsfAltMinusOne));
outerPoints.Add(segmentStartCenter + new Vector2(Mathf.Cos(radAngle - angleProgress * angle) * halfWidth, Mathf.Sin(radAngle - angleProgress * angle) * halfWidth));
}
}
outerPoints.AddRange(new Vector2[]{
segmentLeftStartA,
});
}
}
}
}
}
int lastSegmentIndex = segments.Length - 1;
segmentLeftStartA = segments[lastSegmentIndex].startPoint - segments[lastSegmentIndex].directionNormalizedRotated * halfWidth;
segmentLeftEndA = segments[lastSegmentIndex].endPoint - segments[lastSegmentIndex].directionNormalizedRotated * halfWidth;
segmentRightStartA = segments[lastSegmentIndex].startPoint + segments[lastSegmentIndex].directionNormalizedRotated * halfWidth;
segmentRightEndA = segments[lastSegmentIndex].endPoint + segments[lastSegmentIndex].directionNormalizedRotated * halfWidth;
if(closeLine == ClosePathRule.NEVER)
{
if(lineCap == StrokeLineCap.butt)
{
innerPoints.AddRange(new Vector2[]{
segmentRightEndA,
segmentLeftEndA,
});
} else if(lineCap == StrokeLineCap.round)
{
innerPoints.AddRange(new Vector2[]{
segmentRightEndA
});
outerPoints.AddRange(new Vector2[]{
segmentLeftEndA,
});
segmentStartCenter = Vector2.Lerp(segmentLeftEndA, segmentRightEndA, 0.5f);
radAngle = Mathf.Atan2(-segments[lastSegmentIndex].directionNormalizedRotated.y, -segments[lastSegmentIndex].directionNormalizedRotated.x);
float roundSegmentsfAlt = roundQuality * thickness;
float roundSegmentsfAltMinusOne = roundSegmentsfAlt - 1;
if(roundSegmentsfAltMinusOne > 0)
{
for(j = 0; j <= roundSegmentsfAlt; j++)
{
angleProgress = 1f - Mathf.Clamp01(j / roundSegmentsfAltMinusOne);
innerPoints.Add(segmentStartCenter + new Vector2(Mathf.Cos(radAngle + angleProgress * Mathf.PI) * halfWidth, Mathf.Sin(radAngle + angleProgress * Mathf.PI) * halfWidth));
}
}
} else if(lineCap == StrokeLineCap.square)
{
Vector2 lastSegmentOffset = segments[lastSegmentIndex].directionNormalized * halfWidth;
innerPoints.AddRange(new Vector2[]{
segmentRightEndA + lastSegmentOffset,
segmentLeftEndA + lastSegmentOffset,
});
}
}
if(closeLine == ClosePathRule.ALWAYS && lineJoin == StrokeLineJoin.miter || lineJoin == StrokeLineJoin.miterClip)
{
innerPoints.AddRange(new Vector2[]{
segmentRightEndA,
segmentLeftEndA,
});
}
outerPoints.Reverse();
innerPoints.AddRange(outerPoints);
return innerPoints;
}
public static List<List<Vector2>> StrokeShape(List<StrokeSegment[]> segments, float thickness, Color32 color, StrokeLineJoin lineJoin, StrokeLineCap lineCap, float miterLimit = 4f, float[] dashArray = null, float dashOffset = 0f, ClosePathRule closeLine = ClosePathRule.NEVER, float roundQuality = 10f)
{
if(segments == null || segments.Count == 0)
return null;
float totalCurveLength = 0f;
int i, j;
for(i = 0; i < segments.Count; i++)
{
if(segments[i] == null)
continue;
for(j = 0; j < segments[i].Length; j++)
{
totalCurveLength += segments[i][j].length;
}
}
if(totalCurveLength == 0f)
return null;
bool useDash;
ProcessDashArray(ref dashArray, out useDash);
ClosePathRule closeSegments = closeLine;
List<StrokeSegment[]> finalSegments = new List<StrokeSegment[]>();
for(i = 0; i < segments.Count; i++)
{
if(segments[i] == null || segments[i].Length == 0)
continue;
if(!useDash)
{
finalSegments.Add(segments[i]);
} else {
finalSegments.AddRange(CreateDashedStroke(segments[i], dashArray, dashOffset, ref closeSegments));
}
}
if(finalSegments.Count > 0)
{
List<List<Vector2>> finalPoints = new List<List<Vector2>>();
for(i = 0; i < finalSegments.Count; i++)
{
List<Vector2> points = Stroke(finalSegments[i], thickness, color, lineJoin, lineCap, miterLimit, closeSegments, roundQuality);
if(points == null || points.Count < 2)
continue;
finalPoints.Add(points);
}
return finalPoints;
} else {
return null;
}
}
public static List <List <Vector2> > StrokeShape(List <StrokeSegment[]> segments, float thickness, Color32 color, StrokeLineJoin lineJoin, StrokeLineCap lineCap, float miterLimit = 4f, float[] dashArray = null, float dashOffset = 0f, ClosePathRule closeLine = ClosePathRule.NEVER, float roundQuality = 10f)
{
if (segments == null || segments.Count == 0)
{
return(null);
}
float totalCurveLength = 0f;
int i, j;
for (i = 0; i < segments.Count; i++)
{
if (segments[i] == null)
{
continue;
}
for (j = 0; j < segments[i].Length; j++)
{
totalCurveLength += segments[i][j].length;
}
}
if (totalCurveLength == 0f)
{
return(null);
}
bool useDash;
ProcessDashArray(ref dashArray, out useDash);
ClosePathRule closeSegments = closeLine;
List <StrokeSegment[]> finalSegments = new List <StrokeSegment[]>();
for (i = 0; i < segments.Count; i++)
{
if (segments[i] == null || segments[i].Length == 0)
{
continue;
}
if (!useDash)
{
finalSegments.Add(segments[i]);
}
else
{
finalSegments.AddRange(CreateDashedStroke(segments[i], dashArray, dashOffset, ref closeSegments));
}
}
if (finalSegments.Count > 0)
{
List <List <Vector2> > finalPoints = new List <List <Vector2> >();
for (i = 0; i < finalSegments.Count; i++)
{
List <Vector2> points = Stroke(finalSegments[i], thickness, color, lineJoin, lineCap, miterLimit, closeSegments, roundQuality);
if (points == null || points.Count < 2)
{
continue;
}
List <List <Vector2> > simplifiedShape = SVGGeom.SimplifyPolygon(points);
for (j = 0; j < simplifiedShape.Count; j++)
{
if (simplifiedShape[j] == null || simplifiedShape[j].Count == 0)
{
continue;
}
finalPoints.Add(simplifiedShape[j]);
}
}
return(finalPoints);
}
else
{
return(null);
}
}
public static Mesh StrokeMesh(StrokeSegment[] segments, float thickness, Color32 color, StrokeLineJoin lineJoin, StrokeLineCap lineCap, float miterLimit = 4f, float[] dashArray = null, float dashOffset = 0f, ClosePathRule closeLine = ClosePathRule.NEVER, float roundQuality = 10f)
{
if (segments == null || segments.Length == 0)
{
return(null);
}
List <List <Vector2> > finalPoints = StrokeShape(new List <StrokeSegment[]>()
{
segments
}, thickness, color, lineJoin, lineCap, miterLimit, dashArray, dashOffset, closeLine, roundQuality);
return(TessellateStroke(finalPoints, color));
}
private static void GenerateLineJoints(List <Triangle> triangles, List <CurveTriangle> curveTriangles,
Curve prevCurve, Curve nextCurve, double halfWidth, StrokeLineJoin lineJoin, double miterLimit)
{
// First, calculate the difference between the angles to check where the joint need to be formed
var exitAngle = prevCurve.ExitAngle;
var entryAngle = nextCurve.EntryAngle;
var diff = (exitAngle - entryAngle).WrapAngle();
var sd = Math.Sign(diff);
// Skip creating the joint if the diff is small enough
if (RoughlyZero(diff))
{
return;
}
// The common point and the offset vectors
var p = (prevCurve.At(1) + nextCurve.At(0)) / 2;
var entryOffset = sd * halfWidth * Double2.FromAngle(entryAngle + Pi_2);
var exitOffset = sd * halfWidth * Double2.FromAngle(exitAngle + Pi_2);
// Calculate the bisector and miter length
var miter = halfWidth / Math.Cos(Math.Abs(diff) / 2);
var bisectorOffset = sd * miter * Double2.FromAngle(entryAngle + diff / 2 + Pi_2);
// Utility function for miter and round
Double2[] GenerateClippedTriangle(bool forRound)
{
var miterWidth = halfWidth * (forRound ? 1f : miterLimit);
if (miter < miterWidth)
{
return new[] { Double2.Zero, entryOffset, bisectorOffset, exitOffset }
}
;
else
{
// Clip the miter
var p1 = entryOffset + miterWidth * (bisectorOffset - entryOffset) / miter;
var p2 = exitOffset + miterWidth * (bisectorOffset - exitOffset) / miter;
return(new[] { Double2.Zero, entryOffset, p1, p2, exitOffset });
}
}
// Now, create the next triangles if necessary
switch (lineJoin)
{
case StrokeLineJoin.Bevel:
// Create the bevel triangle
triangles.Add(new Triangle(p, p + entryOffset, p + exitOffset));
break;
case StrokeLineJoin.Miter:
case StrokeLineJoin.MiterClip:
{
// Check the conditions for the miter (only clip if miter-clip is explicity selected)
if (lineJoin == StrokeLineJoin.Miter && miter >= halfWidth * miterLimit)
{
break;
}
// Generate the miter
var polygon = GenerateClippedTriangle(false).Select(v => p + v).ToArray();
triangles.AddRange(Triangle.MakeTriangleFan(polygon));
break;
}
case StrokeLineJoin.Round:
{
// Generate the round triangle
var curvePolygon = GenerateClippedTriangle(true)
.Select(v => new CurveVertex(p + v, new Double4(v.X, v.Y, -v.Y, 1f))).ToArray();
curveTriangles.AddRange(CurveVertex.MakeTriangleFan(curvePolygon));
break;
}
case StrokeLineJoin.Arcs:
{
// Compute the curvatures of the curves
var exitKappa = prevCurve.ExitCurvature;
var entryKappa = nextCurve.EntryCurvature;
// If both of them are zero, fall back to miter
if (RoughlyZero(exitKappa) && RoughlyZero(entryKappa))
{
goto case StrokeLineJoin.MiterClip;
}
throw new NotImplementedException("Later i'll end it");
}
break;
default: break;
}
}
public static List <Vector2> Stroke(StrokeSegment[] segments, float thickness, Color32 color, StrokeLineJoin lineJoin, StrokeLineCap lineCap, float miterLimit = 4f, ClosePathRule closeLine = ClosePathRule.NEVER, float roundQuality = 10f)
{
if (segments == null || segments.Length == 0)
{
return(null);
}
if (segments.Length == 1)
{
closeLine = ClosePathRule.NEVER;
}
else if (closeLine == ClosePathRule.AUTO)
{
if (segments[0].startPoint == segments[segments.Length - 1].endPoint)
{
closeLine = ClosePathRule.ALWAYS;
}
else
{
closeLine = ClosePathRule.NEVER;
}
}
if (segments[0].startPoint == segments[segments.Length - 1].endPoint)
{
List <StrokeSegment> tempSegments = new List <StrokeSegment>(segments);
tempSegments.RemoveAt(tempSegments.Count - 1);
segments = tempSegments.ToArray();
}
List <Vector2> innerPoints = new List <Vector2>();
List <Vector2> outerPoints = new List <Vector2>();
if (closeLine == ClosePathRule.ALWAYS)
{
List <StrokeSegment> tempSegments = new List <StrokeSegment>(segments);
tempSegments.Add(new StrokeSegment(segments[segments.Length - 1].endPoint, segments[0].startPoint));
tempSegments.Add(new StrokeSegment(segments[0].startPoint, segments[0].endPoint));
segments = tempSegments.ToArray();
}
miterLimit = (miterLimit - 1f) * thickness * 2f;
if (miterLimit < 1f)
{
miterLimit = 1f;
}
int i, i1, j, segmentsLength = segments.Length;
float segmentsAngle, segmentsAngleRotated, halfWidth = thickness * 0.5f,
angleProgress, radAngle = 0f, miterClipHalf = miterLimit * 0.5f, miterClipHalfDouble = miterClipHalf * miterClipHalf;
Vector2 segmentLeftStartA, segmentLeftEndA = Vector2.zero, segmentRightStartA, segmentRightEndA = Vector2.zero,
segmentLeftEndB, segmentRightEndB,
intersectionLeft, intersectionRight, segmentStartCenter;
Matrix4x4 rotationMatrix = Matrix4x4.TRS(Vector2.zero, Quaternion.Euler(0f, 0f, 90f), Vector2.one);
if (lineCap == StrokeLineCap.butt || closeLine == ClosePathRule.ALWAYS)
{
innerPoints.AddRange(new Vector2[] {
segments[0].startPoint - segments[0].directionNormalizedRotated * halfWidth,
segments[0].startPoint + segments[0].directionNormalizedRotated * halfWidth,
});
}
else if (lineCap == StrokeLineCap.round)
{
segmentStartCenter = Vector2.Lerp(segments[0].startPoint - segments[0].directionNormalizedRotated * halfWidth,
segments[0].startPoint + segments[0].directionNormalizedRotated * halfWidth, 0.5f);
radAngle = Mathf.Atan2(segments[0].directionNormalizedRotated.y, segments[0].directionNormalizedRotated.x);
float roundSegmentsfAlt = roundQuality * thickness;
float roundSegmentsfAltMinusOne = roundSegmentsfAlt - 1;
if (roundSegmentsfAltMinusOne > 0)
{
for (j = 0; j <= roundSegmentsfAlt; j++)
{
angleProgress = 1f - Mathf.Clamp01(j / roundSegmentsfAltMinusOne);
innerPoints.Add(segmentStartCenter + new Vector2(Mathf.Cos(radAngle + angleProgress * Mathf.PI) * halfWidth, Mathf.Sin(radAngle + angleProgress * Mathf.PI) * halfWidth));
}
}
innerPoints.AddRange(new Vector2[] {
segments[0].startPoint + segments[0].directionNormalizedRotated * halfWidth,
});
outerPoints.AddRange(new Vector2[] {
segments[0].startPoint - segments[0].directionNormalizedRotated * halfWidth,
});
}
else if (lineCap == StrokeLineCap.square)
{
innerPoints.AddRange(new Vector2[] {
segments[0].startPoint - segments[0].directionNormalized * halfWidth - segments[0].directionNormalizedRotated * halfWidth,
segments[0].startPoint - segments[0].directionNormalized * halfWidth + segments[0].directionNormalizedRotated * halfWidth,
});
}
if (segmentsLength > 1)
{
for (i = 1; i < segmentsLength; i++)
{
i1 = i - 1;
/*
* if(segments[i1].length == 0f || segments[i].length == 0)
* {
* continue;
* }
*/
segmentsAngle = Vector2.Dot(segments[i].directionNormalized, segments[i1].directionNormalized);
segmentsAngleRotated = Vector2.Dot(segments[i].directionNormalized, segments[i1].directionNormalizedRotated);
float miterLength = (1f / Mathf.Sin((Mathf.PI - Mathf.Acos(segmentsAngle)) * 0.5f)) * thickness;
float miterLengthHalf = miterLength * 0.5f;
Vector2 miterVector = Vector2.Lerp(segments[i1].directionNormalizedRotated, segments[i].directionNormalizedRotated, 0.5f).normalized;
Vector2 miterVectorLengthHalf = miterVector * miterLengthHalf;
Vector2 miterVectorRotated = rotationMatrix.MultiplyVector(miterVector);
segmentLeftStartA = segments[i].startPoint - segments[i].directionNormalizedRotated * halfWidth;
segmentLeftEndA = segments[i].endPoint - segments[i].directionNormalizedRotated * halfWidth;
segmentRightStartA = segments[i].startPoint + segments[i].directionNormalizedRotated * halfWidth;
segmentRightEndA = segments[i].endPoint + segments[i].directionNormalizedRotated * halfWidth;
//segmentLeftStartB = segments[i1].startPoint - segments[i1].directionNormalizedRotated * halfWidth;
segmentLeftEndB = segments[i1].endPoint - segments[i1].directionNormalizedRotated * halfWidth;
//segmentRightStartB = segments[i1].startPoint + segments[i1].directionNormalizedRotated * halfWidth;
segmentRightEndB = segments[i1].endPoint + segments[i1].directionNormalizedRotated * halfWidth;
if (lineJoin == StrokeLineJoin.miter)
{
if (miterLimit < miterLength)
{
lineJoin = StrokeLineJoin.bevel;
}
}
if (lineJoin == StrokeLineJoin.miter || lineJoin == StrokeLineJoin.miterClip)
{
if (segmentsAngle == 1f || segmentsAngle == -1f)
{
innerPoints.AddRange(new Vector2[] {
segmentRightEndB,
segmentRightStartA,
});
outerPoints.AddRange(new Vector2[] {
segmentLeftEndB,
segmentLeftStartA,
});
}
else
{
if (segmentsAngleRotated < 0)
{
if (miterLimit <= miterLength)
{
Vector2 a = segments[i1].endPoint + miterVector * miterClipHalf;
Vector2 b = segments[i1].endPoint + miterVectorLengthHalf;
Vector2 c = a + miterVectorRotated;
SVGMath.LineLineIntersection(out intersectionLeft, b, segmentRightEndB, a, c);
SVGMath.LineLineIntersection(out intersectionRight, b, segmentRightStartA, a, c);
if (miterClipHalfDouble <= (Vector2.Lerp(segmentRightEndB, segmentRightStartA, 0.5f) - segments[i1].endPoint).sqrMagnitude)
{
intersectionLeft = segmentRightEndB;
intersectionRight = segmentRightStartA;
}
innerPoints.AddRange(new Vector2[] {
intersectionLeft,
intersectionRight,
});
outerPoints.AddRange(new Vector2[] {
segmentLeftEndB,
segmentLeftStartA,
});
}
else
{
intersectionRight = segments[i1].endPoint + miterVectorLengthHalf;
innerPoints.AddRange(new Vector2[] {
intersectionRight,
});
outerPoints.AddRange(new Vector2[] {
segmentLeftEndB,
segmentLeftStartA,
});
}
}
else
{
if (miterLimit <= miterLength)
{
Vector2 a = segments[i1].endPoint - miterVector * miterClipHalf;
Vector2 b = segments[i1].endPoint - miterVectorLengthHalf;
Vector2 c = a + miterVectorRotated;
SVGMath.LineLineIntersection(out intersectionLeft, b, segmentLeftStartA, a, c);
SVGMath.LineLineIntersection(out intersectionRight, b, segmentLeftEndB, a, c);
if (miterClipHalfDouble <= (Vector2.Lerp(segmentLeftStartA, segmentLeftEndB, 0.5f) - segments[i1].endPoint).sqrMagnitude)
{
intersectionLeft = segmentLeftStartA;
intersectionRight = segmentLeftEndB;
}
outerPoints.AddRange(new Vector2[] {
intersectionRight,
intersectionLeft,
});
innerPoints.AddRange(new Vector2[] {
segmentRightEndB,
segmentRightStartA,
});
}
else
{
intersectionLeft = segments[i1].endPoint - miterVectorLengthHalf;
outerPoints.AddRange(new Vector2[] {
intersectionLeft,
});
innerPoints.AddRange(new Vector2[] {
segmentRightEndB,
segmentRightStartA,
});
}
}
}
}
else if (lineJoin == StrokeLineJoin.bevel)
{
innerPoints.AddRange(new Vector2[] {
segmentRightEndB,
segmentRightStartA,
});
outerPoints.AddRange(new Vector2[] {
segmentLeftEndB,
segmentLeftStartA,
});
}
else if (lineJoin == StrokeLineJoin.round)
{
if (segmentsAngle == 1f)
{
innerPoints.AddRange(new Vector2[] {
segmentRightEndB,
segmentRightStartA,
});
outerPoints.AddRange(new Vector2[] {
segmentLeftEndB,
segmentLeftStartA,
});
}
else
{
if (segmentsAngleRotated < 0)
{
innerPoints.AddRange(new Vector2[] {
segmentRightEndB,
});
outerPoints.AddRange(new Vector2[] {
segmentLeftEndB,
segmentLeftStartA,
});
segmentStartCenter = segments[i].startPoint;
Vector2 dir = segments[i1].directionNormalizedRotated;
float angle = Mathf.Acos(Vector2.Dot(segments[i1].directionNormalized, segments[i].directionNormalized));
radAngle = Mathf.Atan2(dir.y, dir.x);
float roundSegmentsfAlt = roundQuality * thickness * (Mathf.Acos(segmentsAngle) / Mathf.PI);
if (roundSegmentsfAlt < 1)
{
roundSegmentsfAlt = 1f;
}
float roundSegmentsfAltMinusOne = roundSegmentsfAlt;
if (roundSegmentsfAltMinusOne > 0)
{
for (j = 0; j < roundSegmentsfAlt; j++)
{
angleProgress = Mathf.Clamp01(j / roundSegmentsfAltMinusOne);
innerPoints.Add(segmentStartCenter + new Vector2(Mathf.Cos(radAngle - angleProgress * angle) * halfWidth, Mathf.Sin(radAngle - angleProgress * angle) * halfWidth));
}
}
innerPoints.AddRange(new Vector2[] {
segmentRightStartA,
});
}
else
{
innerPoints.AddRange(new Vector2[] {
segmentRightEndB,
segmentRightStartA,
});
outerPoints.AddRange(new Vector2[] {
segmentLeftEndB,
});
segmentStartCenter = segments[i].startPoint;
Vector2 dir = -segments[i].directionNormalizedRotated;
float angle = Mathf.Acos(Vector2.Dot(segments[i1].directionNormalized, segments[i].directionNormalized));
radAngle = Mathf.Atan2(dir.y, dir.x);
float roundSegmentsfAlt = roundQuality * thickness * (Mathf.Acos(segmentsAngle) / Mathf.PI);
if (roundSegmentsfAlt < 1)
{
roundSegmentsfAlt = 1f;
}
float roundSegmentsfAltMinusOne = roundSegmentsfAlt;
if (roundSegmentsfAltMinusOne > 0)
{
for (j = 0; j < roundSegmentsfAlt; j++)
{
angleProgress = Mathf.Clamp01(1f - (j / roundSegmentsfAltMinusOne));
outerPoints.Add(segmentStartCenter + new Vector2(Mathf.Cos(radAngle - angleProgress * angle) * halfWidth, Mathf.Sin(radAngle - angleProgress * angle) * halfWidth));
}
}
outerPoints.AddRange(new Vector2[] {
segmentLeftStartA,
});
}
}
}
}
}
int lastSegmentIndex = segments.Length - 1;
segmentLeftStartA = segments[lastSegmentIndex].startPoint - segments[lastSegmentIndex].directionNormalizedRotated * halfWidth;
segmentLeftEndA = segments[lastSegmentIndex].endPoint - segments[lastSegmentIndex].directionNormalizedRotated * halfWidth;
segmentRightStartA = segments[lastSegmentIndex].startPoint + segments[lastSegmentIndex].directionNormalizedRotated * halfWidth;
segmentRightEndA = segments[lastSegmentIndex].endPoint + segments[lastSegmentIndex].directionNormalizedRotated * halfWidth;
if (closeLine == ClosePathRule.NEVER)
{
if (lineCap == StrokeLineCap.butt)
{
innerPoints.AddRange(new Vector2[] {
segmentRightEndA,
segmentLeftEndA,
});
}
else if (lineCap == StrokeLineCap.round)
{
innerPoints.AddRange(new Vector2[] {
segmentRightEndA
});
outerPoints.AddRange(new Vector2[] {
segmentLeftEndA,
});
segmentStartCenter = Vector2.Lerp(segmentLeftEndA, segmentRightEndA, 0.5f);
radAngle = Mathf.Atan2(-segments[lastSegmentIndex].directionNormalizedRotated.y, -segments[lastSegmentIndex].directionNormalizedRotated.x);
float roundSegmentsfAlt = roundQuality * thickness;
float roundSegmentsfAltMinusOne = roundSegmentsfAlt - 1;
if (roundSegmentsfAltMinusOne > 0)
{
for (j = 0; j <= roundSegmentsfAlt; j++)
{
angleProgress = 1f - Mathf.Clamp01(j / roundSegmentsfAltMinusOne);
innerPoints.Add(segmentStartCenter + new Vector2(Mathf.Cos(radAngle + angleProgress * Mathf.PI) * halfWidth, Mathf.Sin(radAngle + angleProgress * Mathf.PI) * halfWidth));
}
}
}
else if (lineCap == StrokeLineCap.square)
{
Vector2 lastSegmentOffset = segments[lastSegmentIndex].directionNormalized * halfWidth;
innerPoints.AddRange(new Vector2[] {
segmentRightEndA + lastSegmentOffset,
segmentLeftEndA + lastSegmentOffset,
});
}
}
if (closeLine == ClosePathRule.ALWAYS && lineJoin == StrokeLineJoin.miter || lineJoin == StrokeLineJoin.miterClip)
{
innerPoints.AddRange(new Vector2[] {
segmentRightEndA,
segmentLeftEndA,
});
}
outerPoints.Reverse();
innerPoints.AddRange(outerPoints);
return(innerPoints);
}
