zzy/bansonic_beta_main
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

UI update 02

Browse Source
This commit is contained in:
akangz
2026-06-30 21:21:30 +08:00
parent b2a1e307a4
commit f62f643cfc
1666 changed files with 211081 additions and 22799 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Assets/XCharts/Runtime/Serie/Pie/PieHandler.cs
+748
View File
@@ -0,0 +1,748 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using XUGL;
namespace XCharts.Runtime
{
[UnityEngine.Scripting.Preserve]
internal sealed class PieHandler : SerieHandler<Pie>
{
public override void Update()
{
base.Update();
}
public override void DrawBase(VertexHelper vh)
{
UpdateRuntimeData(serie);
DrawPieLabelLine(vh, serie, false);
}
public override void DrawSerie(VertexHelper vh)
{
UpdateRuntimeData(serie);
DrawPie(vh, serie);
chart.RefreshBasePainter();
}
public override void DrawUpper(VertexHelper vh)
{
DrawPieLabelLine(vh, serie, true);
}
public override void UpdateTooltipSerieParams(int dataIndex, bool showCategory, string category,
string marker, string itemFormatter, string numericFormatter, string ignoreDataDefaultContent,
ref List<SerieParams> paramList, ref string title)
{
UpdateItemSerieParams(ref paramList, ref title, dataIndex, category,
marker, itemFormatter, numericFormatter, ignoreDataDefaultContent);
}
public override Vector3 GetSerieDataLabelPosition(SerieData serieData, LabelStyle label)
{
var labelLine = SerieHelper.GetSerieLabelLine(serie, serieData);
if (labelLine != null && labelLine.show && serieData.labelObject != null)
{
var currAngle = serieData.context.halfAngle - serie.context.startAngle;
var isLeft = currAngle > 180 || (currAngle == 0 && serieData.context.startAngle > 0);
var textOffset = serieData.labelObject.text.GetPreferredWidth() / 2;
return serieData.context.labelPosition + (isLeft ? Vector3.left : Vector3.right) * textOffset;
}
else
{
return serieData.context.labelPosition;
}
}
public override Vector3 GetSerieDataLabelOffset(SerieData serieData, LabelStyle label)
{
var offset = label.GetOffset(serie.context.insideRadius);
if (label.autoOffset)
{
var currAngle = serieData.context.halfAngle - serie.context.startAngle;
var isLeft = currAngle > 180 || (currAngle == 0 && serieData.context.startAngle > 0);
if (isLeft)
return new Vector3(-offset.x, offset.y, offset.z);
else
return offset;
}
else
{
return offset;
}
}
public override Vector3 GetSerieDataTitlePosition(SerieData serieData, TitleStyle titleStyle)
{
return serie.context.center;
}
public override void OnPointerDown(PointerEventData eventData)
{
if (chart.pointerPos == Vector2.zero) return;
var dataIndex = GetPiePosIndex(serie, chart.pointerPos);
var refresh = false;
if (dataIndex >= 0)
{
refresh = true;
for (int j = 0; j < serie.data.Count; j++)
{
if (j == dataIndex) serie.data[j].context.selected = !serie.data[j].context.selected;
else serie.data[j].context.selected = false;
}
}
if (refresh) chart.RefreshChart();
base.OnPointerDown(eventData);
}
public override int GetPointerItemDataIndex()
{
return GetPiePosIndex(serie, chart.pointerPos);
}
public override void UpdateSerieContext()
{
var needCheck = m_LegendEnter || m_LegendExiting || m_ForceUpdateSerieContext || (chart.isPointerInChart && PointerIsInPieSerie(serie, chart.pointerPos));
var needInteract = false;
var interactEnable = serie.animation.enable && serie.animation.interaction.enable;
Color32 color, toColor;
if (!needCheck)
{
if (m_LastCheckContextFlag != needCheck || m_ForceUpdateSerieContext)
{
serie.context.pointerItemDataIndex = -1;
serie.context.pointerEnter = false;
bool isAllZeroValue1 = SerieHelper.IsAllZeroValue(serie, 1);
var zeroReplaceValue1 = isAllZeroValue1 ? 360 / serie.dataCount : 0;
foreach (var serieData in serie.data)
{
serieData.context.highlight = false;
if (interactEnable)
{
var value = isAllZeroValue1 ? zeroReplaceValue1 : serieData.GetCurrData(1, serie.animation);
var colorIndex = chart.GetLegendRealShowNameIndex(serieData.legendName);
SerieHelper.GetItemColor(out color, out toColor, serie, serieData, chart.theme, colorIndex, SerieState.Normal);
UpdateSerieDataRadius(serieData, value);
serieData.interact.SetValueAndColor(ref needInteract, serieData.context.outsideRadius, color, toColor);
serieData.interact.SetPosition(ref needInteract, serieData.context.offsetCenter);
}
}
if (needInteract)
{
chart.RefreshPainter(serie);
}
else
{
m_LastCheckContextFlag = needCheck;
m_LegendExiting = false;
chart.RefreshPainter(serie);
}
}
return;
}
m_LastCheckContextFlag = needCheck;
var lastPointerItemDataIndex = serie.context.pointerItemDataIndex;
var dataIndex = GetPiePosIndex(serie, chart.pointerPos);
serie.context.pointerItemDataIndex = -1;
serie.context.pointerEnter = dataIndex >= 0;
bool isAllZeroValue = SerieHelper.IsAllZeroValue(serie, 1);
var zeroReplaceValue = isAllZeroValue ? 360 / serie.dataCount : 0;
for (int i = 0; i < serie.dataCount; i++)
{
var serieData = serie.data[i];
var value = isAllZeroValue ? zeroReplaceValue : serieData.GetCurrData(1, serie.animation);
var state = SerieState.Normal;
if (dataIndex == i || (m_LegendEnter && m_LegendEnterIndex == i))
{
serie.context.pointerItemDataIndex = i;
serieData.context.highlight = true;
state = SerieState.Emphasis;
}
else
{
serieData.context.highlight = false;
}
if (interactEnable)
{
UpdateSerieDataRadius(serieData, value);
var colorIndex = chart.GetLegendRealShowNameIndex(serieData.legendName);
SerieHelper.GetItemColor(out color, out toColor, serie, serieData, chart.theme, colorIndex, state);
serieData.interact.SetValueAndColor(ref needInteract, serieData.context.outsideRadius, color, toColor);
serieData.interact.SetPosition(ref needInteract, serieData.context.offsetCenter);
}
}
if (lastPointerItemDataIndex != serie.context.pointerItemDataIndex)
{
needInteract = true;
}
if (needInteract)
{
chart.RefreshPainter(serie);
}
}
private void UpdateRuntimeData(Serie serie)
{
var data = serie.data;
serie.context.dataMax = serie.yMax;
serie.context.startAngle = GetStartAngle(serie);
var runtimePieDataTotal = serie.yTotal;
SerieHelper.UpdateCenter(serie, chart);
float startDegree = serie.context.startAngle;
float totalDegree = 0;
float zeroReplaceValue = 0;
int showdataCount = 0;
foreach (var sd in serie.data)
{
if (sd.show && serie.pieRoseType == RoseType.Area) showdataCount++;
sd.context.canShowLabel = false;
}
bool isAllZeroValue = SerieHelper.IsAllZeroValue(serie, 1);
var dataTotalFilterMinAngle = runtimePieDataTotal;
if (isAllZeroValue)
{
totalDegree = 360;
zeroReplaceValue = totalDegree / data.Count;
serie.context.dataMax = zeroReplaceValue;
runtimePieDataTotal = 360;
dataTotalFilterMinAngle = 360;
}
else
{
dataTotalFilterMinAngle = GetTotalAngle(serie, runtimePieDataTotal, ref totalDegree);
}
if (dataTotalFilterMinAngle == 0)
{
dataTotalFilterMinAngle = 360;
}
for (int n = 0; n < data.Count; n++)
{
var serieData = data[n];
var value = isAllZeroValue ? zeroReplaceValue : serieData.GetCurrData(1, serie.animation);
serieData.context.startAngle = startDegree;
serieData.context.toAngle = startDegree;
serieData.context.halfAngle = startDegree;
serieData.context.currentAngle = startDegree;
if (!serieData.show)
{
continue;
}
float degree = serie.pieRoseType == RoseType.Area ?
(totalDegree / showdataCount) :
(float)(totalDegree * value / dataTotalFilterMinAngle);
if (serie.minAngle > 0 && degree < serie.minAngle) degree = serie.minAngle;
serieData.context.toAngle = startDegree + degree;
var halfDegree = (serieData.context.toAngle - startDegree) / 2;
serieData.context.halfAngle = startDegree + halfDegree;
serieData.context.angle = startDegree + halfDegree;
serieData.context.currentAngle = serie.animation.CheckDetailBreak(serieData.context.toAngle)
? serie.animation.GetCurrDetail() : serieData.context.toAngle;
serieData.context.insideRadius = serie.context.insideRadius;
serieData.context.canShowLabel = serieData.context.currentAngle >= serieData.context.halfAngle && !serie.IsMinShowLabelValue(value);
UpdateSerieDataRadius(serieData, value);
UpdatePieLabelPosition(serie, serieData);
startDegree = serieData.context.toAngle;
}
AvoidLabelOverlap(serie, chart.theme.common);
}
private void UpdateSerieDataRadius(SerieData serieData, double value)
{
var minChartWidth = Mathf.Min(chart.chartWidth, chart.chartHeight);
var minRadius = serie.minRadius > 0 ? ChartHelper.GetActualValue(serie.minRadius, minChartWidth) : 0;
if (serieData.radius > 0)
{
serieData.context.outsideRadius = ChartHelper.GetActualValue(serieData.radius, minChartWidth);
}
else
{
var minInsideRadius = minRadius > 0 ? minRadius : serie.context.insideRadius;
serieData.context.outsideRadius = serie.pieRoseType > 0 ?
minInsideRadius + (float)((serie.context.outsideRadius - minInsideRadius) * value / serie.context.dataMax) :
serie.context.outsideRadius;
}
if (minRadius > 0 && serieData.context.outsideRadius < minRadius)
{
serieData.context.outsideRadius = minRadius;
}
var offset = 0f;
var interactOffset = serie.animation.interaction.GetOffset(serie.context.outsideRadius);
serieData.context.insideRadius = serie.context.insideRadius;
if (serie.pieClickOffset && (serieData.selected || serieData.context.selected))
{
offset += interactOffset;
}
if (offset > 0)
{
serieData.context.outsideRadius += interactOffset;
var currRad = serieData.context.halfAngle * Mathf.Deg2Rad;
var currSin = Mathf.Sin(currRad);
var currCos = Mathf.Cos(currRad);
serieData.context.offsetRadius = 0;
if (serie.pieClickOffset && (serieData.selected || serieData.context.selected))
{
serieData.context.offsetRadius += interactOffset;
if (serieData.context.insideRadius > 0)
{
serieData.context.insideRadius += interactOffset;
}
}
serieData.context.offsetCenter = new Vector3(
serie.context.center.x + serieData.context.offsetRadius * currSin,
serie.context.center.y + serieData.context.offsetRadius * currCos);
}
else
{
serieData.context.offsetCenter = serie.context.center;
}
if (serieData.context.highlight)
{
serieData.context.outsideRadius = serie.animation.GetInteractionRadius(serieData.context.outsideRadius);
}
var halfRadius = serie.context.insideRadius + (serieData.context.outsideRadius - serie.context.insideRadius) / 2;
serieData.context.position = ChartHelper.GetPosition(serie.context.center, serieData.context.halfAngle, halfRadius);
}
private double GetTotalAngle(Serie serie, double dataTotal, ref float totalAngle)
{
totalAngle = serie.context.startAngle + 360f;
if (serie.minAngle > 0)
{
var rate = serie.minAngle / 360;
var minAngleValue = dataTotal * rate;
foreach (var serieData in serie.data)
{
var value = serieData.GetData(1);
if (value < minAngleValue)
{
totalAngle -= serie.minAngle;
dataTotal -= value;
}
}
return dataTotal;
}
else
{
return dataTotal;
}
}
private void DrawPieCenter(VertexHelper vh, Serie serie, ItemStyle itemStyle, float insideRadius)
{
if (!ChartHelper.IsClearColor(itemStyle.centerColor))
{
var radius = insideRadius - itemStyle.centerGap;
UGL.DrawCricle(vh, serie.context.center, radius, itemStyle.centerColor, chart.settings.cicleSmoothness);
}
}
private void DrawPie(VertexHelper vh, Pie serie)
{
if (!serie.show || serie.animation.HasFadeOut())
{
return;
}
var dataChanging = false;
var interacting = false;
var color = ColorUtil.clearColor32;
var toColor = ColorUtil.clearColor32;
var interactDuration = serie.animation.GetInteractionDuration();
var interactEnable = serie.animation.enable && serie.animation.interaction.enable
&& !serie.animation.IsFadeIn() && !serie.animation.IsFadeOut();
var data = serie.data;
serie.animation.InitProgress(0, 360);
if (data.Count == 0)
{
var itemStyle = SerieHelper.GetItemStyle(serie, null);
var fillColor = ChartHelper.IsClearColor(itemStyle.backgroundColor) ?
(Color32)chart.theme.legend.inactiveColor : itemStyle.backgroundColor;
UGL.DrawDoughnut(vh, serie.context.center, serie.context.insideRadius,
serie.context.outsideRadius, fillColor, fillColor, Color.clear, 0,
360, itemStyle.borderWidth, itemStyle.borderColor, serie.gap / 2, chart.settings.cicleSmoothness,
false, true, serie.radiusGradient);
}
for (int n = 0; n < data.Count; n++)
{
var serieData = data[n];
if (!serieData.show)
{
continue;
}
if (serieData.IsDataChanged())
dataChanging = true;
var itemStyle = SerieHelper.GetItemStyle(serie, serieData);
var colorIndex = chart.GetLegendRealShowNameIndex(serieData.legendName);
var outsideRadius = 0f;
var needOffset = (serie.pieClickOffset && (serieData.selected || serieData.context.selected));
var offsetCenter = needOffset ? serieData.context.offsetCenter : serie.context.center;
var progress = AnimationStyleHelper.CheckDataAnimation(chart, serie, n, 1);
var insideRadius = serieData.context.insideRadius * progress;
if (!interactEnable || !serieData.interact.TryGetValueAndColor(
ref outsideRadius, ref offsetCenter, ref color, ref toColor, ref interacting, interactDuration))
{
SerieHelper.GetItemColor(out color, out toColor, serie, serieData, chart.theme, colorIndex);
outsideRadius = serieData.context.outsideRadius * progress;
if (interactEnable)
{
serieData.interact.SetValueAndColor(ref interacting, outsideRadius, color, toColor);
serieData.interact.SetPosition(ref interacting, offsetCenter);
}
}
var borderWidth = itemStyle.borderWidth;
var borderColor = itemStyle.GetBorderColor(color);
if (serie.pieType == PieType.Wireframe)
{
color = ColorUtil.clearColor32;
toColor = ColorUtil.clearColor32;
if (borderWidth <= 0)
{
borderWidth = 4;
}
}
var drawEndDegree = serieData.context.currentAngle;
var needRoundCap = serie.roundCap && insideRadius > 0;
UGL.DrawDoughnut(vh, offsetCenter, insideRadius,
outsideRadius, color, toColor, Color.clear, serieData.context.startAngle,
drawEndDegree, borderWidth, borderColor, serie.gap / 2, chart.settings.cicleSmoothness,
needRoundCap, true, serie.radiusGradient);
DrawPieCenter(vh, serie, itemStyle, insideRadius);
if (serie.animation.CheckDetailBreak(serieData.context.toAngle))
break;
}
if (!serie.animation.IsFinish())
{
serie.animation.CheckProgress();
serie.animation.CheckSymbol(serie.symbol.GetSize(null, chart.theme.serie.lineSymbolSize));
chart.RefreshPainter(serie);
}
if (dataChanging || interacting)
{
chart.RefreshPainter(serie);
}
}
private static void UpdatePieLabelPosition(Serie serie, SerieData serieData)
{
if (serieData.labelObject == null) return;
var startAngle = serie.context.startAngle;
var currAngle = serieData.context.halfAngle;
var currRad = currAngle * Mathf.Deg2Rad;
var offsetRadius = serieData.context.offsetRadius;
var insideRadius = serieData.context.insideRadius;
var outsideRadius = serieData.context.outsideRadius;
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
var labelLine = SerieHelper.GetSerieLabelLine(serie, serieData);
var center = serieData.context.offsetCenter;
var interact = false;
serieData.interact.TryGetValueAndColor(ref outsideRadius, ref center, ref interact, serie.animation.GetInteractionDuration());
var diffAngle = (currAngle - startAngle) % 360;
var isLeft = diffAngle > 180 || (diffAngle == 0 && serieData.context.startAngle > 0);
switch (serieLabel.position)
{
case LabelStyle.Position.Center:
serieData.context.labelPosition = serie.context.center;
break;
case LabelStyle.Position.Inside:
case LabelStyle.Position.Middle:
var labelRadius = offsetRadius + insideRadius + (outsideRadius - insideRadius) / 2 + serieLabel.distance;
var labelCenter = new Vector2(center.x + labelRadius * Mathf.Sin(currRad),
center.y + labelRadius * Mathf.Cos(currRad));
UpdateLabelPosition(serie, serieData, labelLine, labelCenter, isLeft);
break;
default:
//LabelStyle.Position.Outside
var startPos = new Vector2(center.x + outsideRadius * Mathf.Sin(currRad),
center.y + outsideRadius * Mathf.Cos(currRad));
UpdateLabelPosition(serie, serieData, labelLine, startPos, isLeft);
break;
}
}
private static void UpdateLabelPosition(Serie serie, SerieData serieData, LabelLine labelLine, Vector3 startPosition, bool isLeft)
{
serieData.context.labelLinePosition = startPosition;
if (labelLine == null || !labelLine.show)
{
serieData.context.labelPosition = startPosition;
return;
}
var dire = isLeft ? Vector3.left : Vector3.right;
var rad = Mathf.Deg2Rad * serieData.context.halfAngle;
var lineLength1 = ChartHelper.GetActualValue(labelLine.lineLength1, serie.context.outsideRadius);
var lineLength2 = ChartHelper.GetActualValue(labelLine.lineLength2, serie.context.outsideRadius);
var radius = lineLength1;
var pos1 = startPosition;
var pos2 = pos1 + new Vector3(Mathf.Sin(rad) * radius, Mathf.Cos(rad) * radius);
var pos5 = labelLine.lineType == LabelLine.LineType.HorizontalLine
? pos1 + dire * (radius + lineLength2) + labelLine.GetEndSymbolOffset()
: pos2 + dire * lineLength2 + labelLine.GetEndSymbolOffset();
if (labelLine.lineEndX != 0)
{
pos5.x = serie.context.center.x + (isLeft ? -Mathf.Abs(labelLine.lineEndX) : Mathf.Abs(labelLine.lineEndX));
}
serieData.context.labelLinePosition2 = pos2;
serieData.context.labelPosition = pos5;
}
private void DrawPieLabelLine(VertexHelper vh, Serie serie, bool isTop)
{
foreach (var serieData in serie.data)
{
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
var labelLine = SerieHelper.GetSerieLabelLine(serie, serieData);
if (SerieLabelHelper.CanShowLabel(serie, serieData, serieLabel, 1))
{
int colorIndex = chart.m_LegendRealShowName.IndexOf(serieData.name);
if (serieLabel != null && serieLabel.show &&
labelLine != null && labelLine.show)
{
if (serieLabel.position == LabelStyle.Position.Inside || serieLabel.position == LabelStyle.Position.Middle)
{
if (!isTop) continue;
}
else
{
if (isTop && !labelLine.startSymbol.show) continue;
}
var color = ChartHelper.IsClearColor(labelLine.lineColor) ?
chart.theme.GetColor(colorIndex) :
labelLine.lineColor;
switch (labelLine.lineType)
{
case LabelLine.LineType.BrokenLine:
UGL.DrawLine(vh, serieData.context.labelLinePosition, serieData.context.labelLinePosition2,
serieData.context.labelPosition, labelLine.lineWidth, color);
break;
case LabelLine.LineType.Curves:
if (serieData.context.labelLinePosition2 == serieData.context.labelPosition)
{
UGL.DrawCurves(vh, serieData.context.labelLinePosition, serieData.context.labelPosition,
serieData.context.labelLinePosition, (serieData.context.labelLinePosition + serieData.context.labelPosition) * 0.6f,
labelLine.lineWidth, color, chart.settings.lineSmoothness);
}
else
{
UGL.DrawCurves(vh, serieData.context.labelLinePosition, serieData.context.labelPosition,
serieData.context.labelLinePosition, serieData.context.labelLinePosition2,
labelLine.lineWidth, color, chart.settings.lineSmoothness);
}
break;
case LabelLine.LineType.HorizontalLine:
UGL.DrawLine(vh, serieData.context.labelLinePosition, serieData.context.labelPosition,
labelLine.lineWidth, color);
break;
}
DrawLabelLineSymbol(vh, labelLine, serieData.context.labelLinePosition, serieData.context.labelPosition, color);
}
}
}
}
private int GetPiePosIndex(Serie serie, Vector2 local)
{
if (!(serie is Pie))
return -1;
var dist = Vector2.Distance(local, serie.context.center);
var interactOffset = serie.animation.interaction.GetOffset(serie.context.outsideRadius);
var maxRadius = serie.context.outsideRadius + interactOffset;
if (dist < serie.context.insideRadius - interactOffset || dist > maxRadius)
{
return -1;
}
var dir = local - new Vector2(serie.context.center.x, serie.context.center.y);
var angle = ChartHelper.GetAngle360(Vector2.up, dir);
for (int i = 0; i < serie.data.Count; i++)
{
var serieData = serie.data[i];
if (angle >= serieData.context.startAngle && angle <= serieData.context.toAngle)
{
var ndist = (serieData.selected || serieData.context.selected) ?
Vector2.Distance(local, serieData.context.offsetCenter) :
dist;
ndist = dist;
if (ndist >= serieData.context.insideRadius - interactOffset && ndist <= serieData.context.outsideRadius)
{
return i;
}
}
}
return -1;
}
private bool PointerIsInPieSerie(Serie serie, Vector2 local)
{
if (!(serie is Pie))
return false;
var dist = Vector2.Distance(local, serie.context.center);
if (dist >= serie.context.insideRadius && dist <= serie.context.outsideRadius)
return true;
return false;
}
private float GetStartAngle(Serie serie)
{
return serie.clockwise ? (serie.startAngle + 360) % 360 : 360 - serie.startAngle;
}
private float GetToAngle(Serie serie, float angle)
{
var toAngle = angle + serie.startAngle;
if (!serie.clockwise)
{
toAngle = 360 - angle - serie.startAngle;
}
if (!serie.animation.IsFinish())
{
var currAngle = serie.animation.GetCurrDetail();
if (serie.clockwise)
{
toAngle = toAngle > currAngle ? currAngle : toAngle;
}
else
{
toAngle = toAngle < 360 - currAngle ? 360 - currAngle : toAngle;
}
}
return toAngle;
}
private void AvoidLabelOverlap(Serie serie, ComponentTheme theme)
{
if (!serie.avoidLabelOverlap) return;
var lastCheckPos = Vector3.zero;
var lastX = 0f;
var data = serie.data;
var splitCount = 0;
for (int n = 0; n < data.Count; n++)
{
var serieData = data[n];
if (serieData.context.labelPosition.x != 0 && serieData.context.labelPosition.x < serie.context.center.x)
{
splitCount = n;
break;
}
}
var limitX = float.MinValue;
for (int n = 0; n < splitCount; n++)
{
CheckSerieDataLabel(serie, data[n], splitCount, false, n == splitCount - 1, theme, ref lastCheckPos, ref lastX, ref limitX);
}
lastCheckPos = Vector3.zero;
limitX = float.MaxValue;
for (int n = data.Count - 1; n >= splitCount; n--)
{
CheckSerieDataLabel(serie, data[n], data.Count - splitCount, true, n == splitCount, theme, ref lastCheckPos, ref lastX, ref limitX);
}
}
private void CheckSerieDataLabel(Serie serie, SerieData serieData, int total, bool isLeft, bool isLastOne, ComponentTheme theme,
ref Vector3 lastCheckPos, ref float lastX, ref float limitX)
{
if (!serieData.context.canShowLabel)
{
serieData.SetLabelActive(false);
return;
}
if (!serieData.show) return;
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
if (serieLabel == null) return;
if (!serieLabel.show) return;
var labelLine = SerieHelper.GetSerieLabelLine(serie, serieData);
var fontSize = serieData.labelObject.GetHeight();
var lineLength1 = 0f;
var lineLength2 = 0f;
if (labelLine != null && labelLine.show)
{
lineLength1 = ChartHelper.GetActualValue(labelLine.lineLength1, serie.context.outsideRadius);
lineLength2 = ChartHelper.GetActualValue(labelLine.lineLength2, serie.context.outsideRadius);
}
if (lastCheckPos == Vector3.zero)
{
lastCheckPos = serieData.context.labelPosition;
}
else if (serieData.context.labelPosition.x != 0)
{
if (lastCheckPos.y - serieData.context.labelPosition.y < fontSize)
{
var labelRadius = serie.context.outsideRadius + lineLength1;
var y1 = lastCheckPos.y - fontSize;
var cy = serie.context.center.y;
var diff = Mathf.Abs(y1 - cy);
var diffX = labelRadius * labelRadius - diff * diff;
diffX = diffX <= 0 ? 0 : diffX;
var x1 = serie.context.center.x + Mathf.Sqrt(diffX) * (isLeft ? -1 : 1);
var newPos = new Vector3(x1, y1);
serieData.context.labelLinePosition2 = newPos;
if (isLeft)
{
if (x1 < limitX)
{
limitX = x1;
serieData.context.labelPosition = new Vector3(newPos.x - lineLength2, newPos.y);
lastX = serieData.context.labelPosition.x;
}
else
{
serieData.context.labelPosition = new Vector3(lastX, y1);
lastX += 2;
}
}
else
{
if (x1 > limitX)
{
limitX = x1;
serieData.context.labelPosition = new Vector3(newPos.x + lineLength2, newPos.y);
lastX = serieData.context.labelPosition.x;
}
else
{
serieData.context.labelPosition = new Vector3(lastX, y1);
lastX -= 2;
}
}
if (labelLine != null && labelLine.show && labelLine.lineEndX != 0)
{
serieData.context.labelPosition.x = isLeft ? -Mathf.Abs(labelLine.lineEndX) : Mathf.Abs(labelLine.lineEndX);
}
if (!isLastOne && serieData.context.labelPosition.y < serieData.context.labelLinePosition.y)
{
serieData.context.labelLinePosition2 = serieData.context.labelPosition;
}
else
{
if (isLeft && serieData.context.labelLinePosition2.x > serieData.context.labelLinePosition.x)
{
serieData.context.labelLinePosition2.x = serieData.context.labelLinePosition.x;
}
else if (!isLeft && serieData.context.labelLinePosition2.x < serieData.context.labelLinePosition.x)
{
serieData.context.labelLinePosition2.x = serieData.context.labelLinePosition.x;
}
}
}
else
{
lastX = serieData.context.labelPosition.x;
}
lastCheckPos = serieData.context.labelPosition;
UpdateLabelPosition(serieData, serieLabel);
}
}
}
}