foldcc/XCharts
1
0
Fork 0
mirror of https://github.com/XCharts-Team/XCharts.git synced 2026-05-30 21:38:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

3.0 - serie context

Browse Source
This commit is contained in:
monitor1394
2021-12-08 13:36:02 +08:00
parent a5469c0996
commit 6109b62eb7
21 changed files with 222 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Assets/XCharts/Examples/Runtime/Example12_CustomDrawing.cs
View File

@@ -33,7 +33,7 @@ namespace XCharts.Examples
chart.onCustomDrawAfterSerie = delegate (VertexHelper vh, Serie serie) chart.onCustomDrawAfterSerie = delegate (VertexHelper vh, Serie serie)
{ {
if (serie.index != 0) return; if (serie.index != 0) return;
var dataPoints = serie.dataPoints; var dataPoints = serie.context.dataPoints;
if (dataPoints.Count > 0) if (dataPoints.Count > 0)
{ {
var pos = dataPoints[3]; var pos = dataPoints[3];

8
Assets/XCharts/Examples/Runtime/Example41_RadarUpdate.cs
View File

@@ -62,7 +62,7 @@ namespace XCharts.Examples
chart.UpdateData(serieIndex, i, value); chart.UpdateData(serieIndex, i, value);
} }
} }
chart.GetChartComponent<Title>().subText = "max:" + serie.runtimeDataMax; chart.GetChartComponent<Title>().subText = "max:" + serie.context.dataMax;
} }
void UpdateMax() void UpdateMax()
@@ -70,10 +70,10 @@ namespace XCharts.Examples
var serieIndex = 0; var serieIndex = 0;
var serie = chart.GetSerie(serieIndex); var serie = chart.GetSerie(serieIndex);
if (serie == null) return; if (serie == null) return;
if (serie.runtimeDataMax != max) if (serie.context.dataMax != max)
{ {
chart.GetChartComponent<Title>().subText = "max:" + serie.runtimeDataMax; chart.GetChartComponent<Title>().subText = "max:" + serie.context.dataMax;
max = serie.runtimeDataMax; max = serie.context.dataMax;
} }
} }
} }

58
Assets/XCharts/Runtime/Helper/SerieHelper.cs
View File

@@ -214,10 +214,10 @@ namespace XCharts
if (serie.center.Length < 2) return; if (serie.center.Length < 2) return;
var centerX = serie.center[0] <= 1 ? chartWidth * serie.center[0] : serie.center[0]; var centerX = serie.center[0] <= 1 ? chartWidth * serie.center[0] : serie.center[0];
var centerY = serie.center[1] <= 1 ? chartHeight * serie.center[1] : serie.center[1]; var centerY = serie.center[1] <= 1 ? chartHeight * serie.center[1] : serie.center[1];
serie.runtimeCenterPos = chartPosition + new Vector3(centerX, centerY); serie.context.center = chartPosition + new Vector3(centerX, centerY);
var minWidth = Mathf.Min(chartWidth, chartHeight); var minWidth = Mathf.Min(chartWidth, chartHeight);
serie.runtimeInsideRadius = serie.radius[0] <= 1 ? minWidth * serie.radius[0] : serie.radius[0]; serie.context.insideRadius = serie.radius[0] <= 1 ? minWidth * serie.radius[0] : serie.radius[0];
serie.runtimeOutsideRadius = serie.radius[1] <= 1 ? minWidth * serie.radius[1] : serie.radius[1]; serie.context.outsideRadius = serie.radius[1] <= 1 ? minWidth * serie.radius[1] : serie.radius[1];
} }
public static void UpdateRect(Serie serie, Vector3 chartPosition, float chartWidth, float chartHeight) public static void UpdateRect(Serie serie, Vector3 chartPosition, float chartWidth, float chartHeight)
@@ -229,22 +229,22 @@ namespace XCharts
var runtimeTop = serie.top <= 1 ? serie.top * chartHeight : serie.top; var runtimeTop = serie.top <= 1 ? serie.top * chartHeight : serie.top;
var runtimeRight = serie.right <= 1 ? serie.right * chartWidth : serie.right; var runtimeRight = serie.right <= 1 ? serie.right * chartWidth : serie.right;
serie.runtimeX = chartPosition.x + runtimeLeft; serie.context.x = chartPosition.x + runtimeLeft;
serie.runtimeY = chartPosition.y + runtimeBottom; serie.context.y = chartPosition.y + runtimeBottom;
serie.runtimeWidth = chartWidth - runtimeLeft - runtimeRight; serie.context.width = chartWidth - runtimeLeft - runtimeRight;
serie.runtimeHeight = chartHeight - runtimeTop - runtimeBottom; serie.context.height = chartHeight - runtimeTop - runtimeBottom;
serie.runtimeCenterPos = new Vector3(serie.runtimeX + serie.runtimeWidth / 2, serie.context.center = new Vector3(serie.context.x + serie.context.width / 2,
serie.runtimeY + serie.runtimeHeight / 2); serie.context.y + serie.context.height / 2);
serie.runtimeRect = new Rect(serie.runtimeX, serie.runtimeY, serie.runtimeWidth, serie.runtimeHeight); serie.context.rect = new Rect(serie.context.x, serie.context.y, serie.context.width, serie.context.height);
} }
else else
{ {
serie.runtimeX = chartPosition.x; serie.context.x = chartPosition.x;
serie.runtimeY = chartPosition.y; serie.context.y = chartPosition.y;
serie.runtimeWidth = chartWidth; serie.context.width = chartWidth;
serie.runtimeHeight = chartHeight; serie.context.height = chartHeight;
serie.runtimeCenterPos = chartPosition + new Vector3(chartWidth / 2, chartHeight / 2); serie.context.center = chartPosition + new Vector3(chartWidth / 2, chartHeight / 2);
serie.runtimeRect = new Rect(serie.runtimeX, serie.runtimeY, serie.runtimeWidth, serie.runtimeHeight); serie.context.rect = new Rect(serie.context.x, serie.context.y, serie.context.width, serie.context.height);
} }
} }
@@ -370,7 +370,7 @@ namespace XCharts
public static bool IsDownPoint(Serie serie, int index) public static bool IsDownPoint(Serie serie, int index)
{ {
var dataPoints = serie.dataPoints; var dataPoints = serie.context.dataPoints;
if (dataPoints.Count < 2) return false; if (dataPoints.Count < 2) return false;
else if (index > 0 && index < dataPoints.Count - 1) else if (index > 0 && index < dataPoints.Count - 1)
{ {
@@ -549,13 +549,13 @@ namespace XCharts
GetMinMaxData(serie, dimension, out min, out max, dataZoom); GetMinMaxData(serie, dimension, out min, out max, dataZoom);
if (ceilRate < 0) if (ceilRate < 0)
{ {
serie.runtimeDataMin = min; serie.context.dataMin = min;
serie.runtimeDataMax = max; serie.context.dataMax = max;
} }
else else
{ {
serie.runtimeDataMin = ChartHelper.GetMinDivisibleValue(min, ceilRate); serie.context.dataMin = ChartHelper.GetMinDivisibleValue(min, ceilRate);
serie.runtimeDataMax = ChartHelper.GetMaxDivisibleValue(max, ceilRate); serie.context.dataMax = ChartHelper.GetMaxDivisibleValue(max, ceilRate);
} }
} }
@@ -565,13 +565,13 @@ namespace XCharts
GetMinMaxData(serie, out min, out max, dataZoom); GetMinMaxData(serie, out min, out max, dataZoom);
if (ceilRate < 0) if (ceilRate < 0)
{ {
serie.runtimeDataMin = min; serie.context.dataMin = min;
serie.runtimeDataMax = max; serie.context.dataMax = max;
} }
else else
{ {
serie.runtimeDataMin = ChartHelper.GetMinDivisibleValue(min, ceilRate); serie.context.dataMin = ChartHelper.GetMinDivisibleValue(min, ceilRate);
serie.runtimeDataMax = ChartHelper.GetMaxDivisibleValue(max, ceilRate); serie.context.dataMax = ChartHelper.GetMaxDivisibleValue(max, ceilRate);
} }
} }
@@ -689,16 +689,16 @@ namespace XCharts
public static void UpdateSerieRuntimeFilterData(Serie serie, bool filterInvisible = true) public static void UpdateSerieRuntimeFilterData(Serie serie, bool filterInvisible = true)
{ {
serie.runtimeSortedData.Clear(); serie.context.sortedData.Clear();
foreach (var serieData in serie.data) foreach (var serieData in serie.data)
{ {
if (!filterInvisible || (filterInvisible && serieData.show)) if (!filterInvisible || (filterInvisible && serieData.show))
serie.runtimeSortedData.Add(serieData); serie.context.sortedData.Add(serieData);
} }
switch (serie.dataSortType) switch (serie.dataSortType)
{ {
case SerieDataSortType.Ascending: case SerieDataSortType.Ascending:
serie.runtimeSortedData.Sort(delegate (SerieData data1, SerieData data2) serie.context.sortedData.Sort(delegate (SerieData data1, SerieData data2)
{ {
var value1 = data1.GetData(1); var value1 = data1.GetData(1);
var value2 = data2.GetData(1); var value2 = data2.GetData(1);
@@ -708,7 +708,7 @@ namespace XCharts
}); });
break; break;
case SerieDataSortType.Descending: case SerieDataSortType.Descending:
serie.runtimeSortedData.Sort(delegate (SerieData data1, SerieData data2) serie.context.sortedData.Sort(delegate (SerieData data1, SerieData data2)
{ {
var value1 = data1.GetData(1); var value1 = data1.GetData(1);
var value2 = data2.GetData(1); var value2 = data2.GetData(1);

26
Assets/XCharts/Runtime/Helper/SerieLabelHelper.cs
View File

@@ -113,7 +113,7 @@ namespace XCharts
var total = serie.max; var total = serie.max;
var content = SerieLabelHelper.GetFormatterContent(serie, serieData, value, total, null, Color.clear); var content = SerieLabelHelper.GetFormatterContent(serie, serieData, value, total, null, Color.clear);
serieData.labelObject.SetText(content); serieData.labelObject.SetText(content);
serieData.labelObject.SetLabelPosition(serie.runtimeCenterPos + serie.label.offset); serieData.labelObject.SetLabelPosition(serie.context.center + serie.label.offset);
if (!ChartHelper.IsClearColor(serie.label.textStyle.color)) if (!ChartHelper.IsClearColor(serie.label.textStyle.color))
{ {
serieData.labelObject.label.SetColor(serie.label.textStyle.color); serieData.labelObject.label.SetColor(serie.label.textStyle.color);
@@ -191,22 +191,22 @@ namespace XCharts
switch (serieLabel.position) switch (serieLabel.position)
{ {
case LabelStyle.Position.Center: case LabelStyle.Position.Center:
serieData.labelPosition = serie.runtimeCenterPos; serieData.labelPosition = serie.context.center;
break; break;
case LabelStyle.Position.Inside: case LabelStyle.Position.Inside:
var labelRadius = offsetRadius + insideRadius + (outsideRadius - insideRadius) / 2 + serieLabel.margin; var labelRadius = offsetRadius + insideRadius + (outsideRadius - insideRadius) / 2 + serieLabel.margin;
var labelCenter = new Vector2(serie.runtimeCenterPos.x + labelRadius * Mathf.Sin(currRad), var labelCenter = new Vector2(serie.context.center.x + labelRadius * Mathf.Sin(currRad),
serie.runtimeCenterPos.y + labelRadius * Mathf.Cos(currRad)); serie.context.center.y + labelRadius * Mathf.Cos(currRad));
serieData.labelPosition = labelCenter; serieData.labelPosition = labelCenter;
break; break;
case LabelStyle.Position.Outside: case LabelStyle.Position.Outside:
if (labelLine.lineType == LabelLine.LineType.HorizontalLine) if (labelLine.lineType == LabelLine.LineType.HorizontalLine)
{ {
var radius1 = serie.runtimeOutsideRadius; var radius1 = serie.context.outsideRadius;
var radius3 = insideRadius + (outsideRadius - insideRadius) / 2; var radius3 = insideRadius + (outsideRadius - insideRadius) / 2;
var currSin = Mathf.Sin(currRad); var currSin = Mathf.Sin(currRad);
var currCos = Mathf.Cos(currRad); var currCos = Mathf.Cos(currRad);
var pos0 = new Vector3(serie.runtimeCenterPos.x + radius3 * currSin, serie.runtimeCenterPos.y + radius3 * currCos); var pos0 = new Vector3(serie.context.center.x + radius3 * currSin, serie.context.center.y + radius3 * currCos);
if (currAngle > 180) if (currAngle > 180)
{ {
currSin = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad); currSin = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad);
@@ -219,9 +219,9 @@ namespace XCharts
} }
else else
{ {
labelRadius = serie.runtimeOutsideRadius + labelLine.lineLength1; labelRadius = serie.context.outsideRadius + labelLine.lineLength1;
labelCenter = new Vector2(serie.runtimeCenterPos.x + labelRadius * Mathf.Sin(currRad), labelCenter = new Vector2(serie.context.center.x + labelRadius * Mathf.Sin(currRad),
serie.runtimeCenterPos.y + labelRadius * Mathf.Cos(currRad)); serie.context.center.y + labelRadius * Mathf.Cos(currRad));
serieData.labelPosition = labelCenter; serieData.labelPosition = labelCenter;
} }
break; break;
@@ -237,7 +237,7 @@ namespace XCharts
for (int n = 0; n < data.Count; n++) for (int n = 0; n < data.Count; n++)
{ {
var serieData = data[n]; var serieData = data[n];
if (serieData.labelPosition.x != 0 && serieData.labelPosition.x < serie.runtimeCenterPos.x) if (serieData.labelPosition.x != 0 && serieData.labelPosition.x < serie.context.center.x)
{ {
splitCount = n; splitCount = n;
break; break;
@@ -276,13 +276,13 @@ namespace XCharts
{ {
if (lastCheckPos.y - serieData.labelPosition.y < fontSize) if (lastCheckPos.y - serieData.labelPosition.y < fontSize)
{ {
var labelRadius = serie.runtimeOutsideRadius + labelLine.lineLength1; var labelRadius = serie.context.outsideRadius + labelLine.lineLength1;
var y1 = lastCheckPos.y - fontSize; var y1 = lastCheckPos.y - fontSize;
var cy = serie.runtimeCenterPos.y; var cy = serie.context.center.y;
var diff = Mathf.Abs(y1 - cy); var diff = Mathf.Abs(y1 - cy);
var diffX = labelRadius * labelRadius - diff * diff; var diffX = labelRadius * labelRadius - diff * diff;
diffX = diffX <= 0 ? 0 : diffX; diffX = diffX <= 0 ? 0 : diffX;
var x1 = serie.runtimeCenterPos.x + Mathf.Sqrt(diffX) * (isLeft ? -1 : 1); var x1 = serie.context.center.x + Mathf.Sqrt(diffX) * (isLeft ? -1 : 1);
serieData.labelPosition = new Vector3(x1, y1); serieData.labelPosition = new Vector3(x1, y1);
} }
lastCheckPos = serieData.labelPosition; lastCheckPos = serieData.labelPosition;

3
Assets/XCharts/Runtime/Internal/BaseChart.cs
View File

@@ -577,7 +577,8 @@ namespace XCharts
{ {
m_OnCustomDrawSerieBeforeCallback.Invoke(vh, serie); m_OnCustomDrawSerieBeforeCallback.Invoke(vh, serie);
} }
serie.dataPoints.Clear(); serie.context.dataPoints.Clear();
serie.context.dataIgnore.Clear();
DrawPainterSerie(vh, serie); DrawPainterSerie(vh, serie);
if (i >= 0 && i < m_SerieHandlers.Count) if (i >= 0 && i < m_SerieHandlers.Count)
{ {

10
Assets/XCharts/Runtime/Serie/Bar/BarHandler.cs
View File

@@ -69,7 +69,7 @@ namespace XCharts
{ {
var colorIndex = chart.GetLegendRealShowNameIndex(serie.legendName); var colorIndex = chart.GetLegendRealShowNameIndex(serie.legendName);
var yCategory = ComponentHelper.IsAnyCategoryOfYAxis(chart.components); var yCategory = ComponentHelper.IsAnyCategoryOfYAxis(chart.components);
serie.dataPoints.Clear(); serie.context.dataPoints.Clear();
if (yCategory) DrawYBarSerie(vh, serie, colorIndex); if (yCategory) DrawYBarSerie(vh, serie, colorIndex);
else DrawXBarSerie(vh, serie, colorIndex); else DrawXBarSerie(vh, serie, colorIndex);
} }
@@ -134,7 +134,7 @@ namespace XCharts
var serieData = showData[i]; var serieData = showData[i];
if (!serieData.show || serie.IsIgnoreValue(serieData)) if (!serieData.show || serie.IsIgnoreValue(serieData))
{ {
serie.dataPoints.Add(Vector3.zero); serie.context.dataPoints.Add(Vector3.zero);
continue; continue;
} }
var highlight = serie.data[i].highlighted var highlight = serie.data[i].highlighted
@@ -211,7 +211,7 @@ namespace XCharts
top = chart.ClampInGrid(grid, top); top = chart.ClampInGrid(grid, top);
} }
serieData.runtimeRect = Rect.MinMaxRect(plb.x, plb.y, prb.x, prt.y); serieData.runtimeRect = Rect.MinMaxRect(plb.x, plb.y, prb.x, prt.y);
serie.dataPoints.Add(top); serie.context.dataPoints.Add(top);
if (serie.show) if (serie.show)
{ {
switch (serie.barType) switch (serie.barType)
@@ -278,7 +278,7 @@ namespace XCharts
var serieData = showData[i]; var serieData = showData[i];
if (!serieData.show || serie.IsIgnoreValue(serieData)) if (!serieData.show || serie.IsIgnoreValue(serieData))
{ {
serie.dataPoints.Add(Vector3.zero); serie.context.dataPoints.Add(Vector3.zero);
continue; continue;
} }
var highlight = serie.data[i].highlighted var highlight = serie.data[i].highlighted
@@ -364,7 +364,7 @@ namespace XCharts
top = chart.ClampInGrid(grid, top); top = chart.ClampInGrid(grid, top);
} }
serieData.runtimeRect = Rect.MinMaxRect(plb.x, plb.y, prb.x, prt.y); serieData.runtimeRect = Rect.MinMaxRect(plb.x, plb.y, prb.x, prt.y);
serie.dataPoints.Add(top); serie.context.dataPoints.Add(top);
if (serie.show && currHig != 0) if (serie.show && currHig != 0)
{ {
switch (serie.barType) switch (serie.barType)

4
Assets/XCharts/Runtime/Serie/Candlestick/CandlestickHandler.cs
View File

@@ -53,7 +53,7 @@ namespace XCharts
var serieData = showData[i]; var serieData = showData[i];
if (serie.IsIgnoreValue(serieData)) if (serie.IsIgnoreValue(serieData))
{ {
serie.dataPoints.Add(Vector3.zero); serie.context.dataPoints.Add(Vector3.zero);
continue; continue;
} }
var highlight = serie.data[i].highlighted || serie.highlighted; var highlight = serie.data[i].highlighted || serie.highlighted;
@@ -98,7 +98,7 @@ namespace XCharts
prb = chart.ClampInGrid(grid, prb); prb = chart.ClampInGrid(grid, prb);
top = chart.ClampInGrid(grid, top); top = chart.ClampInGrid(grid, top);
} }
serie.dataPoints.Add(top); serie.context.dataPoints.Add(top);
var areaColor = isRise var areaColor = isRise
? itemStyle.GetColor(theme.serie.candlestickColor) ? itemStyle.GetColor(theme.serie.candlestickColor)
: itemStyle.GetColor0(theme.serie.candlestickColor0); : itemStyle.GetColor0(theme.serie.candlestickColor0);

50
Assets/XCharts/Runtime/Serie/Gauge/GaugeHandler.cs
View File

@@ -138,14 +138,14 @@ namespace XCharts
var totalValue = serie.max - serie.min; var totalValue = serie.max - serie.min;
var diffAngle = totalAngle / count; var diffAngle = totalAngle / count;
var diffValue = totalValue / count; var diffValue = totalValue / count;
var radius = serie.runtimeInsideRadius - serie.gaugeAxis.axisLabel.margin; var radius = serie.context.insideRadius - serie.gaugeAxis.axisLabel.margin;
var serieData = serie.GetSerieData(0); var serieData = serie.GetSerieData(0);
var customLabelText = serie.gaugeAxis.axisLabelText; var customLabelText = serie.gaugeAxis.axisLabelText;
for (int j = 0; j <= count; j++) for (int j = 0; j <= count; j++)
{ {
var angle = serie.startAngle + j * diffAngle; var angle = serie.startAngle + j * diffAngle;
var value = serie.min + j * diffValue; var value = serie.min + j * diffValue;
var pos = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, radius); var pos = ChartHelper.GetPosition(serie.context.center, angle, radius);
var text = customLabelText != null && j < customLabelText.Count ? customLabelText[j] : var text = customLabelText != null && j < customLabelText.Count ? customLabelText[j] :
SerieLabelHelper.GetFormatterContent(serie, serieData, value, totalValue, SerieLabelHelper.GetFormatterContent(serie, serieData, value, totalValue,
serie.gaugeAxis.axisLabel, Color.clear); serie.gaugeAxis.axisLabel, Color.clear);
@@ -186,13 +186,13 @@ namespace XCharts
var color = serie.gaugeAxis.GetAxisLineColor(chart.theme, serie.index); var color = serie.gaugeAxis.GetAxisLineColor(chart.theme, serie.index);
var backgroundColor = serie.gaugeAxis.GetAxisLineBackgroundColor(chart.theme, serie.index); var backgroundColor = serie.gaugeAxis.GetAxisLineBackgroundColor(chart.theme, serie.index);
var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth); var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth);
var outsideRadius = serie.runtimeInsideRadius + lineWidth; var outsideRadius = serie.context.insideRadius + lineWidth;
var borderWidth = serie.itemStyle.borderWidth; var borderWidth = serie.itemStyle.borderWidth;
var borderColor = serie.itemStyle.borderColor; var borderColor = serie.itemStyle.borderColor;
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, serie.runtimeInsideRadius, outsideRadius, UGL.DrawDoughnut(vh, serie.context.center, serie.context.insideRadius, outsideRadius,
backgroundColor, backgroundColor, Color.clear, serie.startAngle, serie.endAngle, 0, Color.clear, backgroundColor, backgroundColor, Color.clear, serie.startAngle, serie.endAngle, 0, Color.clear,
0, chart.settings.cicleSmoothness, serie.roundCap); 0, chart.settings.cicleSmoothness, serie.roundCap);
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, serie.runtimeInsideRadius, outsideRadius, UGL.DrawDoughnut(vh, serie.context.center, serie.context.insideRadius, outsideRadius,
color, color, Color.clear, serie.startAngle, currAngle, 0, Color.clear, color, color, Color.clear, serie.startAngle, currAngle, 0, Color.clear,
0, chart.settings.cicleSmoothness, serie.roundCap); 0, chart.settings.cicleSmoothness, serie.roundCap);
} }
@@ -205,14 +205,14 @@ namespace XCharts
var tempStartAngle = serie.startAngle; var tempStartAngle = serie.startAngle;
var tempEndAngle = serie.startAngle; var tempEndAngle = serie.startAngle;
var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth); var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth);
var outsideRadius = serie.runtimeInsideRadius + lineWidth; var outsideRadius = serie.context.insideRadius + lineWidth;
serie.gaugeAxis.runtimeStageAngle.Clear(); serie.gaugeAxis.runtimeStageAngle.Clear();
for (int i = 0; i < serie.gaugeAxis.axisLine.stageColor.Count; i++) for (int i = 0; i < serie.gaugeAxis.axisLine.stageColor.Count; i++)
{ {
var stageColor = serie.gaugeAxis.axisLine.stageColor[i]; var stageColor = serie.gaugeAxis.axisLine.stageColor[i];
tempEndAngle = serie.startAngle + totalAngle * stageColor.percent; tempEndAngle = serie.startAngle + totalAngle * stageColor.percent;
serie.gaugeAxis.runtimeStageAngle.Add(tempEndAngle); serie.gaugeAxis.runtimeStageAngle.Add(tempEndAngle);
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, serie.runtimeInsideRadius, outsideRadius, UGL.DrawDoughnut(vh, serie.context.center, serie.context.insideRadius, outsideRadius,
stageColor.color, stageColor.color, Color.clear, tempStartAngle, tempEndAngle, 0, Color.clear, stageColor.color, stageColor.color, Color.clear, tempStartAngle, tempEndAngle, 0, Color.clear,
0, chart.settings.cicleSmoothness); 0, chart.settings.cicleSmoothness);
tempStartAngle = tempEndAngle; tempStartAngle = tempEndAngle;
@@ -225,12 +225,12 @@ namespace XCharts
var pointerColor = serie.gaugeAxis.GetPointerColor(chart.theme, serie.index, currAngle, serie.itemStyle); var pointerColor = serie.gaugeAxis.GetPointerColor(chart.theme, serie.index, currAngle, serie.itemStyle);
var pointerToColor = !ChartHelper.IsClearColor(serie.itemStyle.toColor) ? serie.itemStyle.toColor : pointerColor; var pointerToColor = !ChartHelper.IsClearColor(serie.itemStyle.toColor) ? serie.itemStyle.toColor : pointerColor;
var len = serie.gaugePointer.length < 1 && serie.gaugePointer.length > -1 ? var len = serie.gaugePointer.length < 1 && serie.gaugePointer.length > -1 ?
serie.runtimeInsideRadius * serie.gaugePointer.length : serie.context.insideRadius * serie.gaugePointer.length :
serie.gaugePointer.length; serie.gaugePointer.length;
var p1 = ChartHelper.GetPosition(serie.runtimeCenterPos, currAngle, len); var p1 = ChartHelper.GetPosition(serie.context.center, currAngle, len);
var p2 = ChartHelper.GetPosition(serie.runtimeCenterPos, currAngle + 180, serie.gaugePointer.width); var p2 = ChartHelper.GetPosition(serie.context.center, currAngle + 180, serie.gaugePointer.width);
var p3 = ChartHelper.GetPosition(serie.runtimeCenterPos, currAngle - 90, serie.gaugePointer.width / 2); var p3 = ChartHelper.GetPosition(serie.context.center, currAngle - 90, serie.gaugePointer.width / 2);
var p4 = ChartHelper.GetPosition(serie.runtimeCenterPos, currAngle + 90, serie.gaugePointer.width / 2); var p4 = ChartHelper.GetPosition(serie.context.center, currAngle + 90, serie.gaugePointer.width / 2);
UGL.DrawTriangle(vh, p2, p3, p1, pointerColor, pointerColor, pointerToColor); UGL.DrawTriangle(vh, p2, p3, p1, pointerColor, pointerColor, pointerToColor);
UGL.DrawTriangle(vh, p4, p2, p1, pointerColor, pointerColor, pointerToColor); UGL.DrawTriangle(vh, p4, p2, p1, pointerColor, pointerColor, pointerToColor);
} }
@@ -246,14 +246,14 @@ namespace XCharts
var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth); var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth);
var splitLineWidth = splitLine.GetWidth(chart.theme.gauge.splitLineWidth); var splitLineWidth = splitLine.GetWidth(chart.theme.gauge.splitLineWidth);
var splitLineLength = splitLine.GetLength(chart.theme.gauge.splitLineLength); var splitLineLength = splitLine.GetLength(chart.theme.gauge.splitLineLength);
var outsideRadius = serie.runtimeInsideRadius + lineWidth; var outsideRadius = serie.context.insideRadius + lineWidth;
var insideRadius = outsideRadius - splitLineLength; var insideRadius = outsideRadius - splitLineLength;
for (int i = 0; i < serie.splitNumber + 1; i++) for (int i = 0; i < serie.splitNumber + 1; i++)
{ {
var angle = serie.startAngle + i * diffAngle; var angle = serie.startAngle + i * diffAngle;
var lineColor = serie.gaugeAxis.GetSplitLineColor(chart.theme.gauge.splitLineColor, serie.index, angle); var lineColor = serie.gaugeAxis.GetSplitLineColor(chart.theme.gauge.splitLineColor, serie.index, angle);
var p1 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, insideRadius); var p1 = ChartHelper.GetPosition(serie.context.center, angle, insideRadius);
var p2 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, outsideRadius); var p2 = ChartHelper.GetPosition(serie.context.center, angle, outsideRadius);
UGL.DrawLine(vh, p1, p2, splitLineWidth, lineColor); UGL.DrawLine(vh, p1, p2, splitLineWidth, lineColor);
} }
} }
@@ -269,7 +269,7 @@ namespace XCharts
var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth); var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth);
var tickWidth = axisTick.GetWidth(chart.theme.gauge.tickWidth); var tickWidth = axisTick.GetWidth(chart.theme.gauge.tickWidth);
var tickLength = axisTick.GetLength(chart.theme.gauge.tickLength); var tickLength = axisTick.GetLength(chart.theme.gauge.tickLength);
var outsideRadius = serie.runtimeInsideRadius + lineWidth; var outsideRadius = serie.context.insideRadius + lineWidth;
var insideRadius = outsideRadius - (tickLength < 1 ? lineWidth * tickLength : tickLength); var insideRadius = outsideRadius - (tickLength < 1 ? lineWidth * tickLength : tickLength);
for (int i = 0; i < serie.splitNumber; i++) for (int i = 0; i < serie.splitNumber; i++)
@@ -278,8 +278,8 @@ namespace XCharts
{ {
var angle = serie.startAngle + i * diffAngle + j * (diffAngle / axisTick.splitNumber); var angle = serie.startAngle + i * diffAngle + j * (diffAngle / axisTick.splitNumber);
var lineColor = serie.gaugeAxis.GetSplitLineColor(chart.theme.gauge.tickColor, serie.index, angle); var lineColor = serie.gaugeAxis.GetSplitLineColor(chart.theme.gauge.tickColor, serie.index, angle);
var p1 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, insideRadius); var p1 = ChartHelper.GetPosition(serie.context.center, angle, insideRadius);
var p2 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, outsideRadius); var p2 = ChartHelper.GetPosition(serie.context.center, angle, outsideRadius);
UGL.DrawLine(vh, p1, p2, tickWidth, lineColor); UGL.DrawLine(vh, p1, p2, tickWidth, lineColor);
} }
} }
@@ -298,7 +298,7 @@ namespace XCharts
if (serie.dataCount > 0) if (serie.dataCount > 0)
{ {
var serieData = serie.data[0]; var serieData = serie.data[0];
serieData.labelPosition = serie.runtimeCenterPos + serie.label.offset; serieData.labelPosition = serie.context.center + serie.label.offset;
value = dest ? serieData.GetData(1) value = dest ? serieData.GetData(1)
: serieData.GetCurrData(1, serie.animation.GetUpdateAnimationDuration()); : serieData.GetCurrData(1, serie.animation.GetUpdateAnimationDuration());
value = MathUtil.Clamp(value, serie.min, serie.max); value = MathUtil.Clamp(value, serie.min, serie.max);
@@ -348,14 +348,14 @@ namespace XCharts
continue; continue;
var len = serie.gaugePointer.length < 1 && serie.gaugePointer.length > -1 var len = serie.gaugePointer.length < 1 && serie.gaugePointer.length > -1
? serie.runtimeInsideRadius * serie.gaugePointer.length ? serie.context.insideRadius * serie.gaugePointer.length
: serie.gaugePointer.length; : serie.gaugePointer.length;
if (Vector3.Distance(local, serie.runtimeCenterPos) > len) continue; if (Vector3.Distance(local, serie.context.center) > len) continue;
var currAngle = (float)(serie.animation.IsFinish() ? GetCurrAngle(serie, false) : serie.animation.GetCurrDetail()); var currAngle = (float)(serie.animation.IsFinish() ? GetCurrAngle(serie, false) : serie.animation.GetCurrDetail());
var p1 = ChartHelper.GetPosition(serie.runtimeCenterPos, currAngle, len); var p1 = ChartHelper.GetPosition(serie.context.center, currAngle, len);
var p2 = ChartHelper.GetPosition(serie.runtimeCenterPos, currAngle + 180, serie.gaugePointer.width); var p2 = ChartHelper.GetPosition(serie.context.center, currAngle + 180, serie.gaugePointer.width);
var p3 = ChartHelper.GetPosition(serie.runtimeCenterPos, currAngle - 90, serie.gaugePointer.width / 2); var p3 = ChartHelper.GetPosition(serie.context.center, currAngle - 90, serie.gaugePointer.width / 2);
var p4 = ChartHelper.GetPosition(serie.runtimeCenterPos, currAngle + 90, serie.gaugePointer.width / 2); var p4 = ChartHelper.GetPosition(serie.context.center, currAngle + 90, serie.gaugePointer.width / 2);
if (ChartHelper.IsPointInQuadrilateral(local, p1, p3, p2, p4)) if (ChartHelper.IsPointInQuadrilateral(local, p1, p3, p2, p4))
{ {
return serie; return serie;

6
Assets/XCharts/Runtime/Serie/Heatmap/HeatmapHandler.cs
View File

@@ -84,7 +84,7 @@ namespace XCharts
borderColor.a = (byte)(borderColor.a * serie.itemStyle.opacity); borderColor.a = (byte)(borderColor.a * serie.itemStyle.opacity);
var borderToColor = serie.itemStyle.opacity > 0 ? serie.itemStyle.borderToColor : ChartConst.clearColor32; var borderToColor = serie.itemStyle.opacity > 0 ? serie.itemStyle.borderToColor : ChartConst.clearColor32;
borderToColor.a = (byte)(borderToColor.a * serie.itemStyle.opacity); borderToColor.a = (byte)(borderToColor.a * serie.itemStyle.opacity);
serie.dataPoints.Clear(); serie.context.dataPoints.Clear();
serie.animation.InitProgress(1, 0, xCount); serie.animation.InitProgress(1, 0, xCount);
var animationIndex = serie.animation.GetCurrIndex(); var animationIndex = serie.animation.GetCurrIndex();
var dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); var dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
@@ -101,7 +101,7 @@ namespace XCharts
var dimension = VisualMapHelper.GetDimension(visualMap, serieData.data.Count); var dimension = VisualMapHelper.GetDimension(visualMap, serieData.data.Count);
if (serie.IsIgnoreIndex(dataIndex, dimension)) if (serie.IsIgnoreIndex(dataIndex, dimension))
{ {
serie.dataPoints.Add(Vector3.zero); serie.context.dataPoints.Add(Vector3.zero);
continue; continue;
} }
var value = serieData.GetCurrData(dimension, dataChangeDuration, yAxis.inverse, var value = serieData.GetCurrData(dimension, dataChangeDuration, yAxis.inverse,
@@ -109,7 +109,7 @@ namespace XCharts
if (serieData.IsDataChanged()) dataChanging = true; if (serieData.IsDataChanged()) dataChanging = true;
var pos = new Vector3(zeroX + (i + (xAxis.boundaryGap ? 0.5f : 0)) * xWidth, var pos = new Vector3(zeroX + (i + (xAxis.boundaryGap ? 0.5f : 0)) * xWidth,
zeroY + (j + (yAxis.boundaryGap ? 0.5f : 0)) * yWidth); zeroY + (j + (yAxis.boundaryGap ? 0.5f : 0)) * yWidth);
serie.dataPoints.Add(pos); serie.context.dataPoints.Add(pos);
serieData.canShowLabel = false; serieData.canShowLabel = false;
serieData.runtimeRect = new Rect(pos.x - rectWid / 2, pos.y - rectHig / 2, rectWid, rectHig); serieData.runtimeRect = new Rect(pos.x - rectWid / 2, pos.y - rectHig / 2, rectWid, rectHig);
if (value == 0) continue; if (value == 0) continue;

47
Assets/XCharts/Runtime/Serie/Line/LineHandler.GridCoord.cs
View File

@@ -94,9 +94,6 @@ namespace XCharts
public override void DrawSerie(VertexHelper vh) public override void DrawSerie(VertexHelper vh)
{ {
var colorIndex = chart.GetLegendRealShowNameIndex(serie.legendName); var colorIndex = chart.GetLegendRealShowNameIndex(serie.legendName);
serie.dataPoints.Clear();
serie.dataIgnore.Clear();
serie.context.colorIndex = colorIndex; serie.context.colorIndex = colorIndex;
if (serie.IsUseCoord<PolarCoord>()) if (serie.IsUseCoord<PolarCoord>())
@@ -163,7 +160,7 @@ namespace XCharts
if (!serie.show || serie.IsPerformanceMode()) if (!serie.show || serie.IsPerformanceMode())
return; return;
var count = serie.dataPoints.Count; var count = serie.context.dataPoints.Count;
var clip = SeriesHelper.IsAnyClipSerie(chart.series); var clip = SeriesHelper.IsAnyClipSerie(chart.series);
XAxis xAxis; XAxis xAxis;
YAxis yAxis; YAxis yAxis;
@@ -193,7 +190,7 @@ namespace XCharts
continue; continue;
} }
if (ChartHelper.IsIngore(serie.dataPoints[i])) if (ChartHelper.IsIngore(serie.context.dataPoints[i]))
continue; continue;
var highlight = serie.data[i].highlighted || serie.highlighted; var highlight = serie.data[i].highlighted || serie.highlighted;
@@ -207,9 +204,9 @@ namespace XCharts
var cornerRadius = SerieHelper.GetSymbolCornerRadius(serie, serieData, highlight); var cornerRadius = SerieHelper.GetSymbolCornerRadius(serie, serieData, highlight);
symbolSize = serie.animation.GetSysmbolSize(symbolSize); symbolSize = serie.animation.GetSysmbolSize(symbolSize);
chart.DrawClipSymbol(vh, symbol.type, symbolSize, symbolBorder, serie.dataPoints[i], chart.DrawClipSymbol(vh, symbol.type, symbolSize, symbolBorder, serie.context.dataPoints[i],
symbolColor, symbolToColor, symbolEmptyColor, symbol.gap, clip, cornerRadius, grid, symbolColor, symbolToColor, symbolEmptyColor, symbol.gap, clip, cornerRadius, grid,
i > 0 ? serie.dataPoints[i - 1] : grid.context.position); i > 0 ? serie.context.dataPoints[i - 1] : grid.context.position);
} }
} }
@@ -218,29 +215,26 @@ namespace XCharts
if (!serie.show || !serie.lineArrow.show) if (!serie.show || !serie.lineArrow.show)
return; return;
if (serie.dataPoints.Count < 2) if (serie.context.dataPoints.Count < 2)
return; return;
var lineColor = SerieHelper.GetLineColor(serie, chart.theme, serie.index, false); var lineColor = SerieHelper.GetLineColor(serie, chart.theme, serie.index, false);
var startPos = Vector3.zero; var startPos = Vector3.zero;
var arrowPos = Vector3.zero; var arrowPos = Vector3.zero;
var lineArrow = serie.lineArrow.arrow; var lineArrow = serie.lineArrow.arrow;
var dataPoints = serie.context.drawPoints;
switch (serie.lineArrow.position) switch (serie.lineArrow.position)
{ {
case LineArrow.Position.End: case LineArrow.Position.End:
var dataPoints = serie.GetUpSmoothList(serie.dataCount - 1);
if (dataPoints.Count < 3) if (dataPoints.Count < 3)
{ {
dataPoints = serie.dataPoints; startPos = dataPoints[dataPoints.Count - 2].position;
startPos = dataPoints[dataPoints.Count - 2]; arrowPos = dataPoints[dataPoints.Count - 1].position;
arrowPos = dataPoints[dataPoints.Count - 1];
} }
else else
{ {
startPos = dataPoints[dataPoints.Count - 3]; startPos = dataPoints[dataPoints.Count - 3].position;
arrowPos = dataPoints[dataPoints.Count - 2]; arrowPos = dataPoints[dataPoints.Count - 2].position;
} }
UGL.DrawArrow(vh, startPos, arrowPos, lineArrow.width, lineArrow.height, UGL.DrawArrow(vh, startPos, arrowPos, lineArrow.width, lineArrow.height,
lineArrow.offset, lineArrow.dent, lineArrow.GetColor(lineColor)); lineArrow.offset, lineArrow.dent, lineArrow.GetColor(lineColor));
@@ -248,11 +242,8 @@ namespace XCharts
break; break;
case LineArrow.Position.Start: case LineArrow.Position.Start:
startPos = dataPoints[1].position;
dataPoints = serie.GetUpSmoothList(1); arrowPos = dataPoints[0].position;
if (dataPoints.Count < 2) dataPoints = serie.dataPoints;
startPos = dataPoints[1];
arrowPos = dataPoints[0];
UGL.DrawArrow(vh, startPos, arrowPos, lineArrow.width, lineArrow.height, UGL.DrawArrow(vh, startPos, arrowPos, lineArrow.width, lineArrow.height,
lineArrow.offset, lineArrow.dent, lineArrow.GetColor(lineColor)); lineArrow.offset, lineArrow.dent, lineArrow.GetColor(lineColor));
@@ -332,15 +323,15 @@ namespace XCharts
{ {
serieData.runtimeStackHig = 0; serieData.runtimeStackHig = 0;
serieData.runtimePosition = Vector3.zero; serieData.runtimePosition = Vector3.zero;
if (serie.ignoreLineBreak && serie.dataIgnore.Count > 0) if (serie.ignoreLineBreak && serie.context.dataIgnore.Count > 0)
{ {
serie.dataIgnore[serie.dataIgnore.Count - 1] = true; serie.context.dataIgnore[serie.context.dataIgnore.Count - 1] = true;
} }
} }
else else
{ {
var np = Vector3.zero; var np = Vector3.zero;
var xValue = serieData.GetData(0, axis.inverse); var xValue = axis.IsCategory() ? i : serieData.GetData(0, axis.inverse);
var relativedValue = DataHelper.SampleValue(ref showData, serie.sampleType, rate, serie.minShow, var relativedValue = DataHelper.SampleValue(ref showData, serie.sampleType, rate, serie.minShow,
maxCount, totalAverage, i, dataChangeDuration, ref dataChanging, relativedAxis); maxCount, totalAverage, i, dataChangeDuration, ref dataChanging, relativedAxis);
@@ -349,18 +340,18 @@ namespace XCharts
serieData.runtimePosition = np; serieData.runtimePosition = np;
serie.dataPoints.Add(np); serie.context.dataPoints.Add(np);
serie.dataIgnore.Add(false); serie.context.dataIgnore.Add(false);
} }
} }
if (dataChanging) if (dataChanging)
chart.RefreshPainter(serie); chart.RefreshPainter(serie);
if (serie.dataPoints.Count <= 0) if (serie.context.dataPoints.Count <= 0)
return; return;
serie.animation.InitProgress(serie.dataPoints, isY); serie.animation.InitProgress(serie.context.dataPoints, isY);
serie.animation.SetDataFinish(0); serie.animation.SetDataFinish(0);
VisualMapHelper.AutoSetLineMinMax(visualMap, serie, isY, axis, relativedAxis); VisualMapHelper.AutoSetLineMinMax(visualMap, serie, isY, axis, relativedAxis);

2
Assets/XCharts/Runtime/Serie/Line/LineHandler.PolarCoord.cs
View File

@@ -44,7 +44,7 @@ namespace XCharts
var currDetailProgress = 0f; var currDetailProgress = 0f;
var totalDetailProgress = datas.Count; var totalDetailProgress = datas.Count;
serie.animation.InitProgress(serie.dataPoints.Count, currDetailProgress, totalDetailProgress); serie.animation.InitProgress(serie.context.dataPoints.Count, currDetailProgress, totalDetailProgress);
serie.animation.SetDataFinish(0); serie.animation.SetDataFinish(0);
for (int i = 1; i < datas.Count; i++) for (int i = 1; i < datas.Count; i++)

14
Assets/XCharts/Runtime/Serie/Line/LineHelper.cs
View File

@@ -373,9 +373,9 @@ namespace XCharts
UpdateStepLineDrawPoints(serie, setting, theme, isY); UpdateStepLineDrawPoints(serie, setting, theme, isY);
break; break;
default: default:
for (int i = 0; i < serie.dataPoints.Count; i++) for (int i = 0; i < serie.context.dataPoints.Count; i++)
{ {
serie.context.drawPoints.Add(new PointInfo(serie.dataPoints[i], serie.dataIgnore[i])); serie.context.drawPoints.Add(new PointInfo(serie.context.dataPoints[i], serie.context.dataIgnore[i]));
} }
break; break;
} }
@@ -383,7 +383,7 @@ namespace XCharts
private static void UpdateSmoothLineDrawPoints(Serie serie, Settings setting, bool isY) private static void UpdateSmoothLineDrawPoints(Serie serie, Settings setting, bool isY)
{ {
var points = serie.dataPoints; var points = serie.context.dataPoints;
float smoothness = setting.lineSmoothness; float smoothness = setting.lineSmoothness;
for (int i = 0; i < points.Count - 1; i++) for (int i = 0; i < points.Count - 1; i++)
{ {
@@ -391,7 +391,7 @@ namespace XCharts
var ep = points[i + 1]; var ep = points[i + 1];
var lsp = i > 0 ? points[i - 1] : sp; var lsp = i > 0 ? points[i - 1] : sp;
var nep = i < points.Count - 2 ? points[i + 2] : ep; var nep = i < points.Count - 2 ? points[i + 2] : ep;
var ignore = serie.dataIgnore[i]; var ignore = serie.context.dataIgnore[i];
if (isY) if (isY)
UGLHelper.GetBezierListVertical(ref s_CurvesPosList, sp, ep, smoothness); UGLHelper.GetBezierListVertical(ref s_CurvesPosList, sp, ep, smoothness);
else else
@@ -406,15 +406,15 @@ namespace XCharts
private static void UpdateStepLineDrawPoints(Serie serie, Settings setting, ThemeStyle theme, bool isY) private static void UpdateStepLineDrawPoints(Serie serie, Settings setting, ThemeStyle theme, bool isY)
{ {
var points = serie.dataPoints; var points = serie.context.dataPoints;
var lp = points[0]; var lp = points[0];
var lineWidth = serie.lineStyle.GetWidth(theme.serie.lineWidth); var lineWidth = serie.lineStyle.GetWidth(theme.serie.lineWidth);
serie.context.drawPoints.Clear(); serie.context.drawPoints.Clear();
serie.context.drawPoints.Add(new PointInfo(lp, serie.dataIgnore[0])); serie.context.drawPoints.Add(new PointInfo(lp, serie.context.dataIgnore[0]));
for (int i = 1; i < points.Count; i++) for (int i = 1; i < points.Count; i++)
{ {
var cp = points[i]; var cp = points[i];
var ignore = serie.dataIgnore[i]; var ignore = serie.context.dataIgnore[i];
if ((isY && Mathf.Abs(lp.x - cp.x) <= lineWidth) if ((isY && Mathf.Abs(lp.x - cp.x) <= lineWidth)
|| (!isY && Mathf.Abs(lp.y - cp.y) <= lineWidth)) || (!isY && Mathf.Abs(lp.y - cp.y) <= lineWidth))
{ {

8
Assets/XCharts/Runtime/Serie/Liquid/LiquidHandler.cs
View File

@@ -155,9 +155,9 @@ namespace XCharts
if (serieData == null) return; if (serieData == null) return;
var dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); var dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
var value = serieData.GetCurrData(1, dataChangeDuration); var value = serieData.GetCurrData(1, dataChangeDuration);
if (serie.runtimeCheckValue != value) if (serie.context.checkValue != value)
{ {
serie.runtimeCheckValue = value; serie.context.checkValue = value;
m_UpdateLabelText = true; m_UpdateLabelText = true;
} }
if (serieData.labelPosition != cenPos) if (serieData.labelPosition != cenPos)
@@ -268,9 +268,9 @@ namespace XCharts
if (serieData == null) return; if (serieData == null) return;
var dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); var dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
var value = serieData.GetCurrData(1, dataChangeDuration); var value = serieData.GetCurrData(1, dataChangeDuration);
if (serie.runtimeCheckValue != value) if (serie.context.checkValue != value)
{ {
serie.runtimeCheckValue = value; serie.context.checkValue = value;
m_UpdateLabelText = true; m_UpdateLabelText = true;
} }
if (serieData.labelPosition != cenPos) if (serieData.labelPosition != cenPos)

2
Assets/XCharts/Runtime/Serie/Parallel/ParallelHandler.cs
View File

@@ -62,7 +62,7 @@ namespace XCharts
serie.animation.InitProgress(serie.showDataDimension, currDetailProgress, totalDetailProgress); serie.animation.InitProgress(serie.showDataDimension, currDetailProgress, totalDetailProgress);
serie.animation.SetDataFinish(0); serie.animation.SetDataFinish(0);
serie.dataPoints.Clear(); serie.context.dataPoints.Clear();
serie.containerIndex = parallel.index; serie.containerIndex = parallel.index;
serie.containterInstanceId = parallel.instanceId; serie.containterInstanceId = parallel.instanceId;

40
Assets/XCharts/Runtime/Serie/Pie/PieHandler.cs
View File

@@ -160,7 +160,7 @@ namespace XCharts
private void UpdateRuntimeData(Serie serie) private void UpdateRuntimeData(Serie serie)
{ {
var data = serie.data; var data = serie.data;
serie.runtimeDataMax = serie.yMax; serie.context.dataMax = serie.yMax;
var runtimePieDataTotal = serie.yTotal; var runtimePieDataTotal = serie.yTotal;
SerieHelper.UpdateCenter(serie, chart.chartPosition, chart.chartWidth, chart.chartHeight); SerieHelper.UpdateCenter(serie, chart.chartPosition, chart.chartWidth, chart.chartHeight);
@@ -180,7 +180,7 @@ namespace XCharts
{ {
totalDegree = 360; totalDegree = 360;
zeroReplaceValue = totalDegree / data.Count; zeroReplaceValue = totalDegree / data.Count;
serie.runtimeDataMax = zeroReplaceValue; serie.context.dataMax = zeroReplaceValue;
runtimePieDataTotal = 360; runtimePieDataTotal = 360;
dataTotalFilterMinAngle = 360; dataTotalFilterMinAngle = 360;
} }
@@ -208,8 +208,8 @@ namespace XCharts
if (serie.minAngle > 0 && degree < serie.minAngle) degree = serie.minAngle; if (serie.minAngle > 0 && degree < serie.minAngle) degree = serie.minAngle;
serieData.runtimePieToAngle = startDegree + degree; serieData.runtimePieToAngle = startDegree + degree;
serieData.runtimePieOutsideRadius = serie.pieRoseType > 0 ? serieData.runtimePieOutsideRadius = serie.pieRoseType > 0 ?
serie.runtimeInsideRadius + (float)((serie.runtimeOutsideRadius - serie.runtimeInsideRadius) * value / serie.runtimeDataMax) : serie.context.insideRadius + (float)((serie.context.outsideRadius - serie.context.insideRadius) * value / serie.context.dataMax) :
serie.runtimeOutsideRadius; serie.context.outsideRadius;
if (serieData.highlighted) if (serieData.highlighted)
{ {
serieData.runtimePieOutsideRadius += chart.theme.serie.pieTooltipExtraRadius; serieData.runtimePieOutsideRadius += chart.theme.serie.pieTooltipExtraRadius;
@@ -229,8 +229,8 @@ namespace XCharts
} }
var halfDegree = (serieData.runtimePieToAngle - startDegree) / 2; var halfDegree = (serieData.runtimePieToAngle - startDegree) / 2;
serieData.runtimePieHalfAngle = startDegree + halfDegree; serieData.runtimePieHalfAngle = startDegree + halfDegree;
serieData.runtiemPieOffsetCenter = serie.runtimeCenterPos; serieData.runtiemPieOffsetCenter = serie.context.center;
serieData.runtimePieInsideRadius = serie.runtimeInsideRadius; serieData.runtimePieInsideRadius = serie.context.insideRadius;
if (offset > 0) if (offset > 0)
{ {
var currRad = serieData.runtimePieHalfAngle * Mathf.Deg2Rad; var currRad = serieData.runtimePieHalfAngle * Mathf.Deg2Rad;
@@ -249,8 +249,8 @@ namespace XCharts
serieData.runtimePieOutsideRadius += chart.theme.serie.pieSelectedOffset; serieData.runtimePieOutsideRadius += chart.theme.serie.pieSelectedOffset;
} }
serieData.runtiemPieOffsetCenter = new Vector3( serieData.runtiemPieOffsetCenter = new Vector3(
serie.runtimeCenterPos.x + serieData.runtimePieOffsetRadius * currSin, serie.context.center.x + serieData.runtimePieOffsetRadius * currSin,
serie.runtimeCenterPos.y + serieData.runtimePieOffsetRadius * currCos); serie.context.center.y + serieData.runtimePieOffsetRadius * currCos);
} }
serieData.canShowLabel = serieData.runtimePieCurrAngle >= serieData.runtimePieHalfAngle; serieData.canShowLabel = serieData.runtimePieCurrAngle >= serieData.runtimePieHalfAngle;
startDegree = serieData.runtimePieToAngle; startDegree = serieData.runtimePieToAngle;
@@ -288,7 +288,7 @@ namespace XCharts
if (!ChartHelper.IsClearColor(itemStyle.centerColor)) if (!ChartHelper.IsClearColor(itemStyle.centerColor))
{ {
var radius = insideRadius - itemStyle.centerGap; var radius = insideRadius - itemStyle.centerGap;
UGL.DrawCricle(vh, serie.runtimeCenterPos, radius, itemStyle.centerColor, chart.settings.cicleSmoothness); UGL.DrawCricle(vh, serie.context.center, radius, itemStyle.centerColor, chart.settings.cicleSmoothness);
} }
} }
@@ -331,7 +331,7 @@ namespace XCharts
{ {
var drawEndDegree = serieData.runtimePieCurrAngle; var drawEndDegree = serieData.runtimePieCurrAngle;
var needRoundCap = serie.roundCap && serieData.runtimePieInsideRadius > 0; var needRoundCap = serie.roundCap && serieData.runtimePieInsideRadius > 0;
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, serieData.runtimePieInsideRadius, UGL.DrawDoughnut(vh, serie.context.center, serieData.runtimePieInsideRadius,
serieData.runtimePieOutsideRadius, color, toColor, Color.clear, serieData.runtimePieStartAngle, serieData.runtimePieOutsideRadius, color, toColor, Color.clear, serieData.runtimePieStartAngle,
drawEndDegree, borderWidth, borderColor, serie.pieSpace / 2, chart.settings.cicleSmoothness, drawEndDegree, borderWidth, borderColor, serie.pieSpace / 2, chart.settings.cicleSmoothness,
needRoundCap, true); needRoundCap, true);
@@ -400,17 +400,17 @@ namespace XCharts
{ {
var insideRadius = serieData.runtimePieInsideRadius; var insideRadius = serieData.runtimePieInsideRadius;
var outSideRadius = serieData.runtimePieOutsideRadius; var outSideRadius = serieData.runtimePieOutsideRadius;
var center = serie.runtimeCenterPos; var center = serie.context.center;
var currAngle = serieData.runtimePieHalfAngle; var currAngle = serieData.runtimePieHalfAngle;
if (!ChartHelper.IsClearColor(labelLine.lineColor)) color = labelLine.lineColor; if (!ChartHelper.IsClearColor(labelLine.lineColor)) color = labelLine.lineColor;
else if (labelLine.lineType == LabelLine.LineType.HorizontalLine) color *= color; else if (labelLine.lineType == LabelLine.LineType.HorizontalLine) color *= color;
float currSin = Mathf.Sin(currAngle * Mathf.Deg2Rad); float currSin = Mathf.Sin(currAngle * Mathf.Deg2Rad);
float currCos = Mathf.Cos(currAngle * Mathf.Deg2Rad); float currCos = Mathf.Cos(currAngle * Mathf.Deg2Rad);
var radius1 = labelLine.lineType == LabelLine.LineType.HorizontalLine ? var radius1 = labelLine.lineType == LabelLine.LineType.HorizontalLine ?
serie.runtimeOutsideRadius : outSideRadius; serie.context.outsideRadius : outSideRadius;
var radius2 = serie.runtimeOutsideRadius + labelLine.lineLength1; var radius2 = serie.context.outsideRadius + labelLine.lineLength1;
var radius3 = insideRadius + (outSideRadius - insideRadius) / 2; var radius3 = insideRadius + (outSideRadius - insideRadius) / 2;
if (radius1 < serie.runtimeInsideRadius) radius1 = serie.runtimeInsideRadius; if (radius1 < serie.context.insideRadius) radius1 = serie.context.insideRadius;
radius1 -= 0.1f; radius1 -= 0.1f;
var pos0 = new Vector3(center.x + radius3 * currSin, center.y + radius3 * currCos); 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 pos1 = new Vector3(center.x + radius1 * currSin, center.y + radius1 * currCos);
@@ -545,10 +545,10 @@ namespace XCharts
private int GetPiePosIndex(Serie serie, Vector2 local) private int GetPiePosIndex(Serie serie, Vector2 local)
{ {
if (!(serie is Pie)) return -1; if (!(serie is Pie)) return -1;
var dist = Vector2.Distance(local, serie.runtimeCenterPos); var dist = Vector2.Distance(local, serie.context.center);
var maxRadius = serie.runtimeOutsideRadius + 3 * chart.theme.serie.pieSelectedOffset; var maxRadius = serie.context.outsideRadius + 3 * chart.theme.serie.pieSelectedOffset;
if (dist < serie.runtimeInsideRadius || dist > maxRadius) return -1; if (dist < serie.context.insideRadius || dist > maxRadius) return -1;
Vector2 dir = local - new Vector2(serie.runtimeCenterPos.x, serie.runtimeCenterPos.y); Vector2 dir = local - new Vector2(serie.context.center.x, serie.context.center.y);
float angle = ChartHelper.GetAngle360(Vector2.up, dir); float angle = ChartHelper.GetAngle360(Vector2.up, dir);
for (int i = 0; i < serie.data.Count; i++) for (int i = 0; i < serie.data.Count; i++)
{ {
@@ -569,8 +569,8 @@ namespace XCharts
private bool PointerIsInPieSerie(Serie serie, Vector2 local) private bool PointerIsInPieSerie(Serie serie, Vector2 local)
{ {
if (!(serie is Pie)) return false; if (!(serie is Pie)) return false;
var dist = Vector2.Distance(local, serie.runtimeCenterPos); var dist = Vector2.Distance(local, serie.context.center);
if (dist >= serie.runtimeInsideRadius && dist <= serie.runtimeOutsideRadius) return true; if (dist >= serie.context.insideRadius && dist <= serie.context.outsideRadius) return true;
return false; return false;
} }
} }

4
Assets/XCharts/Runtime/Serie/Radar/RadarHandler.cs
View File

@@ -179,7 +179,7 @@ namespace XCharts
if (serieData.IsDataChanged()) dataChanging = true; if (serieData.IsDataChanged()) dataChanging = true;
if (max == 0) if (max == 0)
{ {
max = serie.runtimeDataMax; max = serie.context.dataMax;
} }
var radius = (float)(max < 0 ? radar.context.dataRadius - radar.context.dataRadius * value / max var radius = (float)(max < 0 ? radar.context.dataRadius - radar.context.dataRadius * value / max
: radar.context.dataRadius * value / max); : radar.context.dataRadius * value / max);
@@ -347,7 +347,7 @@ namespace XCharts
if (serieData.IsDataChanged()) dataChanging = true; if (serieData.IsDataChanged()) dataChanging = true;
if (max == 0) if (max == 0)
{ {
max = serie.runtimeDataMax; max = serie.context.dataMax;
} }
if (!radar.IsInIndicatorRange(j, serieData.GetData(1))) if (!radar.IsInIndicatorRange(j, serieData.GetData(1)))
{ {

30
Assets/XCharts/Runtime/Serie/Ring/RingHandler.cs
View File

@@ -74,7 +74,7 @@ namespace XCharts
//TitleStyleHelper.CheckTitle(serie, ref chart.m_ReinitTitle, ref m_UpdateTitleText); //TitleStyleHelper.CheckTitle(serie, ref chart.m_ReinitTitle, ref m_UpdateTitleText);
//SerieLabelHelper.CheckLabel(serie, ref chart.m_ReinitLabel, ref m_UpdateLabelText); //SerieLabelHelper.CheckLabel(serie, ref chart.m_ReinitLabel, ref m_UpdateLabelText);
var dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); var dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
var ringWidth = serie.runtimeOutsideRadius - serie.runtimeInsideRadius; var ringWidth = serie.context.outsideRadius - serie.context.insideRadius;
var dataChanging = false; var dataChanging = false;
for (int j = 0; j < data.Count; j++) for (int j = 0; j < data.Count; j++)
{ {
@@ -89,7 +89,7 @@ namespace XCharts
var itemStyle = SerieHelper.GetItemStyle(serie, serieData, serieData.highlighted); var itemStyle = SerieHelper.GetItemStyle(serie, serieData, serieData.highlighted);
var itemColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, j, serieData.highlighted); var itemColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, j, serieData.highlighted);
var itemToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, j, serieData.highlighted); var itemToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, j, serieData.highlighted);
var outsideRadius = serie.runtimeOutsideRadius - j * (ringWidth + serie.ringGap); var outsideRadius = serie.context.outsideRadius - j * (ringWidth + serie.ringGap);
var insideRadius = outsideRadius - ringWidth; var insideRadius = outsideRadius - ringWidth;
var centerRadius = (outsideRadius + insideRadius) / 2; var centerRadius = (outsideRadius + insideRadius) / 2;
var borderWidth = itemStyle.borderWidth; var borderWidth = itemStyle.borderWidth;
@@ -102,11 +102,11 @@ namespace XCharts
serieData.runtimePieOutsideRadius = outsideRadius; serieData.runtimePieOutsideRadius = outsideRadius;
if (itemStyle.backgroundColor.a != 0) if (itemStyle.backgroundColor.a != 0)
{ {
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, insideRadius, outsideRadius, itemStyle.backgroundColor, UGL.DrawDoughnut(vh, serie.context.center, insideRadius, outsideRadius, itemStyle.backgroundColor,
itemStyle.backgroundColor, Color.clear, 0, 360, borderWidth, borderColor, 0, itemStyle.backgroundColor, Color.clear, 0, 360, borderWidth, borderColor, 0,
chart.settings.cicleSmoothness, false, serie.clockwise); chart.settings.cicleSmoothness, false, serie.clockwise);
} }
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, insideRadius, outsideRadius, itemColor, itemToColor, UGL.DrawDoughnut(vh, serie.context.center, insideRadius, outsideRadius, itemColor, itemToColor,
Color.clear, startDegree, toDegree, borderWidth, borderColor, 0, chart.settings.cicleSmoothness, Color.clear, startDegree, toDegree, borderWidth, borderColor, 0, chart.settings.cicleSmoothness,
roundCap, serie.clockwise); roundCap, serie.clockwise);
DrawCenter(vh, serie, serieData, insideRadius, j == data.Count - 1); DrawCenter(vh, serie, serieData, insideRadius, j == data.Count - 1);
@@ -189,7 +189,7 @@ namespace XCharts
{ {
var radius = insideRadius - itemStyle.centerGap; var radius = insideRadius - itemStyle.centerGap;
var smoothness = chart.settings.cicleSmoothness; var smoothness = chart.settings.cicleSmoothness;
UGL.DrawCricle(vh, serie.runtimeCenterPos, radius, itemStyle.centerColor, smoothness); UGL.DrawCricle(vh, serie.context.center, radius, itemStyle.centerColor, smoothness);
} }
} }
@@ -201,20 +201,20 @@ namespace XCharts
switch (serie.label.position) switch (serie.label.position)
{ {
case LabelStyle.Position.Center: case LabelStyle.Position.Center:
serieData.labelPosition = serie.runtimeCenterPos + serie.label.offset; serieData.labelPosition = serie.context.center + serie.label.offset;
break; break;
case LabelStyle.Position.Bottom: case LabelStyle.Position.Bottom:
var px1 = Mathf.Sin(startAngle * Mathf.Deg2Rad) * centerRadius; var px1 = Mathf.Sin(startAngle * Mathf.Deg2Rad) * centerRadius;
var py1 = Mathf.Cos(startAngle * Mathf.Deg2Rad) * centerRadius; var py1 = Mathf.Cos(startAngle * Mathf.Deg2Rad) * centerRadius;
var xDiff = serie.clockwise ? -serie.label.margin : serie.label.margin; var xDiff = serie.clockwise ? -serie.label.margin : serie.label.margin;
serieData.labelPosition = serie.runtimeCenterPos + new Vector3(px1 + xDiff, py1); serieData.labelPosition = serie.context.center + new Vector3(px1 + xDiff, py1);
break; break;
case LabelStyle.Position.Top: case LabelStyle.Position.Top:
startAngle += serie.clockwise ? -serie.label.margin : serie.label.margin; startAngle += serie.clockwise ? -serie.label.margin : serie.label.margin;
toAngle += serie.clockwise ? serie.label.margin : -serie.label.margin; toAngle += serie.clockwise ? serie.label.margin : -serie.label.margin;
var px2 = Mathf.Sin(toAngle * Mathf.Deg2Rad) * centerRadius; var px2 = Mathf.Sin(toAngle * Mathf.Deg2Rad) * centerRadius;
var py2 = Mathf.Cos(toAngle * Mathf.Deg2Rad) * centerRadius; var py2 = Mathf.Cos(toAngle * Mathf.Deg2Rad) * centerRadius;
serieData.labelPosition = serie.runtimeCenterPos + new Vector3(px2, py2); serieData.labelPosition = serie.context.center + new Vector3(px2, py2);
break; break;
} }
serieData.labelObject.SetLabelPosition(serieData.labelPosition); serieData.labelObject.SetLabelPosition(serieData.labelPosition);
@@ -229,12 +229,12 @@ namespace XCharts
var centerRadius = (outsideRadius + insideRadius) / 2; var centerRadius = (outsideRadius + insideRadius) / 2;
var inradius = centerRadius - itemStyle.backgroundWidth / 2; var inradius = centerRadius - itemStyle.backgroundWidth / 2;
var outradius = centerRadius + itemStyle.backgroundWidth / 2; var outradius = centerRadius + itemStyle.backgroundWidth / 2;
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, inradius, UGL.DrawDoughnut(vh, serie.context.center, inradius,
outradius, backgroundColor, Color.clear, chart.settings.cicleSmoothness); outradius, backgroundColor, Color.clear, chart.settings.cicleSmoothness);
} }
else else
{ {
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, insideRadius, UGL.DrawDoughnut(vh, serie.context.center, insideRadius,
outsideRadius, backgroundColor, Color.clear, chart.settings.cicleSmoothness); outsideRadius, backgroundColor, Color.clear, chart.settings.cicleSmoothness);
} }
} }
@@ -244,10 +244,10 @@ namespace XCharts
var itemStyle = SerieHelper.GetItemStyle(serie, serieData); var itemStyle = SerieHelper.GetItemStyle(serie, serieData);
if (itemStyle.show && itemStyle.borderWidth > 0 && !ChartHelper.IsClearColor(itemStyle.borderColor)) if (itemStyle.show && itemStyle.borderWidth > 0 && !ChartHelper.IsClearColor(itemStyle.borderColor))
{ {
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, outsideRadius, UGL.DrawDoughnut(vh, serie.context.center, outsideRadius,
outsideRadius + itemStyle.borderWidth, itemStyle.borderColor, outsideRadius + itemStyle.borderWidth, itemStyle.borderColor,
Color.clear, chart.settings.cicleSmoothness); Color.clear, chart.settings.cicleSmoothness);
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, insideRadius, UGL.DrawDoughnut(vh, serie.context.center, insideRadius,
insideRadius + itemStyle.borderWidth, itemStyle.borderColor, insideRadius + itemStyle.borderWidth, itemStyle.borderColor,
Color.clear, chart.settings.cicleSmoothness); Color.clear, chart.settings.cicleSmoothness);
} }
@@ -273,9 +273,9 @@ namespace XCharts
private int GetRingIndex(Serie serie, Vector2 local) private int GetRingIndex(Serie serie, Vector2 local)
{ {
if (!(serie is Ring)) return -1; if (!(serie is Ring)) return -1;
var dist = Vector2.Distance(local, serie.runtimeCenterPos); var dist = Vector2.Distance(local, serie.context.center);
if (dist > serie.runtimeOutsideRadius) return -1; if (dist > serie.context.outsideRadius) return -1;
Vector2 dir = local - new Vector2(serie.runtimeCenterPos.x, serie.runtimeCenterPos.y); Vector2 dir = local - new Vector2(serie.context.center.x, serie.context.center.y);
float angle = VectorAngle(Vector2.up, dir); float angle = VectorAngle(Vector2.up, dir);
for (int i = 0; i < serie.data.Count; i++) for (int i = 0; i < serie.data.Count; i++)
{ {

4
Assets/XCharts/Runtime/Serie/Scatter/BaseScatterHandler.cs
View File

@@ -186,7 +186,7 @@ namespace XCharts
if (!grid.Contains(pos)) if (!grid.Contains(pos))
continue; continue;
serie.dataPoints.Add(pos); serie.context.dataPoints.Add(pos);
serieData.runtimePosition = pos; serieData.runtimePosition = pos;
var datas = serieData.data; var datas = serieData.data;
float symbolSize = 0; float symbolSize = 0;
@@ -291,7 +291,7 @@ namespace XCharts
var xDataHig = axis.context.height / 2; var xDataHig = axis.context.height / 2;
pos = new Vector3(axis.context.x + xDataHig, axis.context.y + yDataHig); pos = new Vector3(axis.context.x + xDataHig, axis.context.y + yDataHig);
} }
serie.dataPoints.Add(pos); serie.context.dataPoints.Add(pos);
serieData.runtimePosition = pos; serieData.runtimePosition = pos;
var datas = serieData.data; var datas = serieData.data;

93
Assets/XCharts/Runtime/Serie/Serie.cs
View File

@@ -259,7 +259,6 @@ namespace XCharts
[SerializeField] private float m_Top; [SerializeField] private float m_Top;
[SerializeField] private float m_Bottom; [SerializeField] private float m_Bottom;
[SerializeField] private bool m_InsertDataToHead; [SerializeField] private bool m_InsertDataToHead;
[SerializeField] private List<SerieData> m_Data = new List<SerieData>(); [SerializeField] private List<SerieData> m_Data = new List<SerieData>();
[NonSerialized] internal int m_FilterStart; [NonSerialized] internal int m_FilterStart;
@@ -269,11 +268,6 @@ namespace XCharts
[NonSerialized] internal int m_FilterMinShow; [NonSerialized] internal int m_FilterMinShow;
[NonSerialized] internal bool m_NeedUpdateFilterData; [NonSerialized] internal bool m_NeedUpdateFilterData;
[NonSerialized] public List<SerieData> m_FilterData = new List<SerieData>(); [NonSerialized] public List<SerieData> m_FilterData = new List<SerieData>();
[NonSerialized] internal List<SerieData> m_SortedData = new List<SerieData>();
[NonSerialized] private Dictionary<int, List<Vector3>> m_UpSmoothPoints = new Dictionary<int, List<Vector3>>();
[NonSerialized] private Dictionary<int, List<Vector3>> m_DownSmoothPoints = new Dictionary<int, List<Vector3>>();
[NonSerialized] private List<Vector3> m_DataPoints = new List<Vector3>();
[NonSerialized] private List<bool> m_DataIgnore = new List<bool>();
[NonSerialized] private bool m_NameDirty; [NonSerialized] private bool m_NameDirty;
/// <summary> /// <summary>
@@ -993,38 +987,6 @@ namespace XCharts
/// 数据项个数。 /// 数据项个数。
/// </summary> /// </summary>
public int dataCount { get { return m_Data.Count; } } public int dataCount { get { return m_Data.Count; } }
/// <summary>
/// 数据项位置坐标。
/// </summary>
public List<Vector3> dataPoints { get { return m_DataPoints; } }
public List<bool> dataIgnore { get { return m_DataIgnore; } }
/// <summary>
/// 饼图的中心点位置。
/// </summary>
public Vector3 runtimeCenterPos { get; internal set; }
/// <summary>
/// 饼图的内径
/// </summary>
public float runtimeInsideRadius { get; internal set; }
/// <summary>
/// 饼图的外径
/// </summary>
public float runtimeOutsideRadius { get; internal set; }
/// <summary>
/// 运行时的最大数据值
/// </summary>
public double runtimeDataMax { get; internal set; }
/// <summary>
/// 运行时的最小数据值
/// </summary>
public double runtimeDataMin { get; internal set; }
public double runtimeCheckValue { get; set; }
public float runtimeX { get; internal set; }
public float runtimeY { get; internal set; }
public float runtimeWidth { get; internal set; }
public float runtimeHeight { get; internal set; }
public Rect runtimeRect { get; internal set; }
public List<SerieData> runtimeSortedData { get { return m_SortedData; } }
public bool nameDirty { get { return m_NameDirty; } } public bool nameDirty { get { return m_NameDirty; } }
public bool labelDirty { get; set; } public bool labelDirty { get; set; }
public bool titleDirty { get; set; } public bool titleDirty { get; set; }
@@ -1043,45 +1005,6 @@ namespace XCharts
{ {
base.ClearDirty(); base.ClearDirty();
} }
internal List<Vector3> GetUpSmoothList(int dataIndex, int size = 100)
{
if (m_UpSmoothPoints.ContainsKey(dataIndex))
{
return m_UpSmoothPoints[dataIndex];
}
else
{
var list = ListPool<Vector3>.Get();
m_UpSmoothPoints[dataIndex] = list;
return list;
}
}
internal List<Vector3> GetDownSmoothList(int dataIndex, int size = 100)
{
if (m_DownSmoothPoints.ContainsKey(dataIndex))
{
return m_DownSmoothPoints[dataIndex];
}
else
{
var list = ListPool<Vector3>.Get();
m_DownSmoothPoints[dataIndex] = list;
return list;
}
}
internal void ClearSmoothList(int dataIndex)
{
if (m_UpSmoothPoints.ContainsKey(dataIndex))
{
m_UpSmoothPoints[dataIndex].Clear();
}
if (m_DownSmoothPoints.ContainsKey(dataIndex))
{
m_DownSmoothPoints[dataIndex].Clear();
}
}
/// <summary> /// <summary>
/// 维度Y对应数据中最大值。 /// 维度Y对应数据中最大值。
@@ -1226,16 +1149,6 @@ namespace XCharts
{ {
SerieLabelPool.Release(serieData.labelObject.gameObject); SerieLabelPool.Release(serieData.labelObject.gameObject);
} }
if (m_UpSmoothPoints.ContainsKey(serieData.index))
{
ListPool<Vector3>.Release(m_UpSmoothPoints[serieData.index]);
m_UpSmoothPoints.Remove(serieData.index);
}
if (m_DownSmoothPoints.ContainsKey(serieData.index))
{
ListPool<Vector3>.Release(m_DownSmoothPoints[serieData.index]);
m_DownSmoothPoints.Remove(serieData.index);
}
m_Data.RemoveAt(index); m_Data.RemoveAt(index);
m_NeedUpdateFilterData = true; m_NeedUpdateFilterData = true;
labelDirty = true; labelDirty = true;
@@ -1571,7 +1484,7 @@ namespace XCharts
} }
else else
{ {
return runtimeSortedData.Count > 0 ? runtimeSortedData : m_Data; return context.sortedData.Count > 0 ? context.sortedData : m_Data;
} }
} }
@@ -1704,9 +1617,9 @@ namespace XCharts
public bool IsIgnorePoint(int index) public bool IsIgnorePoint(int index)
{ {
if (index >= 0 && index < dataPoints.Count) if (index >= 0 && index < dataCount)
{ {
return ChartHelper.IsIngore(dataPoints[index]); return ChartHelper.IsIngore(data[index].runtimePosition);
} }
return false; return false;
} }

65
Assets/XCharts/Runtime/Serie/SerieContext.cs
View File

@@ -37,9 +37,70 @@ namespace XCharts
/// </summary> /// </summary>
public List<int> pointerAxisDataIndexs = new List<int>(); public List<int> pointerAxisDataIndexs = new List<int>();
public int vertCount; /// <summary>
/// 中心点
/// </summary>
public Vector3 center { get; internal set; }
/// <summary>
/// 内半径
/// </summary>
public float insideRadius { get; internal set; }
/// <summary>
/// 外半径
/// </summary>
public float outsideRadius { get; internal set; }
/// <summary>
/// 最大值
/// </summary>
public double dataMax { get; internal set; }
/// <summary>
/// 最小值
/// </summary>
public double dataMin { get; internal set; }
public double checkValue { get; set; }
/// <summary>
/// 左下角坐标X
/// </summary>
public float x { get; internal set; }
/// <summary>
/// 左下角坐标Y
/// </summary>
public float y { get; internal set; }
/// <summary>
/// 宽
/// </summary>
public float width { get; internal set; }
/// <summary>
/// 高
/// </summary>
public float height { get; internal set; }
/// <summary>
/// 矩形区域
/// </summary>
public Rect rect { get; internal set; }
/// <summary>
/// 绘制顶点数
/// </summary>
public int vertCount { get; internal set; }
/// <summary>
/// 数据对应的位置坐标。
/// </summary>
public List<Vector3> dataPoints = new List<Vector3>();
/// <summary>
/// 数据对应的位置坐标是否忽略（忽略时连线是透明的），dataIgnore 和 dataPoints 一一对应。
/// </summary>
public List<bool> dataIgnore = new List<bool>();
/// <summary>
/// 排序后的数据
/// </summary>
public List<SerieData> sortedData = new List<SerieData>();
/// <summary>
/// theme的颜色索引
/// </summary>
internal int colorIndex; internal int colorIndex;
/// <summary>
/// 绘制点
/// </summary>
internal List<PointInfo> drawPoints = new List<PointInfo>(); internal List<PointInfo> drawPoints = new List<PointInfo>();
} }
} }

2
Assets/XCharts/Runtime/Serie/SerieHandler.cs
View File

@@ -203,7 +203,7 @@ namespace XCharts
txt.SetLocalEulerAngles(Vector2.zero); txt.SetLocalEulerAngles(Vector2.zero);
txt.SetActive(serie.titleStyle.show); txt.SetActive(serie.titleStyle.show);
serie.titleStyle.runtimeText = txt; serie.titleStyle.runtimeText = txt;
serie.titleStyle.UpdatePosition(serie.runtimeCenterPos); serie.titleStyle.UpdatePosition(serie.context.center);
var serieData = serie.GetSerieData(0); var serieData = serie.GetSerieData(0);
if (serieData != null) if (serieData != null)
{ {