protected virtual IEnumerable <MarkupStyleDash> CalculateDashes(ILineTrajectory trajectory, LineBorders borders)
{
if (StyleHelper.CalculateSolidDash(borders, trajectory, 0f, Width, Color, out MarkupStyleDash dash))
{
yield return(dash);
}
}
public static IEnumerable <MarkupStyleDash> CalculateDashed(ILineTrajectory trajectory, float dashLength, float spaceLength, DashedGetter calculateDashes)
{
List <DashT> dashesT;
switch (trajectory)
{
case BezierTrajectory bezierTrajectory:
dashesT = CalculateDashesBezierT(bezierTrajectory, dashLength, spaceLength);
break;
case StraightTrajectory straightTrajectory:
dashesT = CalculateDashesStraightT(straightTrajectory, dashLength, spaceLength);
break;
default:
yield break;
}
foreach (var dashT in dashesT)
{
foreach (var dash in calculateDashes(trajectory, dashT.Start, dashT.End))
{
yield return(dash);
}
}
}
public void Divide(out ILineTrajectory trajectory1, out ILineTrajectory trajectory2)
{
var middle = (Trajectory.a + Trajectory.b) / 2;
trajectory1 = new StraightTrajectory(Trajectory.a, middle);
trajectory2 = new StraightTrajectory(middle, Trajectory.b);
}
private static IEnumerable <MarkupStyleDash> CalculateSolid(int depth, ILineTrajectory trajectory, float deltaAngle, Func <ILineTrajectory, IEnumerable <MarkupStyleDash> > calculateDashes)
{
var length = trajectory.Magnitude;
var needDivide = (MinAngleDelta < deltaAngle && MinLength <= length) || MaxLength < length;
if (depth < MaxDepth && (needDivide || depth == 0))
{
trajectory.Divide(out ILineTrajectory first, out ILineTrajectory second);
var firstDeltaAngle = first.DeltaAngle;
var secondDeltaAngle = second.DeltaAngle;
if (needDivide || MinAngleDelta < deltaAngle || MinAngleDelta < firstDeltaAngle + secondDeltaAngle)
{
foreach (var dash in CalculateSolid(depth + 1, first, firstDeltaAngle, calculateDashes))
{
yield return(dash);
}
foreach (var dash in CalculateSolid(depth + 1, second, secondDeltaAngle, calculateDashes))
{
yield return(dash);
}
yield break;
}
}
foreach (var dash in calculateDashes(trajectory))
{
yield return(dash);
}
}
public static List <MarkupIntersect> Calculate(ILineTrajectory trajectory1, ILineTrajectory trajectory2)
{
if (trajectory1.TrajectoryType == TrajectoryType.Bezier)
{
if (trajectory2.TrajectoryType == TrajectoryType.Bezier)
{
return(Calculate(trajectory1 as BezierTrajectory, trajectory2 as BezierTrajectory));
}
else if (trajectory2.TrajectoryType == TrajectoryType.Line)
{
return(Calculate(trajectory1 as BezierTrajectory, trajectory2 as StraightTrajectory));
}
}
else if (trajectory1.TrajectoryType == TrajectoryType.Line)
{
if (trajectory2.TrajectoryType == TrajectoryType.Bezier)
{
return(Calculate(trajectory1 as StraightTrajectory, trajectory2 as BezierTrajectory));
}
else if (trajectory2.TrajectoryType == TrajectoryType.Line)
{
return(Calculate(trajectory1 as StraightTrajectory, trajectory2 as StraightTrajectory));
}
}
return(new List <MarkupIntersect>());
}
public static IEnumerable <Result> CalculateSolid <Result>(int depth, ILineTrajectory trajectory, float deltaAngle, float minAngle, float minLength, float maxLength, Func <ILineTrajectory, IEnumerable <Result> > calculateDashes)
{
var length = trajectory.Magnitude;
var needDivide = (minAngle < deltaAngle && minLength <= length) || maxLength < length;
if (depth < MaxDepth && (needDivide || depth == 0))
{
trajectory.Divide(out ILineTrajectory first, out ILineTrajectory second);
var firstDeltaAngle = first.DeltaAngle;
var secondDeltaAngle = second.DeltaAngle;
if (needDivide || minAngle < deltaAngle || minAngle < firstDeltaAngle + secondDeltaAngle)
{
foreach (var dash in CalculateSolid(depth + 1, first, firstDeltaAngle, minAngle, minLength, maxLength, calculateDashes))
{
yield return(dash);
}
foreach (var dash in CalculateSolid(depth + 1, second, secondDeltaAngle, minAngle, minLength, maxLength, calculateDashes))
{
yield return(dash);
}
yield break;
}
}
foreach (var dash in calculateDashes(trajectory))
{
yield return(dash);
}
}
protected IEnumerable <MarkupStyleDash> CalculateCroswalkDash(ILineTrajectory trajectory, float startT, float endT, Vector3 direction, ILineTrajectory[] borders, float length, float width)
{
var position = trajectory.Position((startT + endT) / 2);
var dashTrajectory = new StraightTrajectory(position, position + direction, false);
var intersects = MarkupIntersect.Calculate(dashTrajectory, borders, true);
intersects = intersects.OrderBy(i => i.FirstT).ToList();
var halfLength = length / 2;
var halfWidth = width / 2;
for (var i = 1; i < intersects.Count; i += 2)
{
var startOffset = GetOffset(intersects[i - 1], halfWidth);
var endOffset = GetOffset(intersects[i], halfWidth);
var start = Mathf.Clamp(intersects[i - 1].FirstT + startOffset, -halfLength, halfLength);
var end = Mathf.Clamp(intersects[i].FirstT - endOffset, -halfLength, halfLength);
var delta = end - start;
if (delta < 0.9 * length && delta < 0.67 * width)
{
continue;
}
var startPosition = position + direction * start;
var endPosition = position + direction * end;
yield return(new MarkupStyleDash(startPosition, endPosition, direction, width, Color));
}
}
public override IEnumerable <MarkupStyleDash> Calculate(MarkupLine line, ILineTrajectory trajectory)
{
var borders = line.Borders;
return(StyleHelper.CalculateSolid(trajectory, GetDashes));
IEnumerable <MarkupStyleDash> GetDashes(ILineTrajectory trajectory) => CalculateDashes(trajectory, borders);
}
public bool GetBorder(MarkupEnterPoint point, out ILineTrajectory line)
{
if (point.IsFirst && Markup.GetBordersLine(this, Prev, out line))
{
return(true);
}
else if (point.IsLast && Markup.GetBordersLine(this, Next, out line))
{
return(true);
}
else
{
line = null;
return(false);
}
}
public override IEnumerable <MarkupStyleDash> Calculate(MarkupLine line, ILineTrajectory trajectory) => StyleHelper.CalculateSolid(trajectory, CalculateDashes);
public static List <MarkupIntersect> Calculate(ILineTrajectory trajectory, IEnumerable <ILineTrajectory> otherTrajectories, bool onlyIntersect = false) => otherTrajectories.SelectMany(t => Calculate(trajectory, t)).Where(i => !onlyIntersect || i.IsIntersect).ToList();
public static IEnumerable <MarkupStyleDash> CalculateSolid(ILineTrajectory trajectory, Func <ILineTrajectory, IEnumerable <MarkupStyleDash> > calculateDashes) => CalculateSolid(0, trajectory, trajectory.DeltaAngle, calculateDashes);
public static MarkupIntersect CalculateSingle(ILineTrajectory trajectory1, ILineTrajectory trajectory2) => Calculate(trajectory1, trajectory2).FirstOrDefault() ?? NotIntersect;
public abstract IEnumerable <MarkupStyleDash> Calculate(MarkupLine line, ILineTrajectory trajectory);
public override IEnumerable <MarkupStyleDash> Calculate(MarkupLine line, ILineTrajectory trajectory) => line is MarkupStopLine stopLine?Calculate(stopLine, trajectory) : new MarkupStyleDash[0];
public void Divide(out ILineTrajectory trajectory1, out ILineTrajectory trajectory2)
{
Trajectory.Divide(out Bezier3 bezier1, out Bezier3 bezier2);
trajectory1 = new BezierTrajectory(bezier1);
trajectory2 = new BezierTrajectory(bezier2);
}
public TrajectoryBound(ILineTrajectory trajectory, float size)
{
Trajectory = trajectory;
Size = size;
CalculateBounds();
}
protected virtual IEnumerable <MarkupStyleDash> CalculateDashes(ILineTrajectory trajectory)
{
yield return(StyleHelper.CalculateSolidDash(trajectory, 0f, Width, Color));
}
public static IEnumerable <Result> CalculateSolid <Result>(ILineTrajectory trajectory, Func <ILineTrajectory, IEnumerable <Result> > calculateDashes) => CalculateSolid(trajectory, MinAngleDelta, MinLength, MaxLength, calculateDashes);
public static void RenderTrajectory(RenderManager.CameraInfo cameraInfo, Color color, ILineTrajectory trajectory, float width = 0.2f, bool cut = false, bool alphaBlend = true)
{
switch (trajectory)
{
case BezierTrajectory bezierTrajectory:
RenderBezier(cameraInfo, color, bezierTrajectory.Trajectory, width, cut, alphaBlend);
break;
case StraightTrajectory straightTrajectory:
RenderBezier(cameraInfo, color, straightTrajectory.Trajectory.GetBezier(), width, cut, alphaBlend);
break;
}
}
protected override IEnumerable <MarkupStyleDash> Calculate(MarkupStopLine stopLine, ILineTrajectory trajectory)
{
var offset = ((stopLine.Start.Direction + stopLine.End.Direction) / -2).normalized * (Width / 2);
return(StyleHelper.CalculateSolid(trajectory, CalculateDashes));
IEnumerable <MarkupStyleDash> CalculateDashes(ILineTrajectory dashTrajectory)
{
yield return(StyleHelper.CalculateSolidDash(dashTrajectory, offset, offset, Width, Color));
}
}
public static IEnumerable <Result> CalculateSolid <Result>(ILineTrajectory trajectory, float minAngle, float minLength, float maxLength, Func <ILineTrajectory, IEnumerable <Result> > calculateDashes) => CalculateSolid(0, trajectory, trajectory.DeltaAngle, minAngle, minLength, maxLength, calculateDashes);
