/// <summary>
/// Получить следующую точку
/// </summary>
/// <returns>Следующая точка</returns>
private Point GetNextPoint()
{
var nextPoint = new Point(LinePoints.Last());
nextPoint.Move(1, Direction);
return(nextPoint);
}
// Update is called once per frame
void Update()
{
//if target or source class removed delete message as well
if (fromClass == null || toClass == null)
{
Destroy(gameObject);
return;
}
var line = transform.Find("line");
var label = transform.Find("label");
var arrow = line.Find("arrow");
UILineRenderer lr = line.GetComponent <UILineRenderer>();
var rta = arrow.GetComponent <RectTransform>();
rta.anchoredPosition = new Vector2(Direction * (Width - rta.sizeDelta.x) * 0.5f, 0);
arrow.GetComponent <RectTransform>().localEulerAngles = new Vector3(0, Orientation, 0);
GetComponent <VerticalLayoutGroup>().padding.left = (int)StartPosX;
line.GetComponent <LayoutElement>().minHeight = rta.sizeDelta.y;
var rt = line.GetComponent <RectTransform>();
rt.sizeDelta = new Vector2(Width, 0); //using 0 since height is ignored due to layout
rt = label.GetComponent <RectTransform>();
rt.sizeDelta = new Vector2(Width, 0);
lr.Points = LinePoints.ToArray();
}
/// <summary>
/// Рисует горизонтальную линию
/// </summary>
/// <param name="xLeft">Левая точка линии</param>
/// <param name="xRight">Правая точка линии</param>
/// <param name="y">Точка позиции линии по оси Y</param>
/// <param name="symbol">Символ отрисовки линии</param>
public HorizontalLine(int xLeft, int xRight, int y, char symbol)
{
for (var i = xLeft; i <= xRight; i++)
{
LinePoints.Add(new Point(i, y, symbol));
}
}
private void UpdateView()
{
if (labelText == null || lineRenderer == null)
{
return;
}
labelText.text = Label;
labelText.color = IndicatorColor;
labelText.fontSize = FontSize;
lineRenderer.Points = LinePoints.ToArray();
lineRenderer.color = IndicatorColor;
if (ReversedLabel)
{
labelText.alignment = TextAnchor.MiddleRight;
labelText.GetComponent <RectTransform>().pivot = PivotValue.MIDDLE_RIGHT;
}
else
{
labelText.alignment = TextAnchor.MiddleLeft;
labelText.GetComponent <RectTransform>().pivot = PivotValue.MIDDLE_LEFT;
}
}
/// <summary>
/// Рисует вертикальную линию
/// </summary>
/// <param name="yTop">Верхняя точка линии</param>
/// <param name="yBottom">Нижняя точка линии</param>
/// <param name="x">Точка позиции линии по оси X</param>
/// <param name="symbol">Символ отрисовки линии</param>
public VerticalLine(int yTop, int yBottom, int x, char symbol)
{
for (var i = yTop; i <= yBottom; i++)
{
LinePoints.Add(new Point(x, i, symbol));
}
}
Vector2 Movecircle(Vector2 circlePos, Vector2 nextCirclePos)
{
// Look for the next collision from the current position and direction.
RaycastHit2D hit = Physics2D.CircleCast(circlePos, circleRadius, circleDir, 100f);
LinePoints newLine = GetLine(hit.collider.bounds, hit.centroid);
// Only used for OnDrawGizmos.
lineGizmo = newLine;
dest = hit.centroid;
// Get the closest collision point on the current line.
Vector2 collisionPoint = ClosestPointOnSegment(newLine.p1, newLine.p2, hit.centroid);
// Find distances of current and next circle position.
Vector2 currentCircleDirection = new Vector2(circlePos.x - collisionPoint.x, circlePos.y - collisionPoint.y);
float currentDist = Vector2.Dot(currentCircleDirection, hit.normal);
Vector2 nextCircleDirection = new Vector2(nextCirclePos.x - collisionPoint.x, nextCirclePos.y - collisionPoint.y);
float nextDist = Vector2.Dot(nextCircleDirection, hit.normal);
// Find the time until the circle collides with the line.
float timeToCollision = (circleRadius - currentDist) / (nextDist - currentDist);
// Check timeToCollision to see if a collision will happen in the next frame.
if (timeToCollision >= 0 && timeToCollision <= 1)
{
// If the timeToCollision is less than 1 (1 frame), move the circle to the distance before collision.
Vector2 betweenFrameDirection = new Vector2(nextCirclePos.x - circlePos.x, nextCirclePos.y - circlePos.y);
nextCirclePos = circlePos + (betweenFrameDirection * timeToCollision);
circleDir = Vector2.Reflect(circleDir, hit.normal);
}
// return the circle's next position.
return(nextCirclePos);
}
public bool IsPointInHitArea(double x, double y)
{
//TODO hitarea for lines
int d = 2;
return(LinePoints.Any(p => ((p.X - x) * (p.X - x) + (p.Y - y) * (p.Y - y)) <= d * d /*p.X == x && p.Y == y*/));
}
public void GraficadoraRellenoY(PictureBox cuadradoY, ComboBox color)
{
mGraficosY = cuadradoY.CreateGraphics();
int rango = (int)mLado * 10;
PointF[] PuntosL;
PointF[] PuntosR;
PuntosL = LinePoints.ObtenerPuntos(mA, mC, rango);
PuntosR = LinePoints.ObtenerPuntos(mB, mD, rango);
PointF[] PuntosEntreLineas;
for (int i = 0; i < rango; i++)
{
PuntosEntreLineas = LinePoints.ObtenerPuntos(PuntosL[i], PuntosR[i], rango);
for (int j = 0; j < rango; j++)
{
Point pixel = new Point();
pixel.X = (int)PuntosEntreLineas[j].X;
pixel.Y = (int)PuntosEntreLineas[j].Y;
Rectangle rect = new Rectangle(pixel, new Size(2, 2));
Thread.Sleep(20);
mGraficosY.DrawRectangle(mPen, rect);
}
}
}
public void AddPoint(Vector3 drawPoint, Color pointColor)
{
var localPoint = transform.localScale.PiecewiseMultiply(
transform.localToWorldMatrix.MultiplyPoint(drawPoint));
LinePoints.Add(new VertexDefinition(localPoint, pointColor));
}
public void SetUp()
{
_figure = new Figure()
{
Data = new DataPoints(x: _x, y: _y)
};
_scatter2D = new Scatter()
{
Data = new DataPoints(x: _x, y: _y)
};
_scatter3D = new Scatter()
{
Data = new DataPoints(x: _x, y: _y, z: _z)
};
_line2D = new Line()
{
Data = new DataPoints(x: _x, y: _y)
};
_filledCurves = new FilledCurves()
{
Data = new DataPoints(x: _x, y: _y, z: _z)
};
_linePoints2D = new LinePoints()
{
Data = new DataPoints(x: _x, y: _y)
};
_yError = new YError()
{
Data = new DataPoints(x: _x, y: _y, z: _z)
};
_line3D = new Line()
{
Data = new DataPoints(x: _x, y: _y, z: _z)
};
_linePoints3D = new LinePoints()
{
Data = new DataPoints(x: _x, y: _y, z: _z)
};
_impulse = new Impulse();
_function = new Function()
{
Properties = { Function = _f }
};
_bars = new Bars();
Normal.Samples(_array, mean: 0, stddev: 1);
_histogram = new Histogram()
{
Data = new DataPoints(x: _array)
};
_boxplot = new Boxplot()
{
Data = new DataPoints(x: _array)
};
_vector = new Vector()
{
Data = new DataPoints(x1: _x, x2: _y, y1: _z, y2: _z)
};
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="tail">Позиция хвоста змейки</param>
/// <param name="length">Длина змейки</param>
/// <param name="direction">Направление перемещения змейки</param>
public Snake(Point tail, int length, Direction direction)
{
Direction = direction;
for (var i = 0; i <= length; i++)
{
var point = new Point(tail);
point.Move(i, direction);
LinePoints.Add(point);
}
}
/// <summary>
/// Перемещает змейку
/// </summary>
public void Move()
{
var tail = LinePoints.First();
LinePoints.Remove(tail);
var head = GetNextPoint();
LinePoints.Add(head);
tail.Clear();
head.Draw();
}
public void GraficadoraRellenoZ(PictureBox[] pictureBoxes, ComboBox color, ListBox[] listas)
{
int verificador = ((int)mLado * 10) - 2;
mGraficosZ = pictureBoxes[0].CreateGraphics();
mGraficosX = pictureBoxes[1].CreateGraphics();
mGraficosY = pictureBoxes[2].CreateGraphics();
int rango = (int)mLado * 10;
//Z
PointF[] puntosT1;
PointF[] puntosB1;
puntosT1 = LinePoints.ObtenerPuntos(mA, mB, rango);
puntosB1 = LinePoints.ObtenerPuntos(mC, mD, rango);
//Y
PointF[] puntosL;
PointF[] puntosR;
puntosL = LinePoints.ObtenerPuntos(mA, mC, rango);
puntosR = LinePoints.ObtenerPuntos(mB, mD, rango);
PointF[] puntosEntreLineas;
do
{
mPen = SeleccionarColor(color);
puntosEntreLineas = LinePoints.ObtenerPuntos(puntosL[verificador], puntosR[verificador], rango);
for (int i = puntosL.Length - 2; i > 0; i--)
{
//Z
Thread.Sleep(this.velocidad);
mGraficosZ.DrawLine(mPen, puntosT1[i], puntosB1[i]);
listas[0].Items.Add(puntosT1[i].X.ToString()); listas[1].Items.Add(puntosT1[i].Y.ToString());
listas[2].Items.Add(puntosB1[i].X.ToString()); listas[3].Items.Add(puntosB1[i].Y.ToString());
//Y
Point pixel = new Point();
pixel.X = (int)puntosEntreLineas[i].X;
pixel.Y = (int)puntosEntreLineas[i].Y;
listas[4].Items.Add(puntosL[i].X.ToString()); listas[5].Items.Add(puntosL[i].Y.ToString());
listas[6].Items.Add(puntosR[i].X.ToString()); listas[7].Items.Add(puntosR[i].Y.ToString());
listas[12].Items.Add(pixel.X + "," + pixel.Y);
Rectangle rect = new Rectangle(pixel, new Size(1, 1));
mGraficosY.DrawRectangle(mPen, rect);
}
//X
mGraficosX.DrawLine(mPen, puntosL[verificador], puntosR[verificador]);
listas[8].Items.Add(puntosL[verificador].X.ToString()); listas[9].Items.Add(puntosL[verificador].Y.ToString());
listas[10].Items.Add(puntosR[verificador].X.ToString()); listas[11].Items.Add(puntosR[verificador].Y.ToString());
verificador--;
} while (verificador != 0);
}
/// <summary>
/// Обработка столкновения с хвостом
/// </summary>
/// <returns>True - столкновение было, False - столкновения не было</returns>
public bool IsHitTail()
{
var head = LinePoints.Last();
for (var i = 0; i < LinePoints.Count - 2; i++)
{
if (head.IsHit(LinePoints[i]))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Процесс поедания
/// </summary>
/// <param name="food">Точка еды</param>
/// <returns>True - в данном ходе змейка ест, False - в данном ходе змейка не ест</returns>
public bool Eat(Point food)
{
var head = GetNextPoint();
if (head.IsHit(food))
{
food.Symbol = head.Symbol;
LinePoints.Add(food);
return(true);
}
else
{
return(false);
}
}
public void GraficadoraRellenoZ(PictureBox[] pictureBoxes, ComboBox color, ListBox[] listas)
{
int verificador = ((int)mLado * 10) - 2;
int rango = (int)mLado * 10;
mGraficosZ = pictureBoxes[0].CreateGraphics();
mGraficosX = pictureBoxes[1].CreateGraphics();
mGraficosY = pictureBoxes[2].CreateGraphics();
PointF[] puntosEntreLineas;
//Z
PointF[] puntosIzquierda;
PointF[] puntosDerecha;
PointF[] puntosBase;
puntosIzquierda = LinePoints.ObtenerPuntos(mA, mC, rango);
puntosDerecha = LinePoints.ObtenerPuntos(mA, mB, rango);
puntosBase = LinePoints.ObtenerPuntos(mB, mC, rango);
do
{
mPen = SeleccionarColor(color);
puntosEntreLineas = LinePoints.ObtenerPuntos(puntosIzquierda[verificador], puntosDerecha[verificador], rango);
for (int k = puntosBase.Length - 2, j = 0; k > 0; k--, j++)
{
Thread.Sleep(this.velocidad);
//Z
mGraficosZ.DrawLine(mPen, puntosIzquierda[k], puntosDerecha[k]);
listas[0].Items.Add(puntosIzquierda[k].X.ToString()); listas[1].Items.Add(puntosIzquierda[k].Y.ToString());
listas[2].Items.Add(puntosDerecha[k].X.ToString()); listas[3].Items.Add(puntosDerecha[k].Y.ToString());
//Y
Point pixel = new Point();
pixel.X = (int)puntosEntreLineas[k].X;
pixel.Y = (int)puntosEntreLineas[k].Y;
listas[4].Items.Add(puntosIzquierda[k].X.ToString()); listas[5].Items.Add(puntosIzquierda[k].Y.ToString());
listas[6].Items.Add(puntosDerecha[k].X.ToString()); listas[7].Items.Add(puntosDerecha[k].Y.ToString());
listas[12].Items.Add(pixel.X + "," + pixel.Y);
Rectangle rect = new Rectangle(pixel, new Size(1, 1));
mGraficosY.DrawRectangle(mPen, rect);
}
mGraficosX.DrawLine(mPen, puntosIzquierda[verificador], puntosDerecha[verificador]);
listas[8].Items.Add(puntosIzquierda[verificador].X.ToString()); listas[9].Items.Add(puntosIzquierda[verificador].Y.ToString());
listas[10].Items.Add(puntosDerecha[verificador].X.ToString()); listas[11].Items.Add(puntosDerecha[verificador].Y.ToString());
verificador--;
} while (verificador != 0);
}
public void GraficadoraRellenoX(PictureBox cuadradoX, PictureBox cuadradoY, ComboBox color, int capas)
{
mGraficosX = cuadradoX.CreateGraphics();
int rango = (int)mLado * 10;
PointF[] PuntosL;
PointF[] PuntosR;
PointF Puntos;
PuntosL = LinePoints.ObtenerPuntos(mA, mC, rango);
PuntosR = LinePoints.ObtenerPuntos(mB, mD, rango);
for (int i = 0; i <= capas; i++)
{
mGraficosX.DrawLine(mPen, PuntosR[i], PuntosL[i]);
}
}
public void DrawLine(GameObject car, CurvySpline curvySpline, float carTf)
{
float increaseAmount = 1f / (curvySpline.Length * SPLINE_GIZMO_SMOOTHNESS);
int direction = 1;
float endTf = carTf;
curvySpline.MoveByLengthFast(ref endTf, ref direction, 75.0f, CurvyClamping.Clamp); //this is to determine a constant length of the curve drawn, since Tf isn't proportional to the curve length, so you can't use a constant value!
for (float i = carTf; i < endTf; i += increaseAmount)
{
Vector3 pos = curvySpline.Interpolate(i);
LinePoints.Add(pos);
}
lineRenderer.positionCount = LinePoints.Count;
lineRenderer.SetPositions(LinePoints.ToArray());
LinePoints.Clear();
} //NavigationLine of PlayerCar and TrafficCar in PCH
public bool Edit(SemiAutomaticContourDTO contour)
{
SemiAutomaticContourDTO old = repository.Load(contour.guid);
if (old == null)
{
return(false);
}
List <Point> newListOfPoints = new List <Point>();
int i = 0;
int j = 0;
int countOld = old.lines.First().points.Count;
int countNew = contour.lines.First().points.Count;
Point currentInOld = old.lines.First().points[i];
Point currentInNew = contour.lines.First().points[j];
while (i < countOld)
{
currentInOld = old.lines.First().points[i];
currentInNew = contour.lines.First().points[j];
while (currentInOld.x != currentInNew.x || currentInOld.y != currentInNew.y)
{
i++;
currentInOld = old.lines.First().points[i];
}
newListOfPoints.Add(currentInOld);
i++;
j++;
if (j == countNew)
{
break;
}
}
while (j < countNew)
{
double minDistance = double.MaxValue;
int index = 0;
for (int k = 0; k < newListOfPoints.Count; k++)
{
Point point1 = newListOfPoints[k];
Point point2 = newListOfPoints[(k + 1) % newListOfPoints.Count];
double A = point2.y - point1.y;
double B = point1.x - point2.x;
double C = point2.x * point1.y - point1.x * point2.y;
double m = Math.Sqrt(A * A + B * B);
double distance = Math.Abs(A * currentInNew.x + B * currentInNew.y + C) / m;
if (distance < minDistance)
{
minDistance = distance;
index = k;
}
}
newListOfPoints.Insert(index, currentInNew);
j++;
}
contour.lines.First().points = new List <Point>(newListOfPoints);
List <LinePoints> list = new List <LinePoints>();
LinePoints line = new LinePoints();
line.points = new List <Point>(newListOfPoints);
line.brushColor = contour.lines.First().brushColor;
list.Add(line);
SemiAutomaticPointsDTO contourPointsDTO = new SemiAutomaticPointsDTO(contour.guid, contour.dicomid, contour.tag, list, contour.width, contour.height,
contour.centralPoints, contour.pixelSpacing);
SemiAutomaticContourDTO result = SemiAutomatic.Default(contourPointsDTO);
return(repository.Edit(result));
}
public void ApplyPoints()
{
if (LinePoints.Count < 2)
{
return;
}
Renderers = new List <Renderer>();
MeshFilters = new List <MeshFilter>();
RendererTransforms = new List <Transform>();
int counter = 0;
List <Vector2> .Enumerator pointEnumerator = LinePoints.GetEnumerator();
bool morePoints = pointEnumerator.MoveNext();
while (morePoints)
{
var rendererObject = new GameObject("Renderer Object " + counter++);
rendererObject.transform.parent = transform;
rendererObject.transform.localScale = Vector3.one;
rendererObject.transform.localPosition = Vector3.zero;
rendererObject.transform.localRotation = Quaternion.identity;
var vertList = new List <Vector2>();
while (morePoints && vertList.Count < MaxPointsPerMesh)
{
var thisVert = pointEnumerator.Current;
vertList.Add(thisVert);
morePoints = pointEnumerator.MoveNext();
}
vertList.Add(pointEnumerator.Current);
var mesh = new Mesh();
mesh.vertices = vertList.SelectMany(vertex =>
new List <Vector3>()
{
/*transform.position + transform.PiecewiseMultiply( */ new Vector3(0, vertex.y, vertex.x),
/*transform.position + transform.PiecewiseMultiply( */ new Vector3(0, 0, vertex.x)
}).ToArray();
var indices = Enumerable.Range(0, vertList.Count - 1).SelectMany(i => new List <int>()
{
2 * i, 2 * i + 1, 2 * i + 2, 2 * i + 1, 2 * i + 2, 2 * i + 3
}).ToArray();
mesh.SetIndices(indices.ToArray(), MeshTopology.Triangles, 0);
mesh.UploadMeshData(false);
var meshFilter = rendererObject.AddComponent <MeshFilter>();
MeshFilters.Add(meshFilter);
meshFilter.mesh = mesh;
var localMaterial = Instantiate(LineMaterial);
localMaterial.SetColor("_Color", MainColor);
var myRenderer = rendererObject.AddComponent <MeshRenderer>();
Renderers.Add(myRenderer);
myRenderer.material = localMaterial;
}
}
public void AddPoint(float xPosition, float yPosition)
{
LinePoints.Add(new Vector2(xPosition, yPosition));
}
void Awake()
{
mLine = this;
}
} //NavigationLine of PlayerCar and TrafficCar in PCH
public void DrawLine(GameObject car)
{
List <Vector3> initialList = new List <Vector3>();
TrafAIMotor trafAIMotor = car.GetComponent <TrafAIMotor>();
if (trafAIMotor != null)
{
bool hasNextEntryOk;
TrafEntry nextEntryOk;
int index;
if (car.CompareTag("Player"))
{
//tesla
hasNextEntryOk = trafAIMotor.hasNextEntry50;
nextEntryOk = trafAIMotor.nextEntry50;
if (trafAIMotor.hasNextEntry)
{
index = trafAIMotor.currentFixedNode;
}
else
{
index = trafAIMotor.currentFixedNode + 1;
}
}
else
{
hasNextEntryOk = trafAIMotor.hasNextEntry;
nextEntryOk = trafAIMotor.nextEntry;
index = trafAIMotor.currentFixedNode;
}
if (hasNextEntryOk)
{ //I am waiting at the intersection
TrafEntry nextRoadWaypoints = trafAIMotor.system.GetEntry(trafAIMotor.fixedPath[index].id, trafAIMotor.fixedPath[index].subId); //points of the next piece of road
if (nextRoadWaypoints.waypoints.Count == 2)
{
LinePoints.Add(car.transform.position);
List <Vector3> smoothedPoints = ChaikinCurve(nextEntryOk.waypoints.ToArray(), 4); //intersection points
initialList.AddRange(smoothedPoints);
initialList.Add(nextRoadWaypoints.waypoints[nextRoadWaypoints.waypoints.Count - 1]);
}
else if (nextRoadWaypoints.waypoints.Count > 2)
{
List <Vector3> smoothedPoints = new List <Vector3>();
smoothedPoints.Add(car.transform.position);
smoothedPoints.Add(nextEntryOk.waypoints[0]); //intersection points
smoothedPoints.AddRange(nextRoadWaypoints.waypoints);
initialList.AddRange(ChaikinCurve(smoothedPoints.ToArray(), 2));
}
}
else if (!hasNextEntryOk && trafAIMotor.currentEntry.isIntersection())
{ //I am crossing the intersection
TrafEntry nextRoadWaypoints = trafAIMotor.system.GetEntry(trafAIMotor.fixedPath[trafAIMotor.currentFixedNode].id, trafAIMotor.fixedPath[trafAIMotor.currentFixedNode].subId); //points of the next piece of road
if (nextRoadWaypoints.waypoints.Count == 2)
{
LinePoints.Add(car.transform.position);
List <Vector3> smoothedPoints = ChaikinCurve(trafAIMotor.currentEntry.waypoints.ToArray(), 4);
int nearest = CalculatePointDistance(smoothedPoints, car);
Vector3 heading = smoothedPoints[nearest] - car.transform.position;
if (Vector3.Dot(heading, car.transform.forward) > 0)
{
for (int i = nearest; i < smoothedPoints.Count; i++)
{
initialList.Add(smoothedPoints[i]);
}
}
else
{
for (int i = nearest + 1; i < smoothedPoints.Count; i++)
{
initialList.Add(smoothedPoints[i]);
}
}
initialList.Add(nextRoadWaypoints.waypoints[nextRoadWaypoints.waypoints.Count - 1]);
}
else if (nextRoadWaypoints.waypoints.Count > 2) //if more than 2, smooth and add all of them
{
List <Vector3> smoothedPoints = new List <Vector3>();
smoothedPoints.Add(car.transform.position);
smoothedPoints.Add(trafAIMotor.currentEntry.waypoints[0]); //intersection points
smoothedPoints.AddRange(nextRoadWaypoints.waypoints);
smoothedPoints = ChaikinCurve(smoothedPoints.ToArray(), 2);
int nearest = CalculatePointDistance(smoothedPoints, car);
Vector3 heading = smoothedPoints[nearest] - car.transform.position;
if (Vector3.Dot(heading, car.transform.forward) > 0)
{
for (int i = nearest; i < smoothedPoints.Count; i++)
{
initialList.Add(smoothedPoints[i]);
}
}
else
{
for (int i = nearest + 1; i < smoothedPoints.Count; i++)
{
initialList.Add(smoothedPoints[i]);
}
}
//initialList.AddRange(smoothedPoints);
}
}
else if (!hasNextEntryOk && !trafAIMotor.currentEntry.isIntersection())
{//I am on curves or on straight lines
LinePoints.Add(car.transform.position);
if (trafAIMotor.currentEntry.waypoints.Count == 2)
{
initialList.Add(trafAIMotor.currentEntry.waypoints[trafAIMotor.currentEntry.waypoints.Count - 1]);
}
else if (trafAIMotor.currentEntry.waypoints.Count > 2)
{
List <Vector3> pointsToSmooth = ChaikinCurve(trafAIMotor.currentEntry.waypoints.ToArray(), 2);
int nearest = CalculatePointDistance(pointsToSmooth, car);
Vector3 heading = pointsToSmooth[nearest] - car.transform.position;
if (Vector3.Dot(heading, car.transform.forward) > 0)
{
for (int i = nearest; i < pointsToSmooth.Count; i++)
{
initialList.Add(pointsToSmooth[i]);
}
}
else
{
for (int i = nearest + 1; i < pointsToSmooth.Count; i++)
{
initialList.Add(pointsToSmooth[i]);
}
}
}
}
foreach (var p in initialList)
{
Vector3 currentSpot = p;
RaycastHit hit;
Physics.Raycast(currentSpot + Vector3.up * 5, -Vector3.up, out hit, 100f, (1 << LayerMask.NameToLayer("EnvironmentProp"))); //the layer is EnvironmentProp and not Roads since there is a hidden mesh before roads!
Vector3 correctedPoint = new Vector3(currentSpot.x, hit.point.y + 0.05f, currentSpot.z);
LinePoints.Add(correctedPoint);
}
lineRenderer.positionCount = LinePoints.Count;
lineRenderer.SetPositions(LinePoints.ToArray());
LinePoints.Clear();
}
} //NavigationLine of PlayerCar and TrafficCar in SF
public void ApplyPoints()
{
if (LinePoints.Count < 2)
{
return;
}
Renderers = new List <Renderer>();
MeshFilters = new List <MeshFilter>();
RendererTransforms = new List <Transform>();
int counter = 0;
List <VertexDefinition> .Enumerator pointEnumerator = LinePoints.GetEnumerator();
bool morePoints = pointEnumerator.MoveNext();
var firstVert = LinePoints.First();
var secondVert = LinePoints.Skip(1).First();
var lastVertex = new VertexDefinition(firstVert.Position - secondVert.Position, firstVert.Color);
while (morePoints)
{
var rendererObject = new GameObject("Renderer Object " + (counter++));
rendererObject.transform.parent = transform;
//rendererObject.transform.localScale = Vector3.one;
RendererTransforms.Add(rendererObject.transform);
var mesh = new Mesh();
var vertList = new List <VertexDefinition>();
while (morePoints && vertList.Count < MaxPointsPerMesh)
{
var thisVert = pointEnumerator.Current;
thisVert.LastPosition = lastVertex.Position;
lastVertex.NextPosition = thisVert.Position;
if ((thisVert.Position - lastVertex.Position).sqrMagnitude > .0001f)
{
vertList.Add(thisVert);
lastVertex = thisVert;
}
morePoints = pointEnumerator.MoveNext();
}
lastVertex.NextPosition = !morePoints
? lastVertex.Position + Vector3.up * .2f
: pointEnumerator.Current.Position;
//lastVertex.LastPosition = lastVertex.Position - Vector3.up * .2f;
if (morePoints)
{
pointEnumerator.Current.LastPosition = lastVertex.Position;
}
vertList.Add(!morePoints ? lastVertex :pointEnumerator.Current);
mesh.vertices = vertList.Select(vertex => vertex.Position).ToArray();
mesh.colors = vertList.Select(vertex => vertex.Color).ToArray();
mesh.normals = vertList.Select(vertex => vertex.NextPosition - vertex.Position).ToArray();
mesh.tangents = vertList.Select(vertex => (vertex.LastPosition - vertex.Position).ConvertToVector4()).ToArray();
mesh.colors[0] = Color.magenta;
mesh.colors[mesh.colors.Count() - 1] = Color.magenta;
// for ( int i=0; i<mesh.normals.Count(); i++ )
// {
// var normal = mesh.normals[ i ];
// var tangent = mesh.tangents[ i ];
// var vertex = mesh.vertices[ i ];
//
// if ( normal.sqrMagnitude < Mathf.Pow( .001f, 2f ) )
// {
//
// //Debug.Log( "What? This offset should be greater than zero..." );
// }
// }
var indices = new List <int>();
// indices.Add( 0 );
for (var i = 0; i < vertList.Count; i++)
{
indices.Add(i);
}
// indices.Add( vertList.Count-1 );
mesh.SetIndices(indices.ToArray(), MeshTopology.LineStrip, 0);
mesh.UploadMeshData(false);
var meshFilter = rendererObject.AddComponent <MeshFilter>();
MeshFilters.Add(meshFilter);
meshFilter.mesh = mesh;
var localMaterial = Instantiate(LineMaterial);
localMaterial.SetColor("_Color", MainColor);
localMaterial.SetColor("EdgeColor", EdgeColor);
localMaterial.SetFloat("_Size", LineWidth);
localMaterial.SetFloat("_ZDepthOverride", ZDepthOffset);
localMaterial.SetFloat("_Edge", EdgeWidth);
localMaterial.SetFloat("_PointEdge", PointWidth);
localMaterial.SetFloat("_PulseWidth", PulseWidth);
localMaterial.SetFloat("_Pulse", PulseLine ? 1f : 0f);
localMaterial.SetFloat("_Wipe", WipeLine?1f:0f);
localMaterial.SetFloat("_StartTime", StartTime);
localMaterial.SetFloat("_WipeDuration", WipeDuration);
var myRenderer = rendererObject.AddComponent <MeshRenderer>();
Renderers.Add(myRenderer);
myRenderer.material = localMaterial;
}
foreach (Renderer rend in Renderers)
{
rend.transform.SetWorldScale(Vector3.one);
}
}
/// <summary>
/// Generates the datas.
/// </summary>
override public void GenerateDatas()
{
LinePoints.Clear();
if (!IsPointsGenerated)
{
Parts.Clear();
}
if (this.Points != null && this.SeriesContainer != null)
{
CalculateMinAndMax();
ChartPoint oldPoint = new ChartPoint()
{
XValue = double.MinValue, YValue = double.MinValue
};
IntializePoints();
for (int i = 0; i < this.Points.Count; i++)
{
ChartPoint point = this.Points[i];
ChartPoint step = new ChartPoint();
if (!(i == this.Points.Count - 1))
{
step = this.Points[i + 1];
}
if (CheckValuePoint(oldPoint, point))
{
Point linePoint = NormalizePoint(new Point(point.XValue, point.YValue));
LinePoints.Add(linePoint);
if (!(i == this.Points.Count - 1))
{
Point stepPoint = NormalizePoint(new Point(point.XValue, step.YValue));
LinePoints.Add(stepPoint);
}
}
}
if (this.RenderingMode == RenderingMode.Default)
{
if (!IsPointsGenerated)
{
if (!this.UseSinglePart)
{
for (int i = 0; i < LinePoints.Count - 2; i++)
{
StepLinePart stepLinePart = new StepLinePart(LinePoints[i], LinePoints[i + 1], LinePoints[i + 2]);
SetBindingForStrokeandStrokeThickness(stepLinePart);
this.Parts.Add(stepLinePart);
}
}
else
{
LineSinglePart stepLinePart = new LineSinglePart();
stepLinePart.LinePoints = this.LinePoints;
SetBindingForStrokeandStrokeThickness(stepLinePart);
this.Parts.Add(stepLinePart);
}
IsPointsGenerated = true;
}
else
{
int i = 0;
if (!this.UseSinglePart)
{
foreach (StepLinePart part in this.Parts)
{
part.StartPoint = LinePoints[i];
part.StepPoint = LinePoints[i + 1];
part.EndPoint = LinePoints[i + 2];
part.Refresh();
i++;
}
}
else
{
foreach (LineSinglePart part in this.Parts)
{
part.LinePoints = this.LinePoints;
part.Refresh();
i++;
}
}
}
}
}
else
{
Parts.Clear();
}
if (this.SeriesContainer != null)
{
this.SeriesContainer.Invalidate();
}
IsRefreshed = false;
}
