public static void DrawArrow(VertexHelper vh, Vector3 startPos, Vector3 arrowPos, float width,
float height, float offset, float dent, Color32 color)
{
var dir = (arrowPos - startPos).normalized;
var sharpPos = arrowPos + (offset + height / 2) * dir;
var middle = sharpPos + (dent - height) * dir;
var diff = Vector3.Cross(dir, Vector3.forward).normalized *width / 2;
var left = sharpPos - height * dir + diff;
var right = sharpPos - height * dir - diff;
ChartHelper.DrawTriangle(vh, middle, sharpPos, left, color);
ChartHelper.DrawTriangle(vh, middle, sharpPos, right, color);
}
protected void DrawSymbol(VertexHelper vh, SerieSymbolType type, float symbolSize,
float tickness, Vector3 pos, Color color)
{
switch (type)
{
case SerieSymbolType.None:
break;
case SerieSymbolType.Circle:
ChartHelper.DrawCricle(vh, pos, symbolSize, color, GetSymbolCricleSegment(symbolSize));
break;
case SerieSymbolType.EmptyCircle:
int segment = GetSymbolCricleSegment(symbolSize);
ChartHelper.DrawCricle(vh, pos, symbolSize, m_ThemeInfo.backgroundColor, segment);
ChartHelper.DrawDoughnut(vh, pos, symbolSize - tickness, symbolSize, 0, 360, color, segment);
break;
case SerieSymbolType.Rect:
ChartHelper.DrawPolygon(vh, pos, symbolSize, color);
break;
case SerieSymbolType.Triangle:
var x = symbolSize * Mathf.Cos(30 * Mathf.PI / 180);
var y = symbolSize * Mathf.Sin(30 * Mathf.PI / 180);
var p1 = new Vector2(pos.x - x, pos.y - y);
var p2 = new Vector2(pos.x, pos.y + symbolSize);
var p3 = new Vector2(pos.x + x, pos.y - y);
ChartHelper.DrawTriangle(vh, p1, p2, p3, color);
break;
case SerieSymbolType.Diamond:
p1 = new Vector2(pos.x - symbolSize, pos.y);
p2 = new Vector2(pos.x, pos.y + symbolSize);
p3 = new Vector2(pos.x + symbolSize, pos.y);
var p4 = new Vector2(pos.x, pos.y - symbolSize);
ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color);
break;
}
}
private void DrawYAxisLine(VertexHelper vh)
{
if (m_YAxis.show && m_YAxis.axisLine.show)
{
var lineX = zeroX;
if (m_YAxis.type == Axis.AxisType.Value)
{
lineX = coordinateX;
}
var top = new Vector3(lineX, coordinateY + coordinateHig + m_Coordinate.tickness);
ChartHelper.DrawLine(vh, new Vector3(lineX, coordinateY - m_Coordinate.tickness),
top, m_Coordinate.tickness, m_ThemeInfo.axisLineColor);
if (m_YAxis.axisLine.symbol)
{
var axisLine = m_YAxis.axisLine;
top.y += m_YAxis.axisLine.symbolOffset;
var middle = new Vector3(lineX, top.y - axisLine.symbolHeight + axisLine.symbolDent);
var left = new Vector3(lineX - axisLine.symbolWidth / 2, top.y - axisLine.symbolHeight);
var right = new Vector3(lineX + axisLine.symbolWidth / 2, top.y - axisLine.symbolHeight);
ChartHelper.DrawTriangle(vh, middle, top, left, m_ThemeInfo.axisLineColor);
ChartHelper.DrawTriangle(vh, middle, top, right, m_ThemeInfo.axisLineColor);
}
}
}
private void DrawXAxisLine(VertexHelper vh)
{
if (m_XAxis.show && m_XAxis.axisLine.show)
{
var lineY = zeroY;
if (m_XAxis.type == Axis.AxisType.Value)
{
lineY = coordinateY;
}
var top = new Vector3(coordinateX + coordinateWid + m_Coordinate.tickness, lineY);
ChartHelper.DrawLine(vh, new Vector3(coordinateX - m_Coordinate.tickness, lineY),
top, m_Coordinate.tickness, m_ThemeInfo.axisLineColor);
if (m_XAxis.axisLine.symbol)
{
var axisLine = m_XAxis.axisLine;
top.x += m_XAxis.axisLine.symbolOffset;
var middle = new Vector3(top.x - axisLine.symbolHeight + axisLine.symbolDent, lineY);
var left = new Vector3(top.x - axisLine.symbolHeight, lineY - axisLine.symbolWidth / 2);
var right = new Vector3(top.x - axisLine.symbolHeight, lineY + axisLine.symbolWidth / 2);
ChartHelper.DrawTriangle(vh, middle, top, left, m_ThemeInfo.axisLineColor);
ChartHelper.DrawTriangle(vh, middle, top, right, m_ThemeInfo.axisLineColor);
}
}
}
private void DrawYLineSerie(VertexHelper vh, int serieIndex, Serie serie, ref int dataCount,
ref List <Vector3> points, ref List <Color> colors, ref Dictionary <int, float> seriesHig)
{
if (!IsActive(serie.name))
{
return;
}
List <Vector3> lastPoints = new List <Vector3>();
List <Vector3> lastSmoothPoints = new List <Vector3>();
List <Vector3> smoothPoints = new List <Vector3>();
Color color = m_ThemeInfo.GetColor(serieIndex);
Vector3 lp = Vector3.zero;
Vector3 np = Vector3.zero;
var xAxis = m_XAxises[serie.axisIndex];
var yAxis = m_YAxises[serie.axisIndex];
if (!yAxis.show)
{
yAxis = m_YAxises[(serie.axisIndex + 1) % m_YAxises.Count];
}
float scaleWid = yAxis.GetDataWidth(coordinateHig, m_DataZoom);
float startY = coordinateY + (yAxis.boundaryGap ? scaleWid / 2 : 0);
int maxCount = maxShowDataNumber > 0 ?
(maxShowDataNumber > serie.yData.Count ? serie.yData.Count : maxShowDataNumber)
: serie.yData.Count;
dataCount = (maxCount - minShowDataNumber);
if (m_Line.area && points.Count > 0)
{
if (!m_Line.smooth && points.Count > 0)
{
for (int m = points.Count - dataCount; m < points.Count; m++)
{
lastPoints.Add(points[m]);
}
}
else if (m_Line.smooth && smoothPoints.Count > 0)
{
for (int m = 0; m < smoothPoints.Count; m++)
{
lastSmoothPoints.Add(smoothPoints[m]);
}
smoothPoints.Clear();
}
}
int smoothPointCount = 1;
for (int i = minShowDataNumber; i < maxCount; i++)
{
if (!seriesHig.ContainsKey(i))
{
seriesHig[i] = 0;
}
float value = serie.yData[i];
float pY = startY + i * scaleWid;
float pX = seriesHig[i] + coordinateX + m_Coordinate.tickness;
float dataHig = (value - xAxis.minValue) / (xAxis.maxValue - xAxis.minValue) * coordinateWid;
np = new Vector3(pX + dataHig, pY);
if (i > 0)
{
if (m_Line.step)
{
Vector2 middle1, middle2;
switch (m_Line.stepTpe)
{
case Line.StepType.Start:
middle1 = new Vector2(np.x, lp.y);
middle2 = new Vector2(np.x, lp.y - m_Line.tickness);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color);
if (m_Line.area)
{
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, middle1.y), middle1, np,
new Vector2(coordinateX, np.y), areaColor);
}
break;
case Line.StepType.Middle:
middle1 = new Vector2(lp.x, (lp.y + np.y) / 2 + m_Line.tickness);
middle2 = new Vector2(np.x, (lp.y + np.y) / 2 - m_Line.tickness);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color);
ChartHelper.DrawLine(vh, new Vector2(middle1.x, middle1.y - m_Line.tickness),
new Vector2(middle2.x, middle2.y + m_Line.tickness), m_Line.tickness, color);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color);
if (m_Line.area)
{
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, lp.y), lp, middle1,
new Vector2(coordinateX, middle1.y), areaColor);
ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, middle2.y + 2 * m_Line.tickness),
new Vector2(middle2.x, middle2.y + 2 * m_Line.tickness), np,
new Vector2(coordinateX, np.y), areaColor);
}
break;
case Line.StepType.End:
middle1 = new Vector2(np.x, lp.y);
middle2 = new Vector2(np.x, lp.y - m_Line.tickness);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color);
if (m_Line.area)
{
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, lp.y), middle1,
new Vector2(np.x, np.y),
new Vector2(coordinateX, np.y), areaColor);
}
break;
}
}
else if (m_Line.smooth)
{
var list = ChartHelper.GetBezierListVertical(lp, np, m_Line.smoothStyle);
Vector3 start, to;
start = list[0];
for (int k = 1; k < list.Length; k++)
{
smoothPoints.Add(list[k]);
to = list[k];
ChartHelper.DrawLine(vh, start, to, m_Line.tickness, color);
if (m_Line.area)
{
Vector3 alp = new Vector3(start.x, start.y - m_Line.tickness);
Vector3 anp = new Vector3(to.x, to.y - m_Line.tickness);
Vector3 tnp = serieIndex > 0 ?
(smoothPointCount > lastSmoothPoints.Count - 1 ?
new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 1].x,
lastSmoothPoints[lastSmoothPoints.Count - 1].y + m_Line.tickness) :
new Vector3(lastSmoothPoints[smoothPointCount].x,
lastSmoothPoints[smoothPointCount].y + m_Line.tickness)) :
new Vector3(coordinateX + m_Coordinate.tickness, to.y);
Vector3 tlp = serieIndex > 0 ?
(smoothPointCount > lastSmoothPoints.Count - 1 ?
new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 2].x,
lastSmoothPoints[lastSmoothPoints.Count - 2].y + m_Line.tickness) :
new Vector3(lastSmoothPoints[smoothPointCount - 1].x,
lastSmoothPoints[smoothPointCount - 1].y + m_Line.tickness)) :
new Vector3(coordinateX + m_Coordinate.tickness, start.y);
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor);
}
smoothPointCount++;
start = to;
}
}
else
{
ChartHelper.DrawLine(vh, lp, np, m_Line.tickness, color);
if (m_Line.area)
{
Vector3 alp = new Vector3(lp.x, lp.y - m_Line.tickness);
Vector3 anp = new Vector3(np.x, np.y - m_Line.tickness);
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
var cross = ChartHelper.GetIntersection(lp, np, new Vector3(coordinateX, coordinateY),
new Vector3(coordinateX, coordinateY + coordinateHig));
if (cross == Vector3.zero)
{
Vector3 tnp = serieIndex > 0 ?
new Vector3(lastPoints[i].x, lastPoints[i].y + m_Line.tickness) :
new Vector3(coordinateX + m_Coordinate.tickness, np.y);
Vector3 tlp = serieIndex > 0 ?
new Vector3(lastPoints[i - 1].x, lastPoints[i - 1].y + m_Line.tickness) :
new Vector3(coordinateX + m_Coordinate.tickness, lp.y);
ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor);
}
else
{
Vector3 cross1 = new Vector3(cross.x + (alp.x > coordinateX ? m_Coordinate.tickness : -m_Coordinate.tickness), cross.y);
Vector3 cross2 = new Vector3(cross.x + (anp.x > coordinateX ? m_Coordinate.tickness : -m_Coordinate.tickness), cross.y);
Vector3 xp1 = new Vector3(coordinateX + (alp.x > coordinateX ? m_Coordinate.tickness : -m_Coordinate.tickness), alp.y);
Vector3 xp2 = new Vector3(coordinateX + (anp.x > coordinateX ? m_Coordinate.tickness : -m_Coordinate.tickness), anp.y);
ChartHelper.DrawTriangle(vh, alp, cross1, xp1, areaColor);
ChartHelper.DrawTriangle(vh, anp, cross2, xp2, areaColor);
}
}
}
}
if (m_Line.point)
{
points.Add(np);
colors.Add(color);
}
seriesHig[i] += dataHig;
lp = np;
}
}
private void DrawData(VertexHelper vh)
{
Vector3 startPoint = Vector3.zero;
Vector3 toPoint = Vector3.zero;
Vector3 firstPoint = Vector3.zero;
serieNameSet.Clear();
int serieNameCount = -1;
for (int i = 0; i < m_Series.Count; i++)
{
var serie = m_Series.series[i];
var radar = m_Radars[serie.radarIndex];
int indicatorNum = radar.indicatorList.Count;
var angle = 2 * Mathf.PI / indicatorNum;
Vector3 p = radar.centerPos;
if (!IsActive(i))
{
continue;
}
for (int j = 0; j < serie.data.Count; j++)
{
var serieData = serie.data[j];
int key = i * 100 + j;
if (!radar.dataPosList.ContainsKey(key))
{
radar.dataPosList.Add(i * 100 + j, new List <Vector3>(serieData.data.Count));
}
else
{
radar.dataPosList[key].Clear();
}
string dataName = serieData.name;
int serieIndex = 0;
if (string.IsNullOrEmpty(dataName))
{
serieNameCount++;
serieIndex = serieNameCount;
}
else if (!serieNameSet.ContainsKey(dataName))
{
serieNameSet.Add(dataName, serieNameCount);
serieNameCount++;
serieIndex = serieNameCount;
}
else
{
serieIndex = serieNameSet[dataName];
}
if (!serieData.show)
{
continue;
}
var isHighlight = serie.highlighted || serieData.highlighted ||
(m_Tooltip.show && m_Tooltip.dataIndex[0] == i && m_Tooltip.dataIndex[1] == j);
var areaColor = serie.GetAreaColor(m_ThemeInfo, serieIndex, isHighlight);
var lineColor = serie.GetLineColor(m_ThemeInfo, serieIndex, isHighlight);
int dataCount = radar.indicatorList.Count;
List <Vector3> pointList = radar.dataPosList[key];
for (int n = 0; n < dataCount; n++)
{
if (n >= serieData.data.Count)
{
break;
}
float min = radar.GetIndicatorMin(n);
float max = radar.GetIndicatorMax(n);
float value = serieData.data[n];
if (max == 0)
{
serie.GetMinMaxData(n, out min, out max);
min = radar.GetIndicatorMin(n);
}
var radius = max < 0 ? radar.actualRadius - radar.actualRadius * value / max
: radar.actualRadius * value / max;
var currAngle = n * angle;
if (n == 0)
{
startPoint = new Vector3(p.x + radius * Mathf.Sin(currAngle),
p.y + radius * Mathf.Cos(currAngle));
firstPoint = startPoint;
}
else
{
toPoint = new Vector3(p.x + radius * Mathf.Sin(currAngle),
p.y + radius * Mathf.Cos(currAngle));
if (serie.areaStyle.show)
{
ChartHelper.DrawTriangle(vh, p, startPoint, toPoint, areaColor);
}
if (serie.lineStyle.show)
{
ChartHelper.DrawLine(vh, startPoint, toPoint, serie.lineStyle.width, lineColor);
}
startPoint = toPoint;
}
pointList.Add(startPoint);
}
if (serie.areaStyle.show)
{
ChartHelper.DrawTriangle(vh, p, startPoint, firstPoint, areaColor);
}
if (serie.lineStyle.show)
{
ChartHelper.DrawLine(vh, startPoint, firstPoint, serie.lineStyle.width, lineColor);
}
if (serie.symbol.type != SerieSymbolType.None)
{
var symbolSize = (isHighlight ? serie.symbol.selectedSize : serie.symbol.size);
float symbolRadius = symbolSize - serie.lineStyle.width * 2;
var symbolColor = serie.symbol.color != Color.clear ? serie.symbol.color : lineColor;
symbolColor.a *= serie.symbol.opacity;
foreach (var point in pointList)
{
DrawSymbol(vh, serie.symbol.type, symbolSize, serie.lineStyle.width, point, symbolColor);
}
}
}
}
}
private void DrawData(VertexHelper vh)
{
int indicatorNum = m_Radar.indicatorList.Count;
var angle = 2 * Mathf.PI / indicatorNum;
var p = new Vector3(m_RadarCenterX, m_RadarCenterY);
Vector3 startPoint = Vector3.zero;
Vector3 toPoint = Vector3.zero;
Vector3 firstPoint = Vector3.zero;
dataPosList.Clear();
dataPosList.Capacity = m_Series.Count;
for (int i = 0; i < m_Series.Count; i++)
{
if (!IsActive(i))
{
dataPosList.Add(new List <Vector3>());
continue;
}
var dataList = m_Series.series[i].yData;
var color = m_ThemeInfo.GetColor(i);
var areaColor = color;
areaColor.a = (byte)m_Radar.areaAipha;
List <Vector3> pointList = new List <Vector3>(dataList.Count);
dataPosList.Add(pointList);
for (int j = 0; j < dataList.Count; j++)
{
var max = m_Radar.GetIndicatorMax(j) > 0 ?
m_Radar.GetIndicatorMax(j) :
GetMaxValue(j);
var radius = max < 0 ? m_Radar.radius - m_Radar.radius * dataList[j] / max
: m_Radar.radius * dataList[j] / max;
var currAngle = j * angle;
if (j == 0)
{
startPoint = new Vector3(p.x + radius * Mathf.Sin(currAngle),
p.y + radius * Mathf.Cos(currAngle));
firstPoint = startPoint;
}
else
{
toPoint = new Vector3(p.x + radius * Mathf.Sin(currAngle),
p.y + radius * Mathf.Cos(currAngle));
if (m_Radar.area)
{
ChartHelper.DrawTriangle(vh, p, startPoint, toPoint, areaColor);
}
ChartHelper.DrawLine(vh, startPoint, toPoint, m_Radar.lineTickness, color);
startPoint = toPoint;
}
pointList.Add(startPoint);
}
if (m_Radar.area)
{
ChartHelper.DrawTriangle(vh, p, startPoint, firstPoint, areaColor);
}
ChartHelper.DrawLine(vh, startPoint, firstPoint, m_Radar.lineTickness, color);
foreach (var point in pointList)
{
float radius = m_Radar.linePointSize - m_Radar.lineTickness * 2;
ChartHelper.DrawCricle(vh, point, radius, Color.white);
ChartHelper.DrawDoughnut(vh, point, radius, m_Radar.linePointSize, 0, 360, color);
}
}
}
private void DrawXCategory(VertexHelper vh)
{
var stackSeries = m_Series.GetStackSeries();
int seriesCount = stackSeries.Count;
float scaleWid = m_XAxis.GetDataWidth(coordinateWid, m_DataZoom);
int serieCount = 0;
List <Vector3> points = new List <Vector3>();
List <Vector3> smoothPoints = new List <Vector3>();
List <Color> colorList = new List <Color>();
int dataCount = 0;
for (int j = 0; j < seriesCount; j++)
{
var seriesCurrHig = new Dictionary <int, float>();
var serieList = stackSeries[j];
for (int n = 0; n < serieList.Count; n++)
{
Serie serie = serieList[n];
if (!IsActive(serie.name))
{
continue;
}
List <Vector3> lastPoints = new List <Vector3>();
List <Vector3> lastSmoothPoints = new List <Vector3>();
List <float> serieData = serie.GetData(m_DataZoom);
Color color = m_ThemeInfo.GetColor(serieCount);
Vector3 lp = Vector3.zero;
Vector3 np = Vector3.zero;
float startX = zeroX + (m_XAxis.boundaryGap ? scaleWid / 2 : 0);
int maxCount = maxShowDataNumber > 0 ?
(maxShowDataNumber > serieData.Count ? serieData.Count : maxShowDataNumber)
: serieData.Count;
dataCount = (maxCount - minShowDataNumber);
if (m_Line.area && points.Count > 0)
{
if (!m_Line.smooth && points.Count > 0)
{
for (int m = points.Count - dataCount; m < points.Count; m++)
{
lastPoints.Add(points[m]);
}
}
else if (m_Line.smooth && smoothPoints.Count > 0)
{
for (int m = 0; m < smoothPoints.Count; m++)
{
lastSmoothPoints.Add(smoothPoints[m]);
}
smoothPoints.Clear();
}
}
int smoothPointCount = 1;
for (int i = minShowDataNumber; i < maxCount; i++)
{
if (!seriesCurrHig.ContainsKey(i))
{
seriesCurrHig[i] = 0;
}
float value = serieData[i];
float pX = startX + i * scaleWid;
float pY = seriesCurrHig[i] + zeroY + m_Coordinate.tickness;
float dataHig = value / (maxValue - minValue) * coordinateHig;
np = new Vector3(pX, pY + dataHig);
if (i > 0)
{
if (m_Line.step)
{
Vector2 middle1, middle2;
switch (m_Line.stepTpe)
{
case Line.StepType.Start:
middle1 = new Vector2(lp.x, np.y + m_Line.tickness);
middle2 = new Vector2(lp.x - m_Line.tickness, np.y);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color);
if (m_Line.area)
{
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, new Vector2(middle1.x, zeroY), middle1, np,
new Vector2(np.x, zeroY), areaColor);
}
break;
case Line.StepType.Middle:
middle1 = new Vector2((lp.x + np.x) / 2 + m_Line.tickness, lp.y);
middle2 = new Vector2((lp.x + np.x) / 2 - m_Line.tickness, np.y);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color);
ChartHelper.DrawLine(vh, new Vector2(middle1.x - m_Line.tickness, middle1.y),
new Vector2(middle2.x + m_Line.tickness, middle2.y), m_Line.tickness, color);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color);
if (m_Line.area)
{
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, new Vector2(lp.x, zeroY), lp, middle1,
new Vector2(middle1.x, zeroY), areaColor);
ChartHelper.DrawPolygon(vh, new Vector2(middle2.x + 2 * m_Line.tickness, zeroY),
new Vector2(middle2.x + 2 * m_Line.tickness, middle2.y), np,
new Vector2(np.x, zeroY), areaColor);
}
break;
case Line.StepType.End:
middle1 = new Vector2(np.x + m_Line.tickness, lp.y);
middle2 = new Vector2(np.x, lp.y);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color);
if (m_Line.area)
{
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, new Vector2(lp.x, zeroY), lp,
new Vector2(middle1.x - m_Line.tickness, middle1.y),
new Vector2(middle1.x - m_Line.tickness, zeroY), areaColor);
}
break;
}
}
else if (m_Line.smooth)
{
var list = ChartHelper.GetBezierList(lp, np, m_Line.smoothStyle);
Vector3 start, to;
start = list[0];
for (int k = 1; k < list.Length; k++)
{
smoothPoints.Add(list[k]);
to = list[k];
ChartHelper.DrawLine(vh, start, to, m_Line.tickness, color);
if (m_Line.area)
{
Vector3 alp = new Vector3(start.x, start.y - m_Line.tickness);
Vector3 anp = new Vector3(to.x, to.y - m_Line.tickness);
Vector3 tnp = serieCount > 0 ?
(smoothPointCount > lastSmoothPoints.Count - 1 ?
new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 1].x,
lastSmoothPoints[lastSmoothPoints.Count - 1].y + m_Line.tickness) :
new Vector3(lastSmoothPoints[smoothPointCount].x,
lastSmoothPoints[smoothPointCount].y + m_Line.tickness)) :
new Vector3(to.x, zeroY + m_Coordinate.tickness);
Vector3 tlp = serieCount > 0 ?
(smoothPointCount > lastSmoothPoints.Count - 1 ?
new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 2].x,
lastSmoothPoints[lastSmoothPoints.Count - 2].y + m_Line.tickness) :
new Vector3(lastSmoothPoints[smoothPointCount - 1].x,
lastSmoothPoints[smoothPointCount - 1].y + m_Line.tickness)) :
new Vector3(start.x, zeroY + m_Coordinate.tickness);
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor);
}
smoothPointCount++;
start = to;
}
}
else
{
ChartHelper.DrawLine(vh, lp, np, m_Line.tickness, color);
if (m_Line.area)
{
Vector3 alp = new Vector3(lp.x, lp.y - m_Line.tickness);
Vector3 anp = new Vector3(np.x, np.y - m_Line.tickness);
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
var cross = ChartHelper.GetIntersection(lp, np, new Vector3(zeroX, zeroY),
new Vector3(zeroX + coordinateWid, zeroY));
if (cross == Vector3.zero)
{
Vector3 tnp = serieCount > 0 ?
new Vector3(lastPoints[i].x, lastPoints[i].y + m_Line.tickness) :
new Vector3(np.x, zeroY + m_Coordinate.tickness);
Vector3 tlp = serieCount > 0 ?
new Vector3(lastPoints[i - 1].x, lastPoints[i - 1].y + m_Line.tickness) :
new Vector3(lp.x, zeroY + m_Coordinate.tickness);
ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor);
}
else
{
Vector3 cross1 = new Vector3(cross.x, cross.y + (alp.y > zeroY ? m_Coordinate.tickness : -m_Coordinate.tickness));
Vector3 cross2 = new Vector3(cross.x, cross.y + (anp.y > zeroY ? m_Coordinate.tickness : -m_Coordinate.tickness));
Vector3 xp1 = new Vector3(alp.x, zeroY + (alp.y > zeroY ? m_Coordinate.tickness : -m_Coordinate.tickness));
Vector3 xp2 = new Vector3(anp.x, zeroY + (anp.y > zeroY ? m_Coordinate.tickness : -m_Coordinate.tickness));
ChartHelper.DrawTriangle(vh, alp, cross1, xp1, areaColor);
ChartHelper.DrawTriangle(vh, anp, cross2, xp2, areaColor);
}
}
}
}
if (m_Line.point)
{
points.Add(np);
colorList.Add(color);
}
seriesCurrHig[i] += dataHig;
lp = np;
}
if (serie.show)
{
serieCount++;
}
}
// draw point
if (m_Line.point)
{
for (int i = 0; i < points.Count; i++)
{
Vector3 p = points[i];
float pointWid = m_Line.pointWidth;
if (m_Tooltip.show && i % dataCount == m_Tooltip.dataIndex - 1)
{
pointWid = pointWid * 1.8f;
}
if (m_Theme == Theme.Dark)
{
ChartHelper.DrawCricle(vh, p, pointWid, colorList[i],
(int)m_Line.pointWidth * 5);
}
else
{
ChartHelper.DrawCricle(vh, p, pointWid, Color.white);
ChartHelper.DrawDoughnut(vh, p, pointWid - m_Line.tickness,
pointWid, 0, 360, colorList[i]);
}
}
}
}
//draw tooltip line
if (m_Tooltip.show && m_Tooltip.dataIndex > 0)
{
float splitWidth = m_XAxis.GetSplitWidth(coordinateWid, m_DataZoom);
float px = zeroX + (m_Tooltip.dataIndex - 1) * splitWidth
+ (m_XAxis.boundaryGap ? splitWidth / 2 : 0);
Vector2 sp = new Vector2(px, coordinateY);
Vector2 ep = new Vector2(px, coordinateY + coordinateHig);
ChartHelper.DrawLine(vh, sp, ep, m_Coordinate.tickness, m_ThemeInfo.tooltipLineColor);
if (m_Tooltip.crossLabel)
{
sp = new Vector2(zeroX, m_Tooltip.pointerPos.y);
ep = new Vector2(zeroX + coordinateWid, m_Tooltip.pointerPos.y);
DrawSplitLine(vh, true, Axis.SplitLineType.Dashed, sp, ep, m_ThemeInfo.tooltipLineColor);
}
}
}
private void DrawXLineSerie(VertexHelper vh, int serieIndex, Color color, Serie serie, ref int dataCount,
ref List <Vector3> points, ref List <int> pointSerieIndexs, ref List <float> seriesHig)
{
if (!IsActive(serie.index))
{
return;
}
lastPoints.Clear();
lastSmoothPoints.Clear();
smoothPoints.Clear();
List <float> yData = serie.GetYDataList(m_DataZoom);
List <float> xData = serie.GetXDataList(m_DataZoom);
Vector3 lp = Vector3.zero;
Vector3 np = Vector3.zero;
var yAxis = m_YAxises[serie.axisIndex];
var xAxis = m_XAxises[serie.axisIndex];
if (!xAxis.show)
{
xAxis = m_XAxises[(serie.axisIndex + 1) % m_XAxises.Count];
}
float scaleWid = xAxis.GetDataWidth(coordinateWid, m_DataZoom);
float startX = coordinateX + (xAxis.boundaryGap ? scaleWid / 2 : 0);
int maxCount = maxShowDataNumber > 0 ?
(maxShowDataNumber > yData.Count ? yData.Count : maxShowDataNumber)
: yData.Count;
dataCount = (maxCount - minShowDataNumber);
if (m_Line.area && points.Count > 0)
{
if (!m_Line.smooth && points.Count > 0)
{
for (int m = points.Count - dataCount; m < points.Count; m++)
{
lastPoints.Add(points[m]);
}
}
else if (m_Line.smooth && smoothPoints.Count > 0)
{
for (int m = 0; m < smoothPoints.Count; m++)
{
lastSmoothPoints.Add(smoothPoints[m]);
}
smoothPoints.Clear();
}
}
int smoothPointCount = 1;
if (seriesHig.Count < minShowDataNumber)
{
for (int i = 0; i < minShowDataNumber; i++)
{
seriesHig.Add(0);
}
}
for (int i = minShowDataNumber; i < maxCount; i++)
{
if (i >= seriesHig.Count)
{
seriesHig.Add(0);
}
float yValue = yData[i];
float yDataHig;
if (xAxis.IsValue())
{
float xValue = i > xData.Count - 1 ? 0 : xData[i];
float pX = coordinateX + m_Coordinate.tickness;
float pY = seriesHig[i] + coordinateY + m_Coordinate.tickness;
float xDataHig = (xValue - xAxis.minValue) / (xAxis.maxValue - xAxis.minValue) * coordinateWid;
yDataHig = (yValue - yAxis.minValue) / (yAxis.maxValue - yAxis.minValue) * coordinateHig;
np = new Vector3(pX + xDataHig, pY + yDataHig);
}
else
{
float pX = startX + i * scaleWid;
float pY = seriesHig[i] + coordinateY + m_Coordinate.tickness;
yDataHig = (yValue - yAxis.minValue) / (yAxis.maxValue - yAxis.minValue) * coordinateHig;
np = new Vector3(pX, pY + yDataHig);
}
if (i > 0)
{
if (m_Line.step)
{
Vector2 middle1, middle2;
switch (m_Line.stepTpe)
{
case Line.StepType.Start:
middle1 = new Vector2(lp.x, np.y + m_Line.tickness);
middle2 = new Vector2(lp.x - m_Line.tickness, np.y);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color);
if (m_Line.area)
{
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, new Vector2(middle1.x, coordinateY), middle1, np,
new Vector2(np.x, coordinateY), areaColor);
}
break;
case Line.StepType.Middle:
middle1 = new Vector2((lp.x + np.x) / 2 + m_Line.tickness, lp.y);
middle2 = new Vector2((lp.x + np.x) / 2 - m_Line.tickness, np.y);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color);
ChartHelper.DrawLine(vh, new Vector2(middle1.x - m_Line.tickness, middle1.y),
new Vector2(middle2.x + m_Line.tickness, middle2.y), m_Line.tickness, color);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color);
if (m_Line.area)
{
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, new Vector2(lp.x, coordinateY), lp, middle1,
new Vector2(middle1.x, coordinateY), areaColor);
ChartHelper.DrawPolygon(vh, new Vector2(middle2.x + 2 * m_Line.tickness, coordinateY),
new Vector2(middle2.x + 2 * m_Line.tickness, middle2.y), np,
new Vector2(np.x, coordinateY), areaColor);
}
break;
case Line.StepType.End:
middle1 = new Vector2(np.x + m_Line.tickness, lp.y);
middle2 = new Vector2(np.x, lp.y);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, color);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, color);
if (m_Line.area)
{
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, new Vector2(lp.x, coordinateY), lp,
new Vector2(middle1.x - m_Line.tickness, middle1.y),
new Vector2(middle1.x - m_Line.tickness, coordinateY), areaColor);
}
break;
}
}
else if (m_Line.smooth)
{
if (xAxis.IsValue())
{
ChartHelper.GetBezierListVertical(ref smoothSegmentPoints, lp, np, m_Line.smoothStyle);
}
else
{
ChartHelper.GetBezierList(ref smoothSegmentPoints, lp, np, m_Line.smoothStyle);
}
Vector3 start, to;
start = smoothSegmentPoints[0];
for (int k = 1; k < smoothSegmentPoints.Count; k++)
{
smoothPoints.Add(smoothSegmentPoints[k]);
to = smoothSegmentPoints[k];
ChartHelper.DrawLine(vh, start, to, m_Line.tickness, color);
if (m_Line.area)
{
Vector3 alp = new Vector3(start.x, start.y - m_Line.tickness);
Vector3 anp = new Vector3(to.x, to.y - m_Line.tickness);
Vector3 tnp = serieIndex > 0 ?
(smoothPointCount > lastSmoothPoints.Count - 1 ?
new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 1].x,
lastSmoothPoints[lastSmoothPoints.Count - 1].y + m_Line.tickness) :
new Vector3(lastSmoothPoints[smoothPointCount].x,
lastSmoothPoints[smoothPointCount].y + m_Line.tickness)) :
new Vector3(to.x, coordinateY + m_Coordinate.tickness);
Vector3 tlp = serieIndex > 0 ?
(smoothPointCount > lastSmoothPoints.Count - 1 ?
new Vector3(lastSmoothPoints[lastSmoothPoints.Count - 2].x,
lastSmoothPoints[lastSmoothPoints.Count - 2].y + m_Line.tickness) :
new Vector3(lastSmoothPoints[smoothPointCount - 1].x,
lastSmoothPoints[smoothPointCount - 1].y + m_Line.tickness)) :
new Vector3(start.x, coordinateY + m_Coordinate.tickness);
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor);
}
smoothPointCount++;
start = to;
}
}
else
{
ChartHelper.DrawLine(vh, lp, np, m_Line.tickness, color);
if (m_Line.area)
{
Vector3 alp = new Vector3(lp.x, lp.y - m_Line.tickness);
Vector3 anp = new Vector3(np.x, np.y - m_Line.tickness);
Color areaColor = new Color(color.r, color.g, color.b, color.a * 0.75f);
var cross = ChartHelper.GetIntersection(lp, np, new Vector3(coordinateX, coordinateY),
new Vector3(coordinateX + coordinateWid, coordinateY));
if (cross == Vector3.zero)
{
Vector3 tnp = serieIndex > 0 ?
new Vector3(lastPoints[i].x, lastPoints[i].y + m_Line.tickness) :
new Vector3(np.x, coordinateY + m_Coordinate.tickness);
Vector3 tlp = serieIndex > 0 ?
new Vector3(lastPoints[i - 1].x, lastPoints[i - 1].y + m_Line.tickness) :
new Vector3(lp.x, coordinateY + m_Coordinate.tickness);
ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor);
}
else
{
Vector3 cross1 = new Vector3(cross.x, cross.y + (alp.y > coordinateY ? m_Coordinate.tickness : -m_Coordinate.tickness));
Vector3 cross2 = new Vector3(cross.x, cross.y + (anp.y > coordinateY ? m_Coordinate.tickness : -m_Coordinate.tickness));
Vector3 xp1 = new Vector3(alp.x, coordinateY + (alp.y > coordinateY ? m_Coordinate.tickness : -m_Coordinate.tickness));
Vector3 xp2 = new Vector3(anp.x, coordinateY + (anp.y > coordinateY ? m_Coordinate.tickness : -m_Coordinate.tickness));
ChartHelper.DrawTriangle(vh, alp, cross1, xp1, areaColor);
ChartHelper.DrawTriangle(vh, anp, cross2, xp2, areaColor);
}
}
}
}
if (serie.symbol.type != SerieSymbolType.None || m_Line.area)
{
points.Add(np);
pointSerieIndexs.Add(serie.index);
}
seriesHig[i] += yDataHig;
lp = np;
}
}
private void DrawYLineSerie(VertexHelper vh, int serieIndex, Color lineColor, Serie serie, ref List <float> seriesHig)
{
if (!IsActive(serie.index))
{
return;
}
var showData = serie.GetDataList(m_DataZoom);
Vector3 lp = Vector3.zero;
Vector3 np = Vector3.zero;
Color areaColor = new Color(lineColor.r, lineColor.g, lineColor.b, lineColor.a * 0.75f);
var xAxis = m_XAxises[serie.axisIndex];
var yAxis = m_YAxises[serie.axisIndex];
var lastSerie = m_Series.GetSerie(serieIndex - 1);
var isStack = m_Series.IsStack(serie.stack);
if (!yAxis.show)
{
yAxis = m_YAxises[(serie.axisIndex + 1) % m_YAxises.Count];
}
float scaleWid = yAxis.GetDataWidth(coordinateHig, m_DataZoom);
float startY = coordinateY + (yAxis.boundaryGap ? scaleWid / 2 : 0);
int maxCount = maxShowDataNumber > 0 ?
(maxShowDataNumber > showData.Count ? showData.Count : maxShowDataNumber)
: showData.Count;
if (seriesHig.Count < minShowDataNumber)
{
for (int i = 0; i < minShowDataNumber; i++)
{
seriesHig.Add(0);
}
}
for (int i = minShowDataNumber; i < maxCount; i++)
{
if (i >= seriesHig.Count)
{
seriesHig.Add(0);
}
float value = showData[i].data[1];
float pY = startY + i * scaleWid;
float pX = seriesHig[i] + coordinateX + yAxis.axisLine.width;
float dataHig = (value - xAxis.minValue) / (xAxis.maxValue - xAxis.minValue) * coordinateWid;
np = new Vector3(pX + dataHig, pY);
if (i > 0)
{
if (m_Line.step)
{
Vector2 middle1, middle2;
switch (m_Line.stepTpe)
{
case Line.StepType.Start:
middle1 = new Vector2(np.x, lp.y);
middle2 = new Vector2(np.x, lp.y - m_Line.tickness);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, lineColor);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, lineColor);
if (m_Line.area)
{
ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, middle1.y), middle1, np,
new Vector2(coordinateX, np.y), areaColor);
}
break;
case Line.StepType.Middle:
middle1 = new Vector2(lp.x, (lp.y + np.y) / 2 + m_Line.tickness);
middle2 = new Vector2(np.x, (lp.y + np.y) / 2 - m_Line.tickness);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, lineColor);
ChartHelper.DrawLine(vh, new Vector2(middle1.x, middle1.y - m_Line.tickness),
new Vector2(middle2.x, middle2.y + m_Line.tickness), m_Line.tickness, lineColor);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, lineColor);
if (m_Line.area)
{
ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, lp.y), lp, middle1,
new Vector2(coordinateX, middle1.y), areaColor);
ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, middle2.y + 2 * m_Line.tickness),
new Vector2(middle2.x, middle2.y + 2 * m_Line.tickness), np,
new Vector2(coordinateX, np.y), areaColor);
}
break;
case Line.StepType.End:
middle1 = new Vector2(np.x, lp.y);
middle2 = new Vector2(np.x, lp.y - m_Line.tickness);
ChartHelper.DrawLine(vh, lp, middle1, m_Line.tickness, lineColor);
ChartHelper.DrawLine(vh, middle2, np, m_Line.tickness, lineColor);
if (m_Line.area)
{
ChartHelper.DrawPolygon(vh, new Vector2(coordinateX, lp.y), middle1,
new Vector2(np.x, np.y),
new Vector2(coordinateX, np.y), areaColor);
}
break;
}
}
else if (m_Line.smooth)
{
DrawSmoothAreaPoints(vh, serieIndex, serie, yAxis, lp, np, i, lineColor, areaColor, isStack);
}
else
{
ChartHelper.DrawLine(vh, lp, np, m_Line.tickness, lineColor);
if (m_Line.area)
{
Vector3 alp = new Vector3(lp.x, lp.y);
Vector3 anp = new Vector3(np.x, np.y);
var cross = ChartHelper.GetIntersection(lp, np, new Vector3(coordinateX, coordinateY),
new Vector3(coordinateX, coordinateY + coordinateHig));
if (cross == Vector3.zero)
{
Vector3 tnp = serieIndex > 0 ?
new Vector3(lastSerie.dataPoints[i].x + yAxis.axisLine.width, lastSerie.dataPoints[i].y) :
new Vector3(coordinateX + yAxis.axisLine.width, np.y);
Vector3 tlp = serieIndex > 0 ?
new Vector3(lastSerie.dataPoints[i - 1].x + yAxis.axisLine.width, lastSerie.dataPoints[i - 1].y) :
new Vector3(coordinateX + yAxis.axisLine.width, lp.y);
ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor);
}
else
{
Vector3 cross1 = new Vector3(cross.x + (alp.x > coordinateX ? yAxis.axisLine.width : -yAxis.axisLine.width), cross.y);
Vector3 cross2 = new Vector3(cross.x + (anp.x > coordinateX ? yAxis.axisLine.width : -yAxis.axisLine.width), cross.y);
Vector3 xp1 = new Vector3(coordinateX + (alp.x > coordinateX ? yAxis.axisLine.width : -yAxis.axisLine.width), alp.y);
Vector3 xp2 = new Vector3(coordinateX + (anp.x > coordinateX ? yAxis.axisLine.width : -yAxis.axisLine.width), anp.y);
ChartHelper.DrawTriangle(vh, alp, cross1, xp1, areaColor);
ChartHelper.DrawTriangle(vh, anp, cross2, xp2, areaColor);
}
}
}
}
serie.dataPoints.Add(np);
seriesHig[i] += dataHig;
lp = np;
}
}
private void DrawSmoothAreaPoints(VertexHelper vh, int serieIndex, Serie serie, Axis xAxis, Vector3 lp,
Vector3 np, int dataIndex, Color lineColor, Color areaColor, bool isStack)
{
bool isYAxis = xAxis is YAxis;
if (isYAxis)
{
ChartHelper.GetBezierListVertical(ref smoothSegmentPoints, lp, np, m_Line.smoothStyle);
}
else
{
ChartHelper.GetBezierList(ref smoothSegmentPoints, lp, np, m_Line.smoothStyle);
}
Vector3 start, to;
start = smoothSegmentPoints[0];
var smoothPoints = serie.GetSmoothList(dataIndex, smoothSegmentPoints.Count);
smoothPoints.Clear();
var lastSerie = m_Series.GetSerie(serie.index - 1);
var lastSmoothPoints = lastSerie != null?lastSerie.GetSmoothList(dataIndex, smoothSegmentPoints.Count) : new List <Vector3>();
smoothPoints.Add(start);
var lastCount = 1;
for (int k = 1; k < smoothSegmentPoints.Count; k++)
{
smoothPoints.Add(smoothSegmentPoints[k]);
to = smoothSegmentPoints[k];
ChartHelper.DrawLine(vh, start, to, m_Line.tickness, lineColor);
if (m_Line.area)
{
Vector3 alp, anp, tnp, tlp;
if (isYAxis)
{
alp = new Vector3(start.x - m_Line.tickness, start.y);
anp = new Vector3(to.x - m_Line.tickness, to.y);
}
else
{
alp = new Vector3(start.x, start.y - m_Line.tickness);
anp = new Vector3(to.x, to.y - m_Line.tickness);
}
if (serieIndex > 0 && isStack)
{
if (k == smoothSegmentPoints.Count - 1)
{
if (k < lastSmoothPoints.Count - 1)
{
tnp = lastSmoothPoints[lastCount - 1];
if (isYAxis)
{
tnp.x += m_Line.tickness;
}
else
{
tnp.y += m_Line.tickness;
}
ChartHelper.DrawTriangle(vh, alp, anp, tnp, areaColor);
while (lastCount < lastSmoothPoints.Count)
{
tlp = lastSmoothPoints[lastCount];
if (isYAxis)
{
tlp.x += m_Line.tickness;
}
else
{
tlp.y += m_Line.tickness;
}
ChartHelper.DrawTriangle(vh, tnp, anp, tlp, areaColor);
lastCount++;
tnp = tlp;
}
start = to;
continue;
}
}
if (lastCount >= lastSmoothPoints.Count)
{
tlp = lastSmoothPoints[lastSmoothPoints.Count - 1];
if (isYAxis)
{
tlp.x += m_Line.tickness;
}
else
{
tlp.y += m_Line.tickness;
}
ChartHelper.DrawTriangle(vh, anp, alp, tlp, areaColor);
start = to;
continue;
}
if (isYAxis)
{
tnp = new Vector3(lastSmoothPoints[lastCount].x + m_Line.tickness, lastSmoothPoints[lastCount].y);
}
else
{
tnp = new Vector3(lastSmoothPoints[lastCount].x, lastSmoothPoints[lastCount].y + m_Line.tickness);
}
var diff = isYAxis ? tnp.y - to.y : tnp.x - to.x;
if (Math.Abs(diff) < 1)
{
if (isYAxis)
{
tlp = new Vector3(lastSmoothPoints[lastCount - 1].x + m_Line.tickness, lastSmoothPoints[lastCount - 1].y);
}
else
{
tlp = new Vector3(lastSmoothPoints[lastCount - 1].x, lastSmoothPoints[lastCount - 1].y + m_Line.tickness);
}
ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor);
lastCount++;
}
else
{
if (diff < 0)
{
if (isYAxis)
{
tnp = new Vector3(lastSmoothPoints[lastCount - 1].x + m_Line.tickness, lastSmoothPoints[lastCount - 1].y);
}
else
{
tnp = new Vector3(lastSmoothPoints[lastCount - 1].x, lastSmoothPoints[lastCount - 1].y + m_Line.tickness);
}
ChartHelper.DrawTriangle(vh, alp, anp, tnp, areaColor);
while (diff < 0 && lastCount < lastSmoothPoints.Count)
{
if (isYAxis)
{
tlp = new Vector3(lastSmoothPoints[lastCount].x + m_Line.tickness, lastSmoothPoints[lastCount].y);
}
else
{
tlp = new Vector3(lastSmoothPoints[lastCount].x, lastSmoothPoints[lastCount].y + m_Line.tickness);
}
ChartHelper.DrawTriangle(vh, tnp, anp, tlp, areaColor);
lastCount++;
diff = isYAxis ? tlp.y - to.y : tlp.x - to.x;
tnp = tlp;
}
}
else
{
if (isYAxis)
{
tlp = new Vector3(lastSmoothPoints[lastCount - 1].x + m_Line.tickness, lastSmoothPoints[lastCount - 1].y);
}
else
{
tlp = new Vector3(lastSmoothPoints[lastCount - 1].x, lastSmoothPoints[lastCount - 1].y + m_Line.tickness);
}
ChartHelper.DrawTriangle(vh, alp, anp, tlp, areaColor);
}
}
}
else
{
if (isYAxis)
{
tnp = new Vector3(coordinateX + xAxis.axisLine.width, to.y);
tlp = new Vector3(coordinateX + xAxis.axisLine.width, start.y);
}
else
{
tnp = new Vector3(to.x, coordinateY + xAxis.axisLine.width);
tlp = new Vector3(start.x, coordinateY + xAxis.axisLine.width);
}
ChartHelper.DrawPolygon(vh, alp, anp, tnp, tlp, areaColor);
}
}
start = to;
}
}
private void DrawStackArea(VertexHelper vh, Serie serie, Axis axis, List <Vector3> smoothPoints,
List <Vector3> lastSmoothPoints, Color lineColor, Color areaColor, Color areaToColor)
{
if (!serie.areaStyle.show || lastSmoothPoints.Count <= 0)
{
return;
}
Vector3 start, to;
var isYAxis = axis is YAxis;
var lastCount = 1;
start = smoothPoints[0];
for (int k = 1; k < smoothPoints.Count; k++)
{
to = smoothPoints[k];
Vector3 tnp, tlp;
if (k == smoothPoints.Count - 1)
{
if (k < lastSmoothPoints.Count - 1)
{
tnp = lastSmoothPoints[lastCount - 1];
ChartHelper.DrawTriangle(vh, start, to, tnp, areaColor, areaColor, areaToColor);
while (lastCount < lastSmoothPoints.Count)
{
tlp = lastSmoothPoints[lastCount];
ChartHelper.DrawTriangle(vh, tnp, to, tlp, areaToColor, areaColor, areaToColor);
lastCount++;
tnp = tlp;
}
start = to;
continue;
}
}
if (lastCount >= lastSmoothPoints.Count)
{
tlp = lastSmoothPoints[lastSmoothPoints.Count - 1];
ChartHelper.DrawTriangle(vh, to, start, tlp, areaColor, areaColor, areaToColor);
start = to;
continue;
}
tnp = lastSmoothPoints[lastCount];
var diff = isYAxis ? tnp.y - to.y : tnp.x - to.x;
if (Math.Abs(diff) < 1)
{
tlp = lastSmoothPoints[lastCount - 1];
ChartHelper.DrawPolygon(vh, start, to, tnp, tlp, areaColor, areaToColor);
lastCount++;
}
else
{
if (diff < 0)
{
tnp = lastSmoothPoints[lastCount - 1];
ChartHelper.DrawTriangle(vh, start, to, tnp, areaColor, areaColor, areaToColor);
while (diff < 0 && lastCount < lastSmoothPoints.Count)
{
tlp = lastSmoothPoints[lastCount];
ChartHelper.DrawTriangle(vh, tnp, to, tlp, areaToColor, areaColor, areaToColor);
lastCount++;
diff = isYAxis ? tlp.y - to.y : tlp.x - to.x;
tnp = tlp;
}
}
else
{
tlp = lastSmoothPoints[lastCount - 1];
ChartHelper.DrawTriangle(vh, start, to, tlp, areaColor, areaColor, areaToColor);
}
}
start = to;
}
if (lastCount < lastSmoothPoints.Count)
{
var p1 = lastSmoothPoints[lastCount - 1];
var p2 = lastSmoothPoints[lastSmoothPoints.Count - 1];
ChartHelper.DrawTriangle(vh, p1, start, p2, areaToColor, areaColor, areaToColor);
}
}
private void DrawNormalLine(VertexHelper vh, int serieIndex, Serie serie, Axis axis, Vector3 lp,
Vector3 np, Vector3 nnp, int dataIndex, Color lineColor, Color areaColor, Color areaToColor, Vector3 zeroPos)
{
bool isYAxis = axis is YAxis;
var lastSerie = m_Series.GetLastStackSerie(serie);
Vector3 dnPos, upPos1, upPos2, dir1v, dir2v;
bool isDown;
var dir1 = (np - lp).normalized;
dir1v = Vector3.Cross(dir1, Vector3.forward).normalized *(isYAxis ? -1 : 1);
float cut = 0;
if (np != nnp)
{
var dir2 = (nnp - np).normalized;
var dir3 = (dir1 + dir2).normalized;
var normal = Vector3.Cross(dir1, dir2);
isDown = isYAxis ? normal.z >= 0 : normal.z <= 0;
var angle = (180 - Vector3.Angle(dir1, dir2)) * Mathf.Deg2Rad / 2;
var diff = serie.lineStyle.width / Mathf.Sin(angle);
cut = serie.lineStyle.width / Mathf.Tan(angle);
var dirDp = Vector3.Cross(dir3, Vector3.forward).normalized *(isYAxis ? -1 : 1);
dir2v = Vector3.Cross(dir2, Vector3.forward).normalized *(isYAxis ? -1 : 1);
dnPos = np + (isDown ? dirDp : -dirDp) * diff;
upPos1 = np + (isDown ? -dir1v : dir1v) * serie.lineStyle.width;
upPos2 = np + (isDown ? -dir2v : dir2v) * serie.lineStyle.width;
if (dataIndex == 1)
{
stPos1 = lp - dir1v * serie.lineStyle.width;
stPos2 = lp + dir1v * serie.lineStyle.width;
}
if (isDown)
{
ChartHelper.DrawPolygon(vh, stPos1, upPos1, dnPos, stPos2, lineColor);
ChartHelper.DrawTriangle(vh, upPos1, upPos2, dnPos, lineColor);
}
else
{
ChartHelper.DrawPolygon(vh, stPos1, dnPos, upPos1, stPos2, lineColor);
ChartHelper.DrawTriangle(vh, dnPos, upPos2, upPos1, lineColor);
}
lastDir = dir1;
}
else
{
isDown = Vector3.Cross(dir1, lastDir).z <= 0;
if (isYAxis)
{
isDown = !isDown;
}
dir1v = Vector3.Cross(dir1, Vector3.forward).normalized *(isYAxis ? -1 : 1);
upPos1 = np - dir1v * serie.lineStyle.width;
upPos2 = np + dir1v * serie.lineStyle.width;
dnPos = isDown ? upPos2 : upPos1;
ChartHelper.DrawPolygon(vh, stPos1, upPos1, upPos2, stPos2, lineColor);
}
var smoothPoints = serie.GetUpSmoothList(dataIndex);
var smoothDownPoints = serie.GetDownSmoothList(dataIndex);
var dist = Vector3.Distance(lp, np);
var fine = m_Series.IsAnyGradientSerie(serie.stack);
var tick = fine ? 3f : 30f;
int segment = (int)(dist / tick);
smoothPoints.Clear();
smoothDownPoints.Clear();
smoothPoints.Add(stPos1);
smoothDownPoints.Add(stPos2);
for (int i = 1; i < segment; i++)
{
var cp = lp + dir1 * dist * i / segment;
var tp1 = cp - dir1v * serie.lineStyle.width;
var tp2 = cp + dir1v * serie.lineStyle.width;
if (isDown)
{
if (isYAxis)
{
if (tp1.y > lastDnPos.y || dataIndex == 1)
{
smoothPoints.Add(tp1);
}
if (tp2.y < dnPos.y)
{
smoothDownPoints.Add(tp2);
}
}
else
{
if (tp1.x > lastDnPos.x || dataIndex == 1)
{
smoothPoints.Add(tp1);
}
if (tp2.x < dnPos.x || dataIndex == 1)
{
smoothDownPoints.Add(tp2);
}
}
}
else
{
if (isYAxis)
{
if (tp1.y < dnPos.y)
{
smoothPoints.Add(tp1);
}
if (tp2.y > lastDnPos.y || dataIndex == 1)
{
smoothDownPoints.Add(tp2);
}
}
else
{
if (tp1.x < dnPos.x)
{
smoothPoints.Add(tp1);
}
if (tp2.x > lastDnPos.x || dataIndex == 1)
{
smoothDownPoints.Add(tp2);
}
}
}
}
if (isDown)
{
smoothPoints.Add(upPos1);
smoothPoints.Add(upPos2);
smoothDownPoints.Add(dnPos);
}
else
{
smoothPoints.Add(dnPos);
if (isYAxis)
{
smoothDownPoints.Add(np != nnp ? upPos1 : upPos2);
smoothDownPoints.Add(np != nnp ? upPos2 : upPos1);
}
else
{
smoothDownPoints.Add(np != nnp ? upPos1 : upPos2);
smoothDownPoints.Add(np != nnp ? upPos2 : upPos1);
}
}
if (serie.areaStyle.show)
{
if (lastSerie != null)
{
var lastSmoothPoints = lastSerie.GetUpSmoothList(dataIndex);
DrawStackArea(vh, serie, axis, smoothDownPoints, lastSmoothPoints, lineColor, areaColor, areaToColor);
}
else
{
Vector3 alp = new Vector3(lp.x, lp.y - serie.lineStyle.width);
Vector3 anp = new Vector3(np.x, np.y - serie.lineStyle.width);
Vector3 aep = isYAxis ? new Vector3(zeroPos.x, zeroPos.y + coordinateHig) : new Vector3(zeroPos.x + coordinateWid, zeroPos.y);
var cross = ChartHelper.GetIntersection(lp, np, zeroPos, aep);
if (cross == Vector3.zero)
{
var points = ((isYAxis && lp.x < zeroPos.x) || (!isYAxis && lp.y < zeroPos.y)) ? smoothPoints : smoothDownPoints;
Vector3 sp = points[0];
Vector3 ep;
for (int i = 1; i < points.Count; i++)
{
ep = points[i];
DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor);
sp = ep;
}
}
else
{
var sp1 = smoothDownPoints[1];
var ep1 = smoothDownPoints[smoothDownPoints.Count - 2];
var axisUpStart = zeroPos + (isYAxis ? Vector3.right : Vector3.up) * axis.axisLine.width;
var axisUpEnd = axisUpStart + (isYAxis ? Vector3.up * coordinateHig : Vector3.right * coordinateWid);
var axisDownStart = zeroPos - (isYAxis ? Vector3.right : Vector3.up) * axis.axisLine.width;
var axisDownEnd = axisDownStart + (isYAxis ? Vector3.up * coordinateHig : Vector3.right * coordinateWid);
var luPos = ChartHelper.GetIntersection(sp1, ep1, axisUpStart, axisUpEnd);
var ldPos = ChartHelper.GetIntersection(sp1, ep1, axisDownStart, axisDownEnd);
sp1 = smoothPoints[1];
ep1 = smoothPoints[smoothPoints.Count - 2];
var ruPos = ChartHelper.GetIntersection(sp1, ep1, axisUpStart, axisUpEnd);
var rdPos = ChartHelper.GetIntersection(sp1, ep1, axisDownStart, axisDownEnd);
Vector3 sp, ep;
if ((isYAxis && lp.x > zeroPos.x) || (!isYAxis && lp.y > zeroPos.y))
{
sp = smoothDownPoints[0];
for (int i = 1; i < smoothDownPoints.Count; i++)
{
ep = smoothDownPoints[i];
if ((isYAxis && ep.y > luPos.y) || (!isYAxis && ep.x > luPos.x))
{
var tp = isYAxis ? new Vector3(luPos.x, sp.y) : new Vector3(sp.x, luPos.y);
ChartHelper.DrawTriangle(vh, sp, luPos, tp, areaColor, areaToColor, areaToColor);
break;
}
DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor);
sp = ep;
}
sp = smoothPoints[smoothPoints.Count - 1];
for (int i = smoothPoints.Count - 2; i >= 0; i--)
{
ep = smoothPoints[i];
if ((isYAxis && ep.y > rdPos.y) || (!isYAxis && ep.x > rdPos.x))
{
DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor);
}
else
{
var tp = isYAxis ? new Vector3(rdPos.x, sp.y) : new Vector3(sp.x, rdPos.y);
ChartHelper.DrawTriangle(vh, sp, rdPos, tp, areaColor, areaToColor, areaToColor);
break;
}
sp = ep;
}
}
else
{
sp = smoothPoints[0];
for (int i = 1; i < smoothPoints.Count; i++)
{
ep = smoothPoints[i];
if ((isYAxis && ep.y > rdPos.y) || (!isYAxis && ep.x > rdPos.x))
{
var tp = isYAxis ? new Vector3(rdPos.x, sp.y) : new Vector3(sp.x, rdPos.y);
ChartHelper.DrawTriangle(vh, sp, rdPos, tp, areaColor, areaToColor, areaToColor);
break;
}
DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor);
sp = ep;
}
sp = smoothDownPoints[smoothDownPoints.Count - 1];
for (int i = smoothDownPoints.Count - 2; i >= 0; i--)
{
ep = smoothDownPoints[i];
if ((isYAxis && ep.y > luPos.y) || (!isYAxis && ep.x > luPos.x))
{
DrawPolygonToZero(vh, sp, ep, axis, zeroPos, areaColor, areaToColor);
}
else
{
var tp = isYAxis ? new Vector3(luPos.x, sp.y) : new Vector3(sp.x, luPos.y);
ChartHelper.DrawTriangle(vh, sp, luPos, tp, areaColor, areaToColor, areaToColor);
break;
}
sp = ep;
}
}
}
}
}
stPos1 = isDown ? upPos2 : dnPos;
stPos2 = isDown ? dnPos : upPos2;
lastDnPos = dnPos;
}
