public Lane(Curve3DSampler sampler, bool _indicate = false) : base(sampler.xz_curve.Clone(), sampler.y_func.Clone(), maxAngleDiff)
{
spriteSampler = new SpriteVerticeSampler(Resources.Load <Sprite>(_indicate ? "Sectors/Indicator" : "Sectors/SimpleRoad"), 1f, 0.1f);
Repaint();
OnShapeChanged += (arg1, arg2) => Repaint();
}
private void UseSingleVirtualCurveForRoad(Curve3DSampler vCurve)
{
inputHandler.stickyMouse.Reset();
inputHandler.stickyMouse.AddLane(RoadPositionRecords.allLanes);
inputHandler.stickyMouse.AddVirtualCurve(new List <Curve3DSampler>()
{
vCurve
});
}
public static void AddLane(Curve3DSampler l,
out List <Lane> added, out List <Lane> deleted)
{
// Variable has not been actually calculated until "ToList()" is called
var lane_intersections = from lane in allLanes
let intersections = lane.IntersectWith(l)
where intersections.Count > 0
select(lane, intersections);
if (lane_intersections.ToList().Count > 0)
{
Debug.Log("From " + allLanes.Count + " found # intersections: " + lane_intersections.ToList()[0].intersections.Count);
}
added = new List <Lane>();
deleted = new List <Lane>();
List <float> l_intersect_params = new List <float>();
// replacements
foreach (var lane_intersection in lane_intersections.ToList())
{
Lane old_lane;
List <Vector3> intersection;
(old_lane, intersection) = lane_intersection;
List <float> intersection_params = intersection.ConvertAll(input => old_lane.xz_curve.ParamOf(Algebra.toVector2(input)).Value);
List <Curve3DSampler> splitted = old_lane.MultiCut(intersection_params, old_lane.xz_curve.Length);
//remove old lanes & destroy objects.
old_lane.SetGameobjVisible(false);
allLanes.Remove(old_lane);
deleted.Add(old_lane);
//create replacements
var replaced_lanes = splitted.ConvertAll(sampler => new Lane(sampler));
added.AddRange(replaced_lanes);
//store intersection points on l
intersection.ForEach(input =>
l_intersect_params.Add(l.xz_curve.ParamOf(Algebra.toVector2(input)).Value));
}
// create new lane
List <Curve3DSampler> l_splitted = l.MultiCut(l_intersect_params, l.xz_curve.Length);
var new_lanes = l_splitted.ConvertAll(sampler => new Lane(sampler));
added.AddRange(new_lanes);
Debug.Log(new_lanes.Count + "newly added");
// Update record
allLanes.AddRange(added);
OnMapChanged?.Invoke(null, allLanes);
}
public void SetTarget(object data)
{
if (data == null)
{
curvesampler = null;
}
else
{
curvesampler = (Lane)data;
Vector3 closestCtrlPoint = curvesampler.ControlPoints.MinBy((Vector3 arg) => float.IsInfinity(arg.x) ? -1 : (input.MagnetMousePosition - arg).sqrMagnitude);
ctrlPointIndex = curvesampler.ControlPoints.LastIndexOf(closestCtrlPoint);
lastFrameMousePosition = input.MagnetMousePosition;
}
}
public void Execute(object obj)
{
Curve3DSampler c = (Lane)obj;
List <Vector3> ctrl = c.ControlPoints;
if (float.IsInfinity(ctrl[0].x))
{
ctrl[0] = position;
}
else
{
ctrl[ctrl.Count - 1] = position;
}
c.ControlPoints = ctrl;
}
public Curve3DSampler StickTo3DCurve(Vector3 position, out Vector3 out_position, float radius = Lane.laneWidth * 0.6f)
{
List <Curve3DSampler> curves = new List <Curve3DSampler>();
if (_source != null)
{
curves.AddRange(_source);
}
if (_lane_source != null)
{
foreach (var lc in _lane_source)
{
curves.Add((Curve3DSampler)lc);
}
}
Debug.Assert(curves.TrueForAll(input => input.IsValid));
// Check if any intersection or end is close
// 1. Find (maybe more than one) lane(s) with ending close to position
if (_lane_source != null)
{
List <Curve3DSampler> close_lane_endings = new List <Curve3DSampler>();
foreach (Curve3DSampler l in _lane_source)
{
if ((l.GetThreedPos(0) - position).sqrMagnitude < radius * radius)
{
close_lane_endings.Add(l);
}
if ((l.GetThreedPos(1) - position).sqrMagnitude < radius * radius)
{
close_lane_endings.Add(l);
}
}
// 1.2. Find the one with least approximation error
if (close_lane_endings.Count > 0)
{
Curve3DSampler leastApproxError = close_lane_endings.MinBy(
(arg) => (arg.GetAttractedPoint(position, radius * 1.01f) - position).sqrMagnitude);
out_position = new List <Vector3> {
leastApproxError.GetThreedPos(0), leastApproxError.GetThreedPos(1)
}.MinBy(
input => (input - position).sqrMagnitude);
return(leastApproxError);
}
}
// 2. Attract to _points
if (_points != null)
{
KeyValuePair <Vector3, Lane> close_point = new KeyValuePair <Vector3, Lane>();
float minsqrMagnitude = float.PositiveInfinity;
foreach (var point_lane in _points)
{
if ((point_lane.Key - position).sqrMagnitude < minsqrMagnitude)
{
close_point = point_lane;
minsqrMagnitude = (point_lane.Key - position).sqrMagnitude;
}
}
if (minsqrMagnitude < radius * radius)
{
out_position = close_point.Key;
return(close_point.Value);
}
}
// 3. Find a point on single curve with least approximation error from whole set
if (curves.Count == 0)
{
out_position = position;
return(null);
}
Curve3DSampler candidate = curves.MinBy(delegate(Curve3DSampler arg)
{
var attracted = arg.GetAttractedPoint(position, radius);
return((attracted == position) ? float.PositiveInfinity : (attracted - position).sqrMagnitude);
});
var attractedMin = candidate.GetAttractedPoint(position, radius);
if (attractedMin == position || (attractedMin - position).sqrMagnitude > radius * radius)
{
out_position = position;
return(null);
}
out_position = attractedMin;
return(candidate);
}
