protected void DrawScatterSerie(VertexHelper vh, int colorIndex, Serie serie)
{
if (serie.animation.HasFadeOut())
{
return;
}
if (!serie.show)
{
return;
}
DataZoom xDataZoom, yDataZoom;
DataZoomHelper.GetSerieRelatedDataZoom(serie, dataZooms, out xDataZoom, out yDataZoom);
var yAxis = m_YAxes[serie.yAxisIndex];
var xAxis = m_XAxes[serie.xAxisIndex];
var grid = GetSerieGridOrDefault(serie);
int maxCount = serie.maxShow > 0 ?
(serie.maxShow > serie.dataCount ? serie.dataCount : serie.maxShow)
: serie.dataCount;
serie.animation.InitProgress(1, 0, 1);
var rate = serie.animation.GetCurrRate();
var dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
var dataChanging = false;
var dataList = serie.GetDataList(xDataZoom);
foreach (var serieData in dataList)
{
var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
if (!symbol.ShowSymbol(serieData.index, maxCount))
{
continue;
}
var highlight = serie.highlighted || serieData.highlighted;
var color = SerieHelper.GetItemColor(serie, serieData, m_Theme, colorIndex, highlight);
var toColor = SerieHelper.GetItemToColor(serie, serieData, m_Theme, colorIndex, highlight);
var symbolBorder = SerieHelper.GetSymbolBorder(serie, serieData, m_Theme, highlight);
var cornerRadius = SerieHelper.GetSymbolCornerRadius(serie, serieData, highlight);
double xValue = serieData.GetCurrData(0, dataChangeDuration, xAxis.inverse);
double yValue = serieData.GetCurrData(1, dataChangeDuration, yAxis.inverse);
if (serieData.IsDataChanged())
{
dataChanging = true;
}
float pX = grid.runtimeX + xAxis.axisLine.GetWidth(m_Theme.axis.lineWidth);
float pY = grid.runtimeY + yAxis.axisLine.GetWidth(m_Theme.axis.lineWidth);
float xDataHig = GetDataHig(xAxis, xValue, grid.runtimeWidth);
float yDataHig = GetDataHig(yAxis, yValue, grid.runtimeHeight);
var pos = new Vector3(pX + xDataHig, pY + yDataHig);
if (!IsInGrid(grid, pos))
{
continue;
}
serie.dataPoints.Add(pos);
serieData.runtimePosition = pos;
var datas = serieData.data;
float symbolSize = 0;
if (serie.highlighted || serieData.highlighted)
{
symbolSize = symbol.GetSelectedSize(datas, m_Theme.serie.scatterSymbolSelectedSize);
}
else
{
symbolSize = symbol.GetSize(datas, m_Theme.serie.scatterSymbolSize);
}
symbolSize *= rate;
if (symbolSize > 100)
{
symbolSize = 100;
}
if (serie.type == SerieType.EffectScatter)
{
for (int count = 0; count < symbol.animationSize.Count; count++)
{
var nowSize = symbol.animationSize[count];
color.a = (byte)(255 * (symbolSize - nowSize) / symbolSize);
DrawSymbol(vh, symbol.type, nowSize, symbolBorder, pos, color, toColor, symbol.gap, cornerRadius);
}
RefreshPainter(serie);
}
else
{
DrawSymbol(vh, symbol.type, symbolSize, symbolBorder, pos, color, toColor, symbol.gap, cornerRadius);
}
}
if (!serie.animation.IsFinish())
{
serie.animation.CheckProgress(1);
m_IsPlayingAnimation = true;
RefreshPainter(serie);
}
if (dataChanging)
{
RefreshPainter(serie);
}
}
protected void DrawCandlestickSerie(VertexHelper vh, int colorIndex, Serie serie)
{
if (!IsActive(serie.index))
{
return;
}
if (serie.animation.HasFadeOut())
{
return;
}
var yAxis = m_YAxes[serie.yAxisIndex];
var xAxis = m_XAxes[serie.xAxisIndex];
var grid = GetSerieGridOrDefault(serie);
var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
var showData = serie.GetDataList(dataZoom);
float categoryWidth = AxisHelper.GetDataWidth(xAxis, grid.runtimeWidth, showData.Count, dataZoom);
float barWidth = serie.GetBarWidth(categoryWidth);
float space = (categoryWidth - barWidth) / 2;
int maxCount = serie.maxShow > 0
? (serie.maxShow > showData.Count ? showData.Count : serie.maxShow)
: showData.Count;
bool dataChanging = false;
float dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
double yMinValue = yAxis.GetCurrMinValue(dataChangeDuration);
double yMaxValue = yAxis.GetCurrMaxValue(dataChangeDuration);
var isAllBarEnd = true;
var isYAxis = false;
for (int i = serie.minShow; i < maxCount; i++)
{
var serieData = showData[i];
if (serie.IsIgnoreValue(serieData))
{
serie.dataPoints.Add(Vector3.zero);
continue;
}
var highlight = (tooltip.show && tooltip.IsSelected(i)) ||
serie.data[i].highlighted ||
serie.highlighted;
var itemStyle = SerieHelper.GetItemStyle(serie, serieData, highlight);
var open = serieData.GetCurrData(0, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue);
var close = serieData.GetCurrData(1, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue);
var lowest = serieData.GetCurrData(2, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue);
var heighest = serieData.GetCurrData(3, dataChangeDuration, yAxis.inverse, yMinValue, yMaxValue);
var isRise = yAxis.inverse ? close <open : close> open;
var borderWidth = open == 0 ? 0f
: (itemStyle.runtimeBorderWidth == 0 ? m_Theme.serie.candlestickBorderWidth
: itemStyle.runtimeBorderWidth);
if (serieData.IsDataChanged())
{
dataChanging = true;
}
float pX = grid.runtimeX + i * categoryWidth;
float zeroY = grid.runtimeY + yAxis.runtimeZeroYOffset;
if (!xAxis.boundaryGap)
{
pX -= categoryWidth / 2;
}
float pY = zeroY;
var barHig = 0f;
double valueTotal = yMaxValue - yMinValue;
var minCut = (yMinValue > 0 ? yMinValue : 0);
if (valueTotal != 0)
{
barHig = (float)((close - open) / valueTotal * grid.runtimeHeight);
pY += (float)((open - minCut) / valueTotal * grid.runtimeHeight);
}
serieData.runtimeStackHig = barHig;
var isBarEnd = false;
float currHig = Internal_CheckBarAnimation(serie, i, barHig, out isBarEnd);
if (!isBarEnd)
{
isAllBarEnd = false;
}
Vector3 plb, plt, prt, prb, top;
plb = new Vector3(pX + space + borderWidth, pY + borderWidth);
plt = new Vector3(pX + space + borderWidth, pY + currHig - borderWidth);
prt = new Vector3(pX + space + barWidth - borderWidth, pY + currHig - borderWidth);
prb = new Vector3(pX + space + barWidth - borderWidth, pY + borderWidth);
top = new Vector3(pX + space + barWidth / 2, pY + currHig - borderWidth);
if (serie.clip)
{
plb = ClampInGrid(grid, plb);
plt = ClampInGrid(grid, plt);
prt = ClampInGrid(grid, prt);
prb = ClampInGrid(grid, prb);
top = ClampInGrid(grid, top);
}
serie.dataPoints.Add(top);
var areaColor = isRise
? itemStyle.GetColor(m_Theme.serie.candlestickColor)
: itemStyle.GetColor0(m_Theme.serie.candlestickColor0);
var borderColor = isRise
? itemStyle.GetBorderColor(m_Theme.serie.candlestickBorderColor)
: itemStyle.GetBorderColor0(m_Theme.serie.candlestickBorderColor0);
var itemWidth = Mathf.Abs(prt.x - plb.x);
var itemHeight = Mathf.Abs(plt.y - prb.y);
var center = new Vector3((plb.x + prt.x) / 2, (plt.y + prb.y) / 2);
var lowPos = new Vector3(center.x, zeroY + (float)((lowest - minCut) / valueTotal * grid.runtimeHeight));
var heighPos = new Vector3(center.x, zeroY + (float)((heighest - minCut) / valueTotal * grid.runtimeHeight));
var openCenterPos = new Vector3(center.x, prb.y);
var closeCenterPos = new Vector3(center.x, prt.y);
if (barWidth > 2f * borderWidth)
{
if (itemWidth > 0 && itemHeight > 0)
{
if (ItemStyleHelper.IsNeedCorner(itemStyle))
{
UGL.DrawRoundRectangle(vh, center, itemWidth, itemHeight, areaColor, areaColor, 0,
itemStyle.cornerRadius, isYAxis, 0.5f);
}
else
{
Internal_CheckClipAndDrawPolygon(vh, ref prb, ref plb, ref plt, ref prt, areaColor, areaColor,
serie.clip, grid);
}
UGL.DrawBorder(vh, center, itemWidth, itemHeight, 2 * borderWidth, borderColor, 0,
itemStyle.cornerRadius, isYAxis, 0.5f);
}
}
else
{
UGL.DrawLine(vh, openCenterPos, closeCenterPos, Mathf.Max(borderWidth, barWidth / 2), borderColor);
}
if (isRise)
{
UGL.DrawLine(vh, openCenterPos, lowPos, borderWidth, borderColor);
UGL.DrawLine(vh, closeCenterPos, heighPos, borderWidth, borderColor);
}
else
{
UGL.DrawLine(vh, closeCenterPos, lowPos, borderWidth, borderColor);
UGL.DrawLine(vh, openCenterPos, heighPos, borderWidth, borderColor);
}
}
if (isAllBarEnd)
{
serie.animation.AllBarEnd();
}
if (dataChanging)
{
RefreshPainter(serie);
}
}
private void DrawMarkLine(VertexHelper vh, Serie serie)
{
if (!serie.show || !serie.markLine.show)
{
return;
}
if (serie.markLine.data.Count == 0)
{
return;
}
var yAxis = chart.GetSerieYAxisOrDefault(serie);
var xAxis = chart.GetSerieXAxisOrDefault(serie);
var grid = chart.GetSerieGridOrDefault(serie);
var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, chart.dataZooms);
var animation = serie.markLine.animation;
var showData = serie.GetDataList(dataZoom);
var sp = Vector3.zero;
var ep = Vector3.zero;
var colorIndex = chart.GetLegendRealShowNameIndex(serie.name);
var serieColor = SerieHelper.GetLineColor(serie, chart.theme, colorIndex, false);
animation.InitProgress(1, 0, 1f);
ResetTempMarkLineGroupData(serie.markLine);
if (m_TempGroupData.Count > 0)
{
foreach (var kv in m_TempGroupData)
{
if (kv.Value.Count >= 2)
{
sp = GetSinglePos(xAxis, yAxis, grid, serie, dataZoom, kv.Value[0], showData.Count);
ep = GetSinglePos(xAxis, yAxis, grid, serie, dataZoom, kv.Value[1], showData.Count);
kv.Value[0].runtimeStartPosition = sp;
kv.Value[1].runtimeEndPosition = ep;
DrawMakLineData(vh, kv.Value[0], animation, serie, grid, serieColor, sp, ep);
}
}
}
foreach (var data in serie.markLine.data)
{
if (data.group != 0)
{
continue;
}
switch (data.type)
{
case MarkLineType.Min:
data.runtimeValue = SerieHelper.GetMinData(serie, data.dimension, dataZoom);
GetStartEndPos(xAxis, yAxis, grid, data.runtimeValue, ref sp, ref ep);
break;
case MarkLineType.Max:
data.runtimeValue = SerieHelper.GetMaxData(serie, data.dimension, dataZoom);
GetStartEndPos(xAxis, yAxis, grid, data.runtimeValue, ref sp, ref ep);
break;
case MarkLineType.Average:
data.runtimeValue = SerieHelper.GetAverageData(serie, data.dimension, dataZoom);
GetStartEndPos(xAxis, yAxis, grid, data.runtimeValue, ref sp, ref ep);
break;
case MarkLineType.Median:
data.runtimeValue = SerieHelper.GetMedianData(serie, data.dimension, dataZoom);
GetStartEndPos(xAxis, yAxis, grid, data.runtimeValue, ref sp, ref ep);
break;
case MarkLineType.None:
if (data.xPosition != 0)
{
data.runtimeValue = data.xPosition;
var pX = grid.runtimeX + data.xPosition;
sp = new Vector3(pX, grid.runtimeY);
ep = new Vector3(pX, grid.runtimeY + grid.runtimeHeight);
}
else if (data.yPosition != 0)
{
data.runtimeValue = data.yPosition;
var pY = grid.runtimeY + data.yPosition;
sp = new Vector3(grid.runtimeX, pY);
ep = new Vector3(grid.runtimeX + grid.runtimeWidth, pY);
}
else if (data.yValue != 0)
{
data.runtimeValue = data.yValue;
if (yAxis.IsCategory())
{
var pY = AxisHelper.GetAxisPosition(grid, yAxis, data.yValue, showData.Count, dataZoom);
sp = new Vector3(grid.runtimeX, pY);
ep = new Vector3(grid.runtimeX + grid.runtimeWidth, pY);
}
else
{
GetStartEndPos(xAxis, yAxis, grid, data.yValue, ref sp, ref ep);
}
}
else
{
data.runtimeValue = data.xValue;
if (xAxis.IsCategory())
{
var pX = AxisHelper.GetAxisPosition(grid, xAxis, data.xValue, showData.Count, dataZoom);
sp = new Vector3(pX, grid.runtimeY);
ep = new Vector3(pX, grid.runtimeY + grid.runtimeHeight);
}
else
{
GetStartEndPos(xAxis, yAxis, grid, data.xValue, ref sp, ref ep);
}
}
break;
default:
break;
}
data.runtimeStartPosition = sp;
data.runtimeEndPosition = ep;
DrawMakLineData(vh, data, animation, serie, grid, serieColor, sp, ep);
}
if (!animation.IsFinish())
{
animation.CheckProgress(1f);
chart.RefreshTopPainter();
}
}
protected void DrawYBarSerie(VertexHelper vh, Serie serie, int colorIndex)
{
if (!IsActive(serie.name))
{
return;
}
if (serie.animation.HasFadeOut())
{
return;
}
var xAxis = m_XAxes[serie.xAxisIndex];
var yAxis = m_YAxes[serie.yAxisIndex];
var grid = GetSerieGridOrDefault(serie);
var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(yAxis, dataZooms);
var showData = serie.GetDataList(dataZoom);
float categoryWidth = AxisHelper.GetDataWidth(yAxis, grid.runtimeHeight, showData.Count, dataZoom);
float barGap = Internal_GetBarGap(SerieType.Bar);
float totalBarWidth = Internal_GetBarTotalWidth(categoryWidth, barGap, SerieType.Bar);
float barWidth = serie.GetBarWidth(categoryWidth);
float offset = (categoryWidth - totalBarWidth) / 2;
float barGapWidth = barWidth + barWidth * barGap;
float space = serie.barGap == -1 ? offset : offset + Internal_GetBarIndex(serie, SerieType.Bar) * barGapWidth;
var isStack = SeriesHelper.IsStack(m_Series, serie.stack, SerieType.Bar);
m_StackSerieData.Clear();
if (isStack)
{
SeriesHelper.UpdateStackDataList(m_Series, serie, dataZoom, m_StackSerieData);
}
int maxCount = serie.maxShow > 0 ?
(serie.maxShow > showData.Count ? showData.Count : serie.maxShow)
: showData.Count;
var isPercentStack = SeriesHelper.IsPercentStack(m_Series, serie.stack, SerieType.Bar);
bool dataChanging = false;
float dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
double xMinValue = xAxis.GetCurrMinValue(dataChangeDuration);
double xMaxValue = xAxis.GetCurrMaxValue(dataChangeDuration);
var isAllBarEnd = true;
for (int i = serie.minShow; i < maxCount; i++)
{
var serieData = showData[i];
if (!serieData.show || serie.IsIgnoreValue(serieData))
{
serie.dataPoints.Add(Vector3.zero);
continue;
}
var highlight = (tooltip.show && tooltip.IsSelected(i)) ||
serie.data[i].highlighted ||
serie.highlighted;
var itemStyle = SerieHelper.GetItemStyle(serie, serieData, highlight);
serieData.canShowLabel = true;
double value = showData[i].GetCurrData(1, dataChangeDuration, xAxis.inverse, xMinValue, xMaxValue);
float borderWidth = value == 0 ? 0 : itemStyle.runtimeBorderWidth;
if (showData[i].IsDataChanged())
{
dataChanging = true;
}
float axisLineWidth = value == 0 ? 0
: ((value < 0 ? -1 : 1) * yAxis.axisLine.GetWidth(m_Theme.axis.lineWidth));
float pY = grid.runtimeY + i * categoryWidth;
if (!yAxis.boundaryGap)
{
pY -= categoryWidth / 2;
}
float pX = grid.runtimeX + xAxis.runtimeZeroXOffset + axisLineWidth;
if (isStack)
{
for (int n = 0; n < m_StackSerieData.Count - 1; n++)
{
pX += m_StackSerieData[n][i].runtimeStackHig;
}
}
var barHig = 0f;
double valueTotal = 0f;
if (isPercentStack)
{
valueTotal = Internal_GetBarSameStackTotalValue(serie.stack, i, SerieType.Bar);
barHig = valueTotal != 0 ? (float)((value / valueTotal * grid.runtimeWidth)) : 0;
}
else
{
if (yAxis.IsLog())
{
int minIndex = xAxis.runtimeMinLogIndex;
float nowIndex = xAxis.GetLogValue(value);
barHig = (nowIndex - minIndex) / xAxis.splitNumber * grid.runtimeWidth;
}
else
{
valueTotal = xMaxValue - xMinValue;
if (valueTotal != 0)
{
barHig = (float)((xMinValue > 0 ? value - xMinValue : value)
/ valueTotal * grid.runtimeWidth);
}
}
}
serieData.runtimeStackHig = barHig;
var isBarEnd = false;
float currHig = Internal_CheckBarAnimation(serie, i, barHig, out isBarEnd);
if (!isBarEnd)
{
isAllBarEnd = false;
}
Vector3 plt, prt, prb, plb, top;
if (value < 0)
{
plt = new Vector3(pX - borderWidth, pY + space + barWidth - borderWidth);
prt = new Vector3(pX + currHig + borderWidth, pY + space + barWidth - borderWidth);
prb = new Vector3(pX + currHig + borderWidth, pY + space + borderWidth);
plb = new Vector3(pX - borderWidth, pY + space + borderWidth);
}
else
{
plt = new Vector3(pX + borderWidth, pY + space + barWidth - borderWidth);
prt = new Vector3(pX + currHig - borderWidth, pY + space + barWidth - borderWidth);
prb = new Vector3(pX + currHig - borderWidth, pY + space + borderWidth);
plb = new Vector3(pX + borderWidth, pY + space + borderWidth);
}
top = new Vector3(pX + currHig - borderWidth, pY + space + barWidth / 2);
if (serie.clip)
{
plt = ClampInGrid(grid, plt);
prt = ClampInGrid(grid, prt);
prb = ClampInGrid(grid, prb);
plb = ClampInGrid(grid, plb);
top = ClampInGrid(grid, top);
}
serie.dataPoints.Add(top);
if (serie.show)
{
switch (serie.barType)
{
case BarType.Normal:
DrawNormalBar(vh, serie, serieData, itemStyle, colorIndex, highlight, space, barWidth,
pX, pY, plb, plt, prt, prb, true, grid);
break;
case BarType.Zebra:
DrawZebraBar(vh, serie, serieData, itemStyle, colorIndex, highlight, space, barWidth,
pX, pY, plb, plt, prt, prb, true, grid);
break;
case BarType.Capsule:
DrawCapsuleBar(vh, serie, serieData, itemStyle, colorIndex, highlight, space, barWidth,
pX, pY, plb, plt, prt, prb, true, grid);
break;
}
}
}
if (isAllBarEnd)
{
serie.animation.AllBarEnd();
}
if (dataChanging)
{
RefreshPainter(serie);
}
}