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);
}
}
}
}
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 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);
}
foreach (var dash in StyleHelper.CalculateDashed(trajectorySecond, dashLength, spaceLength, CalculateDashes))
{
yield return(dash);
}
IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory crosswalkTrajectory, float startT, float endT)
=> CalculateCroswalkPart(crosswalkTrajectory, startT, endT, direction, borders, Width, DashLength);
}
public override void GetUIComponents(MarkupCrosswalk crosswalk, List <EditorItem> components, UIComponent parent, bool isTemplate = false)
{
GetBaseUIComponents(crosswalk, components, parent, isTemplate);
components.Add(AddDashLengthProperty(this, parent));
components.Add(AddSpaceLengthProperty(this, parent));
components.Add(AddParallelProperty(this, parent));
}
public override void GetUIComponents(MarkupCrosswalk crosswalk, List <EditorItem> components, UIComponent parent, bool isTemplate = false)
{
base.GetUIComponents(crosswalk, components, parent, isTemplate);
var useSecondColor = AddUseSecondColorProperty(parent);
var secondColor = AddSecondColorProperty(parent);
components.Add(useSecondColor);
components.Add(secondColor);
useSecondColor.OnSelectObjectChanged += ChangeSecondColorVisible;
ChangeSecondColorVisible(useSecondColor.SelectedObject);
components.Add(AddDashLengthProperty(this, parent));
components.Add(AddSpaceLengthProperty(this, parent));
var useGap = AddUseGapProperty(parent);
var gapLength = AddGapLengthProperty(parent);
var gapPeriod = AddGapPeriodProperty(parent);
components.Add(useGap);
components.Add(gapLength);
components.Add(gapPeriod);
useGap.OnSelectObjectChanged += ChangeGapVisible;
ChangeGapVisible(useGap.SelectedObject);
components.Add(AddParallelProperty(this, parent));
void ChangeSecondColorVisible(bool useSecondColor) => secondColor.isVisible = useSecondColor;
void ChangeGapVisible(bool useGap)
{
gapLength.isVisible = useGap;
gapPeriod.isVisible = useGap;
}
}
public void Update(MarkupCrosswalk crosswalk, bool recalculate = false)
{
crosswalk.Line.Update();
if (recalculate)
{
RecalculateDashes();
}
}
public override void GetUIComponents(MarkupCrosswalk crosswalk, List <EditorItem> components, UIComponent parent, bool isTemplate = false)
{
base.GetUIComponents(crosswalk, components, parent, isTemplate);
components.Add(AddSquareSideProperty(parent));
components.Add(AddLineCountProperty(parent));
if (!isTemplate)
{
components.Add(AddInvertProperty(this, parent));
}
}
public override void GetUIComponents(MarkupCrosswalk crosswalk, List <EditorItem> components, UIComponent parent, bool isTemplate = false)
{
base.GetUIComponents(crosswalk, components, parent, isTemplate);
var offsetBetween = AddOffsetBetweenProperty(this, parent);
if (parent.Find(nameof(OffsetBefore)) is UIComponent offsetBefore)
{
offsetBetween.zOrder = offsetBefore.zOrder + 1;
}
components.Add(offsetBetween);
}
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 override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod)
{
var offset = GetVisibleWidth(crosswalk) / 2 + OffsetBefore;
var coef = Mathf.Sin(crosswalk.CornerAndNormalAngle);
var borders = crosswalk.BorderTrajectories;
var index = 0;
var direction = Parallel ? crosswalk.NormalDir : crosswalk.CornerDir.Turn90(true);
var trajectory = crosswalk.GetFullTrajectory(offset, direction);
if (!UseGap)
{
var dashLength = Parallel ? DashLength / coef : DashLength;
var spaceLength = Parallel ? SpaceLength / coef : SpaceLength;
return(StyleHelper.CalculateDashed(trajectory, dashLength, spaceLength, CalculateDashes));
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);
}
}
}
else
{
var groupLength = (DashLength * GapPeriod + SpaceLength * (GapPeriod - 1));
var dashT = DashLength / groupLength;
var spaceT = SpaceLength / groupLength;
groupLength /= (Parallel ? coef : 1f);
var gapLength = GapLength / (Parallel ? coef : 1f);
return(StyleHelper.CalculateDashed(trajectory, groupLength, gapLength, CalculateDashes));
IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory crosswalkTrajectory, float startT, float endT)
{
index += 1;
for (var i = 0; i < GapPeriod; i += 1)
{
var partStartT = startT + (endT - startT) * (dashT + spaceT) * i;
var partEndT = partStartT + (endT - startT) * dashT;
foreach (var part in CalculateCroswalkPart(crosswalkTrajectory, partStartT, partEndT, direction, borders, Width, DashLength, GetColor(index)))
{
yield return(part);
}
}
}
}
}
protected bool Cut(MarkupCrosswalk crosswalk, ITrajectory trajectory, float width, out ITrajectory cutTrajectory)
{
var delta = width / Mathf.Tan(crosswalk.CornerAndNormalAngle) / 2;
if (2 * delta >= trajectory.Magnitude)
{
cutTrajectory = default;
return(false);
}
else
{
var startCut = trajectory.Travel(0, delta);
var endCut = trajectory.Invert().Travel(0, delta);
cutTrajectory = trajectory.Cut(startCut, 1 - endCut);
return(true);
}
}
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod)
{
var offset = GetVisibleWidth(crosswalk) / 2 + OffsetBefore;
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 trajectory = crosswalk.GetFullTrajectory(offset, direction);
return(StyleHelper.CalculateDashed(trajectory, dashLength, spaceLength, CalculateDashes));
IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory crosswalkTrajectory, float startT, float endT)
=> CalculateCroswalkPart(crosswalkTrajectory, startT, endT, direction, borders, Width, DashLength);
}
public void FromXml(Version version, XElement config, Dictionary <ObjectId, ObjectId> map = null)
{
if (version < new Version("1.2"))
{
map = VersionMigration.Befor1_2(this, map);
}
foreach (var pointConfig in config.Elements(MarkupPoint.XmlName))
{
MarkupPoint.FromXml(pointConfig, this, map);
}
var toInit = new Dictionary <MarkupLine, XElement>();
foreach (var lineConfig in config.Elements(MarkupLine.XmlName))
{
if (MarkupLine.FromXml(lineConfig, this, map, out MarkupLine line))
{
LinesDictionary[line.Id] = line;
toInit[line] = lineConfig;
}
}
foreach (var pair in toInit)
{
pair.Key.FromXml(pair.Value, map);
}
foreach (var fillerConfig in config.Elements(MarkupFiller.XmlName))
{
if (MarkupFiller.FromXml(fillerConfig, this, map, out MarkupFiller filler))
{
FillersList.Add(filler);
}
}
foreach (var crosswalkConfig in config.Elements(MarkupCrosswalk.XmlName))
{
if (MarkupCrosswalk.FromXml(crosswalkConfig, this, map, out MarkupCrosswalk crosswalk))
{
CrosswalksDictionary[crosswalk.Line] = crosswalk;
}
}
Update();
}
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.CalculateSolid(firstTrajectory, lod, CalculateDashes))
{
yield return(dash);
}
foreach (var dash in StyleHelper.CalculateSolid(secondTrajectory, lod, CalculateDashes))
{
yield return(dash);
}
MarkupStylePart CalculateDashes(ITrajectory dashTrajectory) => StyleHelper.CalculateSolidPart(dashTrajectory, 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 abstract IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod);
public override IEnumerable <MarkupStyleDash> Calculate(MarkupCrosswalk crosswalk) => new MarkupStyleDash[0];
public virtual void GetUIComponents(MarkupCrosswalk crosswalk, List <EditorItem> components, UIComponent parent, bool isTemplate = false)
{
}
public void AddCrosswalk(MarkupCrosswalk crosswalk)
{
CrosswalksDictionary[crosswalk.Line] = crosswalk;
crosswalk.RecalculateDashes();
NeedRecalculateBatches = true;
}
public void RemoveCrosswalk(MarkupCrosswalk crosswalk) => RemoveConnect(crosswalk.Line);
public override IEnumerable <MarkupStylePart> Calculate(MarkupCrosswalk crosswalk, MarkupLOD lod) => new MarkupStylePart[0];
public override float GetTotalWidth(MarkupCrosswalk crosswalk) => Width;
protected override float GetVisibleWidth(MarkupCrosswalk crosswalk) => GetLengthCoef(SquareSide * LineCount, crosswalk);
protected float GetLengthCoef(float length, MarkupCrosswalk crosswalk) => length / Mathf.Sin(crosswalk.CornerAndNormalAngle);
protected override float GetVisibleWidth(MarkupCrosswalk crosswalk) => GetLengthCoef(Width * 2 + Offset, crosswalk);
public override void GetUIComponents(MarkupCrosswalk crosswalk, List <EditorItem> components, UIComponent parent, bool isTemplate = false)
{
base.GetUIComponents(crosswalk, components, parent, isTemplate);
components.Add(AddOffsetBeforeProperty(this, parent));
components.Add(AddOffsetAfterProperty(this, parent));
}
public override float GetTotalWidth(MarkupCrosswalk crosswalk) => OffsetBefore + GetVisibleWidth(crosswalk) + OffsetAfter;
protected abstract float GetVisibleWidth(MarkupCrosswalk crosswalk);
public abstract float GetTotalWidth(MarkupCrosswalk crosswalk);
public abstract IEnumerable <MarkupStyleDash> Calculate(MarkupCrosswalk crosswalk);
protected override float GetVisibleWidth(MarkupCrosswalk crosswalk) => Width / Mathf.Sin(crosswalk.CornerAndNormalAngle);
