public static void GetParts(float width, float offset, MarkupLOD lod, out int count, out float partWidth)
{
var max = LodMax[lod];
if (width < max || offset != 0f)
{
count = 1;
partWidth = width;
}
else
{
var intWidth = (int)(width * 100);
var delta = (int)(max * 100);
var num = 0;
for (var i = (int)(max * 50); i < (int)(max * 100); i += 1)
{
var iDelta = intWidth - (intWidth / i) * i;
if (iDelta < delta)
{
delta = iDelta;
num = i;
}
}
count = intWidth / num;
partWidth = num / 100f;
}
}
protected override IEnumerable <IStyleData> GetStyleData(MarkupLOD lod)
{
if (Visible)
{
yield return(Rule.Style.Calculate(this, LineTrajectory, lod));
}
}
private List <List <ITrajectory> > GetParts(List <ITrajectory> trajectories, MarkupLOD lod)
{
var parts = trajectories.Select(t => StyleHelper.CalculateSolid(t, lod, (tr) => tr, MinAngle, MinLength, MaxLength)).ToList();
for (var i = 0; i < parts.Count; i += 1)
{
var xm = (i - 1 + parts.Count) % parts.Count;
var x = i;
var y = (i + 1) % parts.Count;
var yp = (i + 2) % parts.Count;
if (FindIntersects(parts[x], parts[y], true, 1))
{
continue;
}
if (parts.Count > 3 && parts[y].Count == 1 && FindIntersects(parts[x], parts[yp], true, 0))
{
parts.RemoveAt(y);
continue;
}
if (FindIntersects(parts[y], parts[x], false, 1))
{
continue;
}
if (parts.Count > 3 && parts[x].Count == 1 && FindIntersects(parts[y], parts[xm], false, 0))
{
parts.RemoveAt(x);
i -= 1;
continue;
}
}
return(parts);
}
private static List <Result> CalculateSolid <Result>(ITrajectory trajectory, MarkupLOD lod, float?minAngle, float?minLength, float?maxLength, Action <List <Result>, ITrajectory> addToResult)
{
var lodScale = LodScale[lod];
var result = new List <Result>();
CalculateSolid(0, trajectory, trajectory.DeltaAngle, (minAngle ?? MinAngleDelta) * lodScale, (minLength ?? MinLength) * lodScale, (maxLength ?? MaxLength) * lodScale, t => addToResult(result, t));
return(result);
}
protected Vector3[] GetContourPoints(List <FillerContour.Part> contour, MarkupLOD lod, out int[] groups)
{
var trajectories = contour.Select(i => i.Trajectory).ToList();
if (trajectories.GetDirection() == TrajectoryHelper.Direction.CounterClockWise)
{
trajectories = trajectories.Select(t => t.Invert()).Reverse().ToList();
}
var parts = GetParts(trajectories, lod);
var points = parts.SelectMany(p => p).Select(t => t.StartPosition).ToArray();
groups = parts.Select(g => g.Count).ToArray();
return(points);
}
public override IStyleData Calculate(MarkupFiller filler, MarkupLOD lod)
{
var trajectories = GetTrajectories(filler);
var parts = GetParts(trajectories, lod);
var points = parts.SelectMany(p => p).Select(t => t.StartPosition).ToArray();
if (points.Length < 3)
{
return(null);
}
var triangles = Triangulator.Triangulate(points, PolygonDirection.ClockWise);
if (triangles == null)
{
return(null);
}
return(new MarkupStylePolygonMesh(filler.Markup.Height, Elevation, parts.Select(g => g.Count).ToArray(), points, triangles, MaterialType));
}
public override IStyleData Calculate(MarkupFiller filler, MarkupLOD lod)
{
var contour = filler.IsMedian ? SetMedianOffset(filler) : filler.Contour.Trajectories.ToArray();
if (NeedReverse(contour))
{
contour = contour.Select(t => t.Invert()).Reverse().ToArray();
}
var parts = contour.Select(t => StyleHelper.CalculateSolid(t, lod, (tr) => tr, MinAngle, MinLength, MaxLength)).ToArray();
for (var i = 0; i < parts.Length; i += 1)
{
var partI = parts[i];
var partJ = parts[(i + 1) % parts.Length];
if (!FindIntersects(partI, partJ, false))
{
FindIntersects(partJ, partI, true);
}
}
var points = parts.SelectMany(p => p).Select(t => t.StartPosition).ToArray();
if (points.Length < 3)
{
return(null);
}
var polygon = new Polygon(points.Select(p => new PolygonPoint(p.x, p.z)));
P2T.Triangulate(polygon);
var triangles = polygon.Triangles.SelectMany(t => t.Points.Select(p => polygon.IndexOf(p))).ToArray();
return(new MarkupStylePolygonMesh(filler.Markup.Height, Elevation, parts.Select(g => g.Count).ToArray(), points, triangles, MaterialType));
}
protected abstract IEnumerable <IStyleData> GetStyleData(MarkupLOD lod);
private void RecalculateStyleData(MarkupLOD lod) => StyleData[lod] = GetStyleData(lod).ToArray();
public override IStyleData Calculate(MarkupLine line, ITrajectory trajectory, MarkupLOD lod) => new MarkupStyleLineMesh(trajectory, Width, Elevation, MaterialType.Pavement);
public sealed override IEnumerable <IStyleData> Calculate(MarkupFiller filler, List <List <FillerContour.Part> > contours, MarkupLOD lod)
{
yield return(new MarkupStyleParts(CalculateProcess(filler, contours, lod)));
}
public sealed override IStyleData Calculate(MarkupLine line, ITrajectory trajectory, MarkupLOD lod) => line is MarkupStopLine stopLine?Calculate(stopLine, trajectory, lod) : new MarkupStyleParts();
public abstract IStyleData Calculate(MarkupLine line, ITrajectory trajectory, MarkupLOD lod);
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod)
{
var middleOffset = GetVisibleWidth(crosswalk) / 2 + OffsetBefore;
var deltaOffset = (Width - LineWidth) / 2 / Mathf.Sin(crosswalk.CornerAndNormalAngle);
var firstTrajectory = crosswalk.GetTrajectory(middleOffset - deltaOffset);
var secondTrajectory = crosswalk.GetTrajectory(middleOffset + deltaOffset);
foreach (var dash in StyleHelper.CalculateDashed(firstTrajectory, DashLength, SpaceLength, CalculateDashes))
{
yield return(dash);
}
foreach (var dash in StyleHelper.CalculateDashed(secondTrajectory, DashLength, SpaceLength, CalculateDashes))
{
yield return(dash);
}
IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory dashTrajectory, float startT, float endT)
{
yield return(StyleHelper.CalculateDashedPart(dashTrajectory, startT, endT, DashLength, 0, LineWidth, Color));
}
}
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod)
{
foreach (var dash in base.Calculate(crosswalk, lod))
{
yield return(dash);
}
var offset = GetVisibleWidth(crosswalk) / 2 + OffsetBefore;
var direction = crosswalk.CornerDir.Turn90(true);
var borders = crosswalk.BorderTrajectories;
var width = Width - 2 * LineWidth;
var trajectory = crosswalk.GetFullTrajectory(offset, direction);
foreach (var dash in StyleHelper.CalculateDashed(trajectory, DashLength, SpaceLength, CalculateDashes))
{
yield return(dash);
}
IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory crosswalkTrajectory, float startT, float endT)
=> CalculateCroswalkPart(crosswalkTrajectory, startT, endT, direction, borders, Width, DashLength, Color);
}
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod) => new MarkupStylePart[0];
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod)
{
var middleOffset = GetVisibleWidth(crosswalk) / 2 + OffsetBefore;
var deltaOffset = GetLengthCoef((Width + Offset) / 2, crosswalk);
var firstOffset = -crosswalk.NormalDir * (middleOffset - deltaOffset);
var secondOffset = -crosswalk.NormalDir * (middleOffset + deltaOffset);
var coef = Mathf.Sin(crosswalk.CornerAndNormalAngle);
var dashLength = Parallel ? DashLength / coef : DashLength;
var spaceLength = Parallel ? SpaceLength / coef : SpaceLength;
var direction = Parallel ? crosswalk.NormalDir : crosswalk.CornerDir.Turn90(true);
var borders = crosswalk.BorderTrajectories;
var index = 0;
var trajectoryFirst = crosswalk.GetFullTrajectory(middleOffset - deltaOffset, direction);
var trajectorySecond = crosswalk.GetFullTrajectory(middleOffset + deltaOffset, direction);
foreach (var dash in StyleHelper.CalculateDashed(trajectoryFirst, dashLength, spaceLength, CalculateDashes))
{
yield return(dash);
}
index = 0;
foreach (var dash in StyleHelper.CalculateDashed(trajectorySecond, dashLength, spaceLength, CalculateDashes))
{
yield return(dash);
}
IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory crosswalkTrajectory, float startT, float endT)
{
index += 1;
foreach (var part in CalculateCroswalkPart(crosswalkTrajectory, startT, endT, direction, borders, Width, DashLength, GetColor(index)))
{
yield return(part);
}
}
}
protected override IStyleData Calculate(MarkupRegularLine line, ITrajectory trajectory, MarkupLOD lod)
{
if (!IsValid)
{
return(new MarkupStyleParts());
}
if (Invert)
{
trajectory = trajectory.Invert();
}
if (Shift != 0)
{
var startNormal = trajectory.StartDirection.Turn90(!Invert);
var endNormal = trajectory.EndDirection.Turn90(Invert);
trajectory = new BezierTrajectory(trajectory.StartPosition + startNormal * Shift, trajectory.StartDirection, trajectory.EndPosition + endNormal * Shift, trajectory.EndDirection);
}
var length = trajectory.Length;
if (OffsetBefore + OffsetAfter >= length)
{
return(new MarkupStyleParts());
}
var startT = OffsetBefore == 0f ? 0f : trajectory.Travel(OffsetBefore);
var endT = OffsetAfter == 0f ? 1f : 1f - trajectory.Invert().Travel(OffsetAfter);
trajectory = trajectory.Cut(startT, endT);
var count = Mathf.CeilToInt(trajectory.Length / RepeatDistance);
var trajectories = new ITrajectory[count];
if (count == 1)
{
trajectories[0] = trajectory;
}
else
{
for (int i = 0; i < count; i += 1)
{
trajectories[i] = trajectory.Cut(1f / count * i, 1f / count * (i + 1));
}
}
return(new MarkupStyleNetwork(Prefab, trajectories, Prefab.Value.m_halfWidth * 2f, Prefab.Value.m_segmentLength, Scale, Elevation));
}
protected override IEnumerable <IStyleData> GetStyleData(MarkupLOD lod)
{
yield break;
}
protected virtual IEnumerable <MarkupStylePart> CalculateProcess(MarkupFiller filler, List <List <FillerContour.Part> > contours, MarkupLOD lod)
{
var originalContour = filler.Contour.TrajectoriesProcessed.ToArray();
var rails = GetRails(filler, originalContour).ToArray();
foreach (var rail in rails)
{
var partItems = GetItems(rail, lod).ToArray();
foreach (var partItem in partItems)
{
foreach (var dash in GetDashes(partItem, contours))
{
yield return(dash);
}
}
}
}
public abstract IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod);
protected override IStyleData Calculate(MarkupStopLine stopLine, ITrajectory trajectory, MarkupLOD lod)
{
var offsetNormal = ((stopLine.Start.Direction + stopLine.End.Direction) / -2).normalized;
var offsetLeft = offsetNormal * (Width / 2);
var offsetRight = offsetNormal * (Width / 2 + 2 * Offset);
return(new MarkupStyleParts(StyleHelper.CalculateSolid(trajectory, lod, CalculateDashes)));
IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory dashTrajectory)
{
yield return(StyleHelper.CalculateSolidPart(dashTrajectory, offsetLeft, offsetLeft, Width, Color));
yield return(StyleHelper.CalculateSolidPart(dashTrajectory, offsetRight, offsetRight, Width, Color));
}
}
public abstract IEnumerable <IStyleData> Calculate(MarkupFiller filler, List <List <FillerContour.Part> > contours, MarkupLOD lod);
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod)
{
var deltaOffset = GetLengthCoef(SquareSide, crosswalk);
var startOffset = deltaOffset / 2 + OffsetBefore;
var direction = crosswalk.CornerDir;
var normalDirection = direction.Turn90(true);
var borders = crosswalk.BorderTrajectories;
for (var i = 0; i < LineCount; i += 1)
{
var trajectory = crosswalk.GetFullTrajectory(startOffset + deltaOffset * i, normalDirection);
var trajectoryLength = trajectory.Length;
var count = (int)(trajectoryLength / SquareSide);
var squareT = SquareSide / trajectoryLength;
var startT = (trajectoryLength - SquareSide * count) / trajectoryLength;
for (var j = (Invert ? i + 1 : i) % 2; j < count; j += 2)
{
foreach (var dash in CalculateCroswalkPart(trajectory, startT + squareT * (j - 1), startT + squareT * j, direction, borders, SquareSide, SquareSide, Color))
{
yield return(dash);
}
}
}
}
protected abstract IStyleData Calculate(MarkupStopLine stopLine, ITrajectory trajectory, MarkupLOD lod);
public static List <Result> CalculateSolid <Result>(ITrajectory trajectory, MarkupLOD lod, Func <ITrajectory, IEnumerable <Result> > calculateParts, float?minAngle = null, float?minLength = null, float?maxLength = null)
{
return(CalculateSolid <Result>(trajectory, lod, minAngle, minLength, maxLength, AddToResult));
void AddToResult(List <Result> result, ITrajectory trajectory) => result.AddRange(calculateParts(trajectory));
}
protected bool CheckDashedLod(MarkupLOD lod, float width, float length) => lod != MarkupLOD.LOD1 || width > LodWidth || length > LodLength;
protected override IStyleData Calculate(MarkupStopLine stopLine, ITrajectory trajectory, MarkupLOD lod)
{
if (!CheckDashedLod(lod, Base, Height))
{
return(new MarkupStyleParts());
}
var styleData = new MarkupStyleParts(StyleHelper.CalculateDashed(trajectory, Base, Space, CalculateDashes));
foreach (var dash in styleData)
{
dash.MaterialType = MaterialType.Triangle;
}
return(styleData);
}
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod)
{
StyleHelper.GetParts(Width, 0, lod, out int count, out float partWidth);
var partOffset = GetVisibleWidth(crosswalk) / count;
var startOffset = partOffset / 2;
for (var i = 0; i < count; i += 1)
{
var trajectory = crosswalk.GetTrajectory(startOffset + partOffset * i + OffsetBefore);
yield return(new MarkupStylePart(trajectory.StartPosition, trajectory.EndPosition, trajectory.Direction, partWidth, Color));
}
}
public abstract IStyleData Calculate(MarkupFiller filler, MarkupLOD lod);
