private void LegacyAddEdge()
{
// split the path into segments based on the split angle
List <List <int> > segments = new List <List <int> >();
List <Ferr2DT_TerrainDirection> dirs = new List <Ferr2DT_TerrainDirection>();
List <int> order = new List <int>();
segments = GetSegments(Path.GetVertsRaw(), out dirs);
if (dirs.Count < segments.Count)
{
dirs.Add(directionOverrides[directionOverrides.Count - 1]);
}
for (int i = 0; i < segments.Count; i++)
{
order.Add(i);
}
order.Sort(
new Ferr.LambdaComparer <int>(
(x, y) => {
Ferr2DT_TerrainDirection dirx = dirs[x] == Ferr2DT_TerrainDirection.None ? Ferr2D_Path.GetDirection(Path.pathVerts, segments[x], 0, fill == Ferr2DT_FillMode.InvertedClosed) : dirs[x];
Ferr2DT_TerrainDirection diry = dirs[y] == Ferr2DT_TerrainDirection.None ? Ferr2D_Path.GetDirection(Path.pathVerts, segments[y], 0, fill == Ferr2DT_FillMode.InvertedClosed) : dirs[y];
return(TerrainMaterial.GetDescriptor(diry).zOffset.CompareTo(TerrainMaterial.GetDescriptor(dirx).zOffset));
}
));
// process the segments into meshes
for (int i = 0; i < order.Count; i++)
{
List <int> currSeg = segments[order[i]];
List <int> prevSeg = order[i] - 1 < 0 ? segments[segments.Count - 1] : segments[order[i] - 1];
List <int> nextSeg = segments[(order[i] + 1) % segments.Count];
int curr = currSeg[0];
int prev = prevSeg[prevSeg.Count - 2];
int next = currSeg[1];
Vector2 p1 = Path.pathVerts[prev] - Path.pathVerts[curr];
Vector2 p2 = Path.pathVerts[next] - Path.pathVerts[curr];
bool leftInner = Mathf.Atan2(p1.x * p2.y - p1.y * p2.x, Vector2.Dot(p1, p2)) < 0;
curr = currSeg[currSeg.Count - 1];
prev = currSeg[currSeg.Count - 2];
next = nextSeg[1];
p1 = Path.pathVerts[prev] - Path.pathVerts[curr];
p2 = Path.pathVerts[next] - Path.pathVerts[curr];
bool rightInner = Mathf.Atan2(p1.x * p2.y - p1.y * p2.x, Vector2.Dot(p1, p2)) < 0;
LegacyAddSegment(Ferr2D_Path.IndicesToList <Vector2>(Path.pathVerts, segments[order[i]]), leftInner, rightInner, Ferr2D_Path.IndicesToList <float>(vertScales, segments[order[i]]), Ferr2D_Path.IndicesToList <CutOverrides>(cutOverrides, segments[order[i]]), order.Count <= 1 && Path.closed, smoothPath, dirs[order[i]]);
}
}
private void LegacyAddSegment(List <Vector2> aSegment, bool aLeftInner, bool aRightInner, List <float> aScale, List <CutOverrides> aCutOverrides, bool aClosed, bool aSmooth, Ferr2DT_TerrainDirection aDir = Ferr2DT_TerrainDirection.None)
{
Ferr2DT_SegmentDescription desc;
if (aDir != Ferr2DT_TerrainDirection.None)
{
desc = TerrainMaterial.GetDescriptor(aDir);
}
else
{
desc = GetDescription(aSegment);
}
#if UNITY_5_4_OR_NEWER
UnityEngine.Random.State tSeed = UnityEngine.Random.state;
#else
int tSeed = UnityEngine.Random.seed;
#endif
Rect body = TerrainMaterial.ToUV(desc.body[0]);
float bodyWidth = body.width * unitsPerUV.x;
#if UNITY_5_4_OR_NEWER
UnityEngine.Random.InitState((int)(aSegment[0].x * 100000 + aSegment[0].y * 10000));
#else
UnityEngine.Random.seed = (int)(aSegment[0].x * 100000 + aSegment[0].y * 10000);
#endif
Vector2 capLeftSlideDir = (aSegment[1] - aSegment[0]);
Vector2 capRightSlideDir = (aSegment[aSegment.Count - 2] - aSegment[aSegment.Count - 1]);
capLeftSlideDir.Normalize();
capRightSlideDir.Normalize();
aSegment[0] -= capLeftSlideDir * desc.capOffset;
aSegment[aSegment.Count - 1] -= capRightSlideDir * desc.capOffset;
LegacyCreateBody(desc, aSegment, aScale, aCutOverrides, bodyWidth, Mathf.Max(2, splitCount + 2), aClosed);
if (!aClosed)
{
LegacyAddCap(aSegment, desc, aLeftInner, -1, aScale[0], aSmooth);
LegacyAddCap(aSegment, desc, aRightInner, 1, aScale[aScale.Count - 1], aSmooth);
}
#if UNITY_5_4_OR_NEWER
UnityEngine.Random.state = tSeed;
#else
UnityEngine.Random.seed = tSeed;
#endif
}
public Ferr2DT_SegmentDescription GetDescription(List <int> aSegment)
{
Ferr2DT_TerrainDirection dir = Ferr2D_Path.GetDirection(Path.pathVerts, aSegment, 0, fill == Ferr2DT_FillMode.InvertedClosed);
return(TerrainMaterial.GetDescriptor(dir));
}
