internal void DrawLabelBackground(VertexHelper vh, Serie serie, SerieData serieData)
{
if (serieData == null || serieData.labelObject == null)
{
return;
}
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
if (!serieLabel.show)
{
return;
}
var invert = serieLabel.autoOffset &&
serie.type == SerieType.Line &&
SerieHelper.IsDownPoint(serie, serieData.index) &&
!serie.areaStyle.show;
var centerPos = Vector3.zero;
if (serie.type == SerieType.Pie)
{
centerPos = SerieLabelHelper.GetRealLabelPosition(serieData, serieLabel);
}
else
{
centerPos = serieData.labelPosition + serieLabel.offset * (invert ? -1 : 1);
}
var labelHalfWid = serieData.labelObject.GetLabelWidth() / 2;
var labelHalfHig = serieData.GetLabelHeight() / 2;
var p1 = new Vector3(centerPos.x - labelHalfWid, centerPos.y + labelHalfHig);
var p2 = new Vector3(centerPos.x + labelHalfWid, centerPos.y + labelHalfHig);
var p3 = new Vector3(centerPos.x + labelHalfWid, centerPos.y - labelHalfHig);
var p4 = new Vector3(centerPos.x - labelHalfWid, centerPos.y - labelHalfHig);
if (serieLabel.textStyle.rotate > 0)
{
p1 = ChartHelper.RotateRound(p1, centerPos, Vector3.forward, serieLabel.textStyle.rotate);
p2 = ChartHelper.RotateRound(p2, centerPos, Vector3.forward, serieLabel.textStyle.rotate);
p3 = ChartHelper.RotateRound(p3, centerPos, Vector3.forward, serieLabel.textStyle.rotate);
p4 = ChartHelper.RotateRound(p4, centerPos, Vector3.forward, serieLabel.textStyle.rotate);
}
UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, serieLabel.textStyle.backgroundColor);
if (serieLabel.border)
{
UGL.DrawBorder(vh, centerPos, serieData.GetLabelWidth(), serieData.GetLabelHeight(),
serieLabel.borderWidth, serieLabel.borderColor, serieLabel.textStyle.rotate);
}
}
/// <summary>
/// Add a data to serie.
/// 添加一个数据到指定的系列中。
/// </summary>
/// <param name="serieIndex">the index of serie</param>
/// <param name="data">the data to add</param>
/// <param name="dataName">the name of data</param>
/// <returns>Returns True on success</returns>
public virtual SerieData AddData(int serieIndex, float data, string dataName = null)
{
var serieData = m_Series.AddData(serieIndex, data, dataName);
if (serieData != null)
{
var serie = m_Series.GetSerie(serieIndex);
if (SerieHelper.GetSerieLabel(serie, serieData).show)
{
RefreshLabel();
}
RefreshChart();
}
return(serieData);
}
/// <summary>
/// Add a (x,y) data to serie.
/// 添加（x,y）数据到指定系列中。
/// </summary>
/// <param name="serieIndex">the index of serie</param>
/// <param name="xValue">x data</param>
/// <param name="yValue">y data</param>
/// <param name="dataName">the name of data</param>
/// <returns>Returns True on success</returns>
public virtual SerieData AddData(int serieIndex, float xValue, float yValue, string dataName = null)
{
var serieData = m_Series.AddXYData(serieIndex, xValue, yValue, dataName);
if (serieData != null)
{
var serie = m_Series.GetSerie(serieIndex);
if (SerieHelper.GetSerieLabel(serie, serieData).show)
{
RefreshLabel();
}
RefreshPainter(serie);
}
return(serieData);
}
public virtual SerieData AddData(int serieIndex, float open, float close, float lowest, float heighest, string dataName = null)
{
var serieData = m_Series.AddData(serieIndex, open, close, lowest, heighest, dataName);
if (serieData != null)
{
var serie = m_Series.GetSerie(serieIndex);
if (SerieHelper.GetSerieLabel(serie, serieData).show)
{
RefreshLabel();
}
RefreshPainter(serie);
}
return(serieData);
}
/// <summary>
/// Add an arbitray dimension data to serie,such as (x,y,z,...).
/// 添加多维数据（x,y,z...）到指定的系列中。
/// </summary>
/// <param name="serieIndex">the index of serie,index starts at 0</param>
/// <param name="multidimensionalData">the (x,y,z,...) data</param>
/// <param name="dataName">the name of data</param>
/// <returns>Returns True on success</returns>
public virtual SerieData AddData(int serieIndex, List <float> multidimensionalData, string dataName = null)
{
var serieData = m_Series.AddData(serieIndex, multidimensionalData, dataName);
if (serieData != null)
{
var serie = m_Series.GetSerie(serieIndex);
if (SerieHelper.GetSerieLabel(serie, serieData).show)
{
RefreshLabel();
}
RefreshPainter(serie);
}
return(serieData);
}
/// <summary>
/// Add a data to serie.
/// If serieName doesn't exist in legend,will be add to legend.
/// 添加一个数据到指定的系列中。
/// </summary>
/// <param name="serieName">the name of serie</param>
/// <param name="data">the data to add</param>
/// <param name="dataName">the name of data</param>
/// <returns>Returns True on success</returns>
public virtual SerieData AddData(string serieName, float data, string dataName = null)
{
var serieData = m_Series.AddData(serieName, data, dataName);
if (serieData != null)
{
var serie = m_Series.GetSerie(serieName);
if (SerieHelper.GetSerieLabel(serie, serieData).show)
{
RefreshLabel();
}
RefreshPainter(serie);
}
return(serieData);
}
private void DrawPieLabelBackground(VertexHelper vh, Serie serie)
{
if (serie.avoidLabelOverlap)
{
return;
}
foreach (var serieData in serie.data)
{
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
if (SerieLabelHelper.CanShowLabel(serie, serieData, serieLabel, 1))
{
SerieLabelHelper.UpdatePieLabelPosition(serie, serieData);
chart.DrawLabelBackground(vh, serie, serieData);
}
}
}
protected override void OnRefreshLabel()
{
for (int i = 0; i < m_Series.Count; i++)
{
var serie = m_Series.GetSerie(i);
if (!serie.show && serie.radarType != RadarType.Single)
{
continue;
}
var radar = m_Radars[serie.radarIndex];
var center = radar.runtimeCenterPos;
for (int n = 0; n < serie.dataCount; n++)
{
var serieData = serie.data[n];
if (serieData.labelObject == null)
{
continue;
}
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
var labelPos = serieData.labelPosition;
if (serieLabel.margin != 0)
{
labelPos += serieLabel.margin * (labelPos - center).normalized;
}
serieData.labelObject.SetPosition(labelPos);
serieData.labelObject.UpdateIcon(serieData.iconStyle);
if (serie.show && serieLabel.show && serieData.canShowLabel)
{
var value = serieData.GetCurrData(1);
var max = radar.GetIndicatorMax(n);
SerieLabelHelper.ResetLabel(serieData, serieLabel, themeInfo, i);
serieData.SetLabelActive(serieData.labelPosition != Vector3.zero);
serieData.labelObject.SetLabelPosition(serieLabel.offset);
var content = SerieLabelHelper.GetFormatterContent(serie, serieData, value, max, serieLabel);
if (serieData.labelObject.SetText(content))
{
RefreshChart();
}
}
else
{
serieData.SetLabelActive(false);
}
}
}
}
protected void AddSerieLabel(Serie serie, SerieData serieData, int count = -1)
{
if (m_SerieLabelRoot == null)
{
return;
}
if (count == -1)
{
count = serie.dataCount;
}
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
var iconStyle = SerieHelper.GetIconStyle(serie, serieData);
if (serie.IsPerformanceMode())
{
return;
}
if (!serieLabel.show && !iconStyle.show)
{
return;
}
var textName = ChartCached.GetSerieLabelName(s_SerieLabelObjectName, serie.index, serieData.index);
var color = Color.grey;
if (serie.type == SerieType.Pie)
{
color = (serieLabel.position == SerieLabel.Position.Inside) ? Color.white :
(Color)m_Theme.GetColor(count);
}
else
{
color = !ChartHelper.IsClearColor(serieLabel.textStyle.color) ? serieLabel.textStyle.color :
(Color)m_Theme.GetColor(serie.index);
}
var labelObj = SerieLabelPool.Get(textName, m_SerieLabelRoot.transform, serieLabel, color,
iconStyle.width, iconStyle.height, theme);
var iconImage = labelObj.transform.Find("Icon").GetComponent <Image>();
var isAutoSize = serieLabel.backgroundWidth == 0 || serieLabel.backgroundHeight == 0;
var item = new ChartLabel();
item.SetLabel(labelObj, isAutoSize, serieLabel.paddingLeftRight, serieLabel.paddingTopBottom);
item.SetIcon(iconImage);
item.SetIconActive(iconStyle.show);
serieData.labelObject = item;
}
private void InitSerieLabel()
{
var labelObject = ChartHelper.AddObject(s_SerieLabelObjectName, transform, m_ChartMinAnchor,
m_ChartMaxAnchor, m_ChartPivot, m_ChartSizeDelta);
SerieLabelPool.ReleaseAll(labelObject.transform);
int count = 0;
for (int i = 0; i < m_Series.Count; i++)
{
var serie = m_Series.list[i];
SerieHelper.UpdateCenter(serie, chartPosition, chartWidth, chartHeight);
for (int j = 0; j < serie.data.Count; j++)
{
var serieData = serie.data[j];
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
if (!serieLabel.show && j > 100)
{
continue;
}
var textName = ChartCached.GetSerieLabelName(s_SerieLabelObjectName, i, j);
var color = Color.grey;
if (serie.type == SerieType.Pie)
{
color = (serieLabel.position == SerieLabel.Position.Inside) ? Color.white :
(Color)m_ThemeInfo.GetColor(count);
}
else
{
color = serieLabel.color != Color.clear ? serieLabel.color :
(Color)m_ThemeInfo.GetColor(i);
}
var labelObj = SerieLabelPool.Get(textName, labelObject.transform, serieLabel, m_ThemeInfo.font, color,
serieData.iconStyle.width, serieData.iconStyle.height);
var iconImage = labelObj.transform.Find("Icon").GetComponent <Image>();
serieData.SetIconImage(iconImage);
var isAutoSize = serieLabel.backgroundWidth == 0 || serieLabel.backgroundHeight == 0;
serieData.InitLabel(labelObj, isAutoSize, serieLabel.paddingLeftRight, serieLabel.paddingTopBottom);
serieData.SetLabelActive(false);
count++;
}
}
SerieLabelHelper.UpdateLabelText(m_Series, m_ThemeInfo);
}
private void DrawLabelBackground(VertexHelper vh)
{
foreach (var serie in m_Series.list)
{
if (serie.type == SerieType.Pie)
{
foreach (var serieData in serie.data)
{
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
if (serieLabel.show && serieData.canShowLabel)
{
UpdateLabelPostion(serie, serieData);
DrawLabelBackground(vh, serie, serieData);
}
}
}
}
}
private static void CheckSerieDataLabel(Serie serie, SerieData serieData, bool isLeft, ComponentTheme theme,
ref Vector3 lastCheckPos)
{
if (!serieData.canShowLabel)
{
serieData.SetLabelActive(false);
return;
}
if (!serieData.show)
{
return;
}
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
var fontSize = serieLabel.textStyle.GetFontSize(theme);
if (!serieLabel.show)
{
return;
}
if (serieLabel.position != SerieLabel.Position.Outside)
{
return;
}
if (lastCheckPos == Vector3.zero)
{
lastCheckPos = serieData.labelPosition;
}
else if (serieData.labelPosition.x != 0)
{
if (lastCheckPos.y - serieData.labelPosition.y < fontSize)
{
var labelRadius = serie.runtimeOutsideRadius + serieLabel.lineLength1;
var y1 = lastCheckPos.y - fontSize;
var cy = serie.runtimeCenterPos.y;
var diff = Mathf.Abs(y1 - cy);
var diffX = labelRadius * labelRadius - diff * diff;
diffX = diffX <= 0 ? 0 : diffX;
var x1 = serie.runtimeCenterPos.x + Mathf.Sqrt(diffX) * (isLeft ? -1 : 1);
serieData.labelPosition = new Vector3(x1, y1);
}
lastCheckPos = serieData.labelPosition;
serieData.labelObject.SetPosition(SerieLabelHelper.GetRealLabelPosition(serieData, serieLabel));
}
}
private void DrawLabelBackground(VertexHelper vh)
{
foreach (var serie in m_Series.list)
{
if (serie.type != SerieType.Pie)
{
continue;
}
foreach (var serieData in serie.data)
{
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
if (SerieLabelHelper.CanShowLabel(serie, serieData, serieLabel, 1))
{
SerieLabelHelper.UpdatePieLabelPosition(serie, serieData);
DrawLabelBackground(vh, serie, serieData);
}
}
}
}
private void DrawLabelLine(VertexHelper vh)
{
foreach (var serie in m_Series.list)
{
if (serie.type == SerieType.Pie)
{
foreach (var serieData in serie.data)
{
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
if (serieLabel.show && serieData.canShowLabel)
{
int colorIndex = m_LegendRealShowName.IndexOf(serieData.name);
Color color = m_ThemeInfo.GetColor(colorIndex);
DrawLabelLine(vh, serie, serieData, color);
}
}
}
}
}
private void DrawLabelBackground(VertexHelper vh)
{
foreach (var serie in m_Series.list)
{
if (serie.type == SerieType.Pie)
{
foreach (var serieData in serie.data)
{
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
if (SerieLabelHelper.CanShowLabel(serie, serieData, serieLabel, 1))
{
int colorIndex = m_LegendRealShowName.IndexOf(serieData.name);
if (ShowCount == -1 || colorIndex < ShowCount)
{
UpdateLabelPostion(serie, serieData);
DrawLabelBackground(vh, serie, serieData);
}
}
}
}
}
}
public static void SetRingLabelText(Serie serie, ChartTheme theme)
{
for (int i = 0; i < serie.dataCount; i++)
{
var serieData = serie.data[i];
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData, serieData.highlighted);
if (serieLabel.show && serieData.labelObject != null)
{
if (!serie.show || !serieData.show)
{
serieData.SetLabelActive(false);
continue;
}
var value = serieData.GetData(0);
var total = serieData.GetData(1);
var content = SerieLabelHelper.GetFormatterContent(serie, serieData, value, total);
serieData.SetLabelActive(true);
serieData.labelObject.SetText(content);
serieData.labelObject.SetLabelColor(GetLabelColor(serie, theme, i));
if (serie.label.position == SerieLabel.Position.Bottom)
{
var labelWidth = serieData.GetLabelWidth();
if (serie.clockwise)
{
serieData.labelObject.SetLabelPosition(serieData.labelPosition - new Vector3(labelWidth / 2, 0));
}
else
{
serieData.labelObject.SetLabelPosition(serieData.labelPosition + new Vector3(labelWidth / 2, 0));
}
}
else
{
serieData.labelObject.SetLabelPosition(serieData.labelPosition);
}
}
}
}
public static string GetFormatterContent(Serie serie, SerieData serieData,
float dataValue, float dataTotal, SerieLabel serieLabel = null)
{
if (serieLabel == null)
{
serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
}
var numericFormatter = serieLabel == null ? serie.label.numericFormatter : serieLabel.numericFormatter;
var serieName = serie.name;
var dataName = serieData != null ? serieData.name : null;
if (string.IsNullOrEmpty(serieLabel.formatter))
{
return(ChartCached.NumberToStr(dataValue, numericFormatter));
}
else
{
var content = serieLabel.formatter;
FormatterHelper.ReplaceSerieLabelContent(ref content, numericFormatter, dataValue,
dataTotal, serieName, dataName);
return(content);
}
}
public static string GetFormatterContent(Serie serie, SerieData serieData,
float dataValue, float dataTotal, SerieLabel serieLabel = null)
{
if (serieLabel == null)
{
serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
}
var numericFormatter = GetLabelNumericFormatter(serie, serieData);
var serieName = serie.name;
var dataName = serieData != null ? serieData.name : null;
if (string.IsNullOrEmpty(serieLabel.formatter))
{
return(ChartCached.NumberToStr(dataValue, numericFormatter));
}
else
{
var content = serieLabel.formatter.Replace("{a}", serieName);
content = content.Replace("{b}", dataName);
content = content.Replace("{c}", ChartCached.NumberToStr(dataValue, numericFormatter));
content = content.Replace("{c:f0}", ChartCached.IntToStr((int)Mathf.Round(dataValue)));
content = content.Replace("{c:f1}", ChartCached.FloatToStr(dataValue, string.Empty, 1));
content = content.Replace("{c:f2}", ChartCached.FloatToStr(dataValue, string.Empty, 2));
if (dataTotal > 0)
{
var percent = dataValue / dataTotal * 100;
content = content.Replace("{d}", ChartCached.NumberToStr(percent, numericFormatter));
content = content.Replace("{d:f0}", ChartCached.IntToStr((int)Mathf.Round(percent)));
content = content.Replace("{d:f1}", ChartCached.FloatToStr(percent, string.Empty, 1));
content = content.Replace("{d:f2}", ChartCached.FloatToStr(percent, string.Empty, 2));
}
content = content.Replace("\\n", "\n");
content = content.Replace("<br/>", "\n");
return(content);
}
}
protected void UpdateLabelPostion(Serie serie, SerieData serieData)
{
if (serieData.labelObject == null)
{
return;
}
var currAngle = serieData.runtimePieHalfAngle;
var currRad = currAngle * Mathf.Deg2Rad;
var offsetRadius = serieData.runtimePieOffsetRadius;
var insideRadius = serieData.runtimePieInsideRadius;
var outsideRadius = serieData.runtimePieOutsideRadius;
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
switch (serieLabel.position)
{
case SerieLabel.Position.Center:
serieData.labelPosition = serie.runtimeCenterPos;
break;
case SerieLabel.Position.Inside:
var labelRadius = offsetRadius + insideRadius + (outsideRadius - insideRadius) / 2;
var labelCenter = new Vector2(serie.runtimeCenterPos.x + labelRadius * Mathf.Sin(currRad),
serie.runtimeCenterPos.y + labelRadius * Mathf.Cos(currRad));
serieData.labelPosition = labelCenter;
break;
case SerieLabel.Position.Outside:
if (serieLabel.lineType == SerieLabel.LineType.HorizontalLine)
{
var radius1 = serie.runtimeOutsideRadius;
var radius3 = insideRadius + (outsideRadius - insideRadius) / 2;
var currSin = Mathf.Sin(currRad);
var currCos = Mathf.Cos(currRad);
var pos0 = new Vector3(serie.runtimeCenterPos.x + radius3 * currSin, serie.runtimeCenterPos.y + radius3 * currCos);
if (currAngle > 180)
{
currSin = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad);
currCos = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad);
}
var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3;
r4 += serieLabel.lineLength1 + serieLabel.lineWidth * 4;
r4 += serieData.labelObject.label.preferredWidth / 2;
serieData.labelPosition = pos0 + (currAngle > 180 ? Vector3.left : Vector3.right) * r4;
}
else
{
labelRadius = serie.runtimeOutsideRadius + serieLabel.lineLength1;
labelCenter = new Vector2(serie.runtimeCenterPos.x + labelRadius * Mathf.Sin(currRad),
serie.runtimeCenterPos.y + labelRadius * Mathf.Cos(currRad));
float labelWidth = serieData.labelObject.label.preferredWidth;
if (currAngle > 180)
{
serieData.labelPosition = new Vector2(labelCenter.x - serieLabel.lineLength2 - 5 - labelWidth / 2, labelCenter.y);
}
else
{
serieData.labelPosition = new Vector2(labelCenter.x + serieLabel.lineLength2 + 5 + labelWidth / 2, labelCenter.y);
}
}
break;
}
}
private void DrawLabel(Serie serie, int dataIndex, SerieData serieData, Color serieColor)
{
if (serieData.labelObject == null)
{
return;
}
var currAngle = serieData.runtimePieHalfAngle;
var isHighlight = (serieData.highlighted && serie.emphasis.label.show);
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
var showLabel = ((serieLabel.show || isHighlight) && serieData.canShowLabel);
if (showLabel || serieData.iconStyle.show)
{
serieData.SetLabelActive(showLabel);
float rotate = 0;
bool isInsidePosition = serieLabel.position == SerieLabel.Position.Inside;
if (serieLabel.rotate > 0 && isInsidePosition)
{
if (currAngle > 180)
{
rotate += 270 - currAngle;
}
else
{
rotate += -(currAngle - 90);
}
}
Color color = serieColor;
if (isHighlight)
{
if (!ChartHelper.IsClearColor(serie.emphasis.label.color))
{
color = serie.emphasis.label.color;
}
}
else if (!ChartHelper.IsClearColor(serieLabel.color))
{
color = serieLabel.color;
}
else
{
color = isInsidePosition ? Color.white : serieColor;
}
var fontSize = isHighlight ? serie.emphasis.label.fontSize : serieLabel.fontSize;
var fontStyle = isHighlight ? serie.emphasis.label.fontStyle : serieLabel.fontStyle;
serieData.labelObject.label.color = color;
serieData.labelObject.label.fontSize = fontSize;
serieData.labelObject.label.fontStyle = fontStyle;
serieData.labelObject.SetLabelRotate(rotate);
UpdateLabelPostion(serie, serieData);
if (!string.IsNullOrEmpty(serieLabel.formatter))
{
var value = serieData.data[1];
var total = serie.yTotal;
var content = SerieLabelHelper.GetFormatterContent(serie, serieData, value, total, serieLabel);
if (serieData.labelObject.SetText(content))
{
RefreshChart();
}
}
else
{
if (serieData.labelObject.SetText(serieData.name))
{
RefreshChart();
}
}
serieData.labelObject.SetPosition(serieData.labelPosition);
if (showLabel)
{
serieData.labelObject.SetLabelPosition(serieLabel.offset);
}
else
{
serieData.SetLabelActive(false);
}
}
else
{
serieData.SetLabelActive(false);
}
serieData.labelObject.UpdateIcon(serieData.iconStyle);
}
private void DrawLabelLine(VertexHelper vh, Serie serie, SerieData serieData, Color color)
{
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
if (serieLabel.show &&
serieLabel.position == SerieLabel.Position.Outside &&
serieLabel.line)
{
var insideRadius = serieData.runtimePieInsideRadius;
var outSideRadius = serieData.runtimePieOutsideRadius;
var center = serie.runtimeCenterPos;
var currAngle = serieData.runtimePieHalfAngle;
if (!ChartHelper.IsClearColor(serieLabel.lineColor))
{
color = serieLabel.lineColor;
}
else if (serieLabel.lineType == SerieLabel.LineType.HorizontalLine)
{
color *= color;
}
float currSin = Mathf.Sin(currAngle * Mathf.Deg2Rad);
float currCos = Mathf.Cos(currAngle * Mathf.Deg2Rad);
var radius1 = serieLabel.lineType == SerieLabel.LineType.HorizontalLine ?
serie.runtimeOutsideRadius : outSideRadius;
var radius2 = serie.runtimeOutsideRadius + serieLabel.lineLength1;
var radius3 = insideRadius + (outSideRadius - insideRadius) / 2;
if (radius1 < serie.runtimeInsideRadius)
{
radius1 = serie.runtimeInsideRadius;
}
radius1 -= 0.1f;
var pos0 = new Vector3(center.x + radius3 * currSin, center.y + radius3 * currCos);
var pos1 = new Vector3(center.x + radius1 * currSin, center.y + radius1 * currCos);
var pos2 = new Vector3(center.x + radius2 * currSin, center.y + radius2 * currCos);
float tx, ty;
Vector3 pos3, pos4, pos6;
var horizontalLineCircleRadius = serieLabel.lineWidth * 4f;
var lineCircleDiff = horizontalLineCircleRadius - 0.3f;
if (currAngle < 90)
{
ty = serieLabel.lineWidth * Mathf.Cos((90 - currAngle) * Mathf.Deg2Rad);
tx = serieLabel.lineWidth * Mathf.Sin((90 - currAngle) * Mathf.Deg2Rad);
pos3 = new Vector3(pos2.x - tx, pos2.y + ty - serieLabel.lineWidth);
var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3;
r4 += serieLabel.lineLength1 - lineCircleDiff;
pos6 = pos0 + Vector3.right * lineCircleDiff;
pos4 = pos6 + Vector3.right * r4;
}
else if (currAngle < 180)
{
ty = serieLabel.lineWidth * Mathf.Sin((180 - currAngle) * Mathf.Deg2Rad);
tx = serieLabel.lineWidth * Mathf.Cos((180 - currAngle) * Mathf.Deg2Rad);
pos3 = new Vector3(pos2.x - tx, pos2.y - ty + serieLabel.lineWidth);
var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3;
r4 += serieLabel.lineLength1 - lineCircleDiff;
pos6 = pos0 + Vector3.right * lineCircleDiff;
pos4 = pos6 + Vector3.right * r4;
}
else if (currAngle < 270)
{
ty = serieLabel.lineWidth * Mathf.Sin((180 + currAngle) * Mathf.Deg2Rad);
tx = serieLabel.lineWidth * Mathf.Cos((180 + currAngle) * Mathf.Deg2Rad);
var currSin1 = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad);
var currCos1 = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad);
pos3 = new Vector3(pos2.x + tx, pos2.y - ty + serieLabel.lineWidth);
var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos1 * radius3, 2)) - currSin1 * radius3;
r4 += serieLabel.lineLength1 - lineCircleDiff;
pos6 = pos0 + Vector3.left * lineCircleDiff;
pos4 = pos6 + Vector3.left * r4;
}
else
{
ty = serieLabel.lineWidth * Mathf.Cos((90 + currAngle) * Mathf.Deg2Rad);
tx = serieLabel.lineWidth * Mathf.Sin((90 + currAngle) * Mathf.Deg2Rad);
pos3 = new Vector3(pos2.x + tx, pos2.y + ty - serieLabel.lineWidth);
var currSin1 = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad);
var currCos1 = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad);
var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos1 * radius3, 2)) - currSin1 * radius3;
r4 += serieLabel.lineLength1 - lineCircleDiff;
pos6 = pos0 + Vector3.left * lineCircleDiff;
pos4 = pos6 + Vector3.left * r4;
}
var pos5 = new Vector3(currAngle > 180 ? pos3.x - serieLabel.lineLength2 : pos3.x + serieLabel.lineLength2, pos3.y);
switch (serieLabel.lineType)
{
case SerieLabel.LineType.BrokenLine:
ChartDrawer.DrawLine(vh, pos1, pos2, serieLabel.lineWidth, color);
ChartDrawer.DrawLine(vh, pos3, pos5, serieLabel.lineWidth, color);
break;
case SerieLabel.LineType.Curves:
ChartDrawer.DrawCurves(vh, pos1, pos5, pos1, pos2, serieLabel.lineWidth, color, m_Settings.lineSmoothness);
break;
case SerieLabel.LineType.HorizontalLine:
ChartDrawer.DrawCricle(vh, pos0, horizontalLineCircleRadius, color);
ChartDrawer.DrawLine(vh, pos6, pos4, serieLabel.lineWidth, color);
break;
}
}
}
