public void DrawClipTriangle(VertexHelper vh, Vector3 p1, Vector3 p2, Vector3 p3, Color32 color, Color32 color2, Color32 color3, bool clip, GridCoord grid) { if (!IsInChart(p1) || !IsInChart(p2) || !IsInChart(p3)) { return; } if (!clip || (clip && (grid.Contains(p1) || grid.Contains(p2) || grid.Contains(p3)))) { UGL.DrawTriangle(vh, p1, p2, p3, color, color2, color3); } }
public void DrawClipLine(VertexHelper vh, Vector3 p1, Vector3 p2, float size, Color32 color, bool clip, GridCoord grid) { if (!IsInChart(p1) || !IsInChart(p2)) { return; } if (!clip || (clip && (grid.Contains(p1) || grid.Contains(p2)))) { UGL.DrawLine(vh, p1, p2, size, color); } }
public Vector3 ClampInGrid(GridCoord grid, Vector3 pos) { if (grid.Contains(pos)) { return(pos); } else { // var pos = new Vector3(pos.x, pos.y); if (pos.x < grid.context.x) { pos.x = grid.context.x; } if (pos.x > grid.context.x + grid.context.width) { pos.x = grid.context.x + grid.context.width; } if (pos.y < grid.context.y) { pos.y = grid.context.y; } if (pos.y > grid.context.y + grid.context.height) { pos.y = grid.context.y + grid.context.height; } return(pos); } }
public void DrawClipPolygon(VertexHelper vh, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4, Color32 startColor, Color32 toColor, bool clip, GridCoord grid) { ClampInChart(ref p1); ClampInChart(ref p2); ClampInChart(ref p3); ClampInChart(ref p4); if (clip) { p1 = ClampInGrid(grid, p1); p2 = ClampInGrid(grid, p2); p3 = ClampInGrid(grid, p3); p4 = ClampInGrid(grid, p4); } if (!clip || (clip && (grid.Contains(p1) && grid.Contains(p2) && grid.Contains(p3) && grid.Contains(p4)))) { UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, startColor, toColor); } }
public void DrawClipPolygon(VertexHelper vh, Vector3 p, float radius, Color32 color, bool clip, bool vertical, GridCoord grid) { if (!IsInChart(p)) { return; } if (!clip || (clip && (grid.Contains(p)))) { UGL.DrawSquare(vh, p, radius, color); } }
public void DrawClipSymbol(VertexHelper vh, SymbolType type, float symbolSize, float tickness, Vector3 pos, Color32 color, Color32 toColor, Color32 emptyColor, Color32 borderColor, float gap, bool clip, float[] cornerRadius, GridCoord grid, Vector3 startPos) { if (!IsInChart(pos)) { return; } if (!clip || (clip && (grid.Contains(pos)))) { DrawSymbol(vh, type, symbolSize, tickness, pos, color, toColor, emptyColor, borderColor, gap, cornerRadius, startPos); } }
private void DrawLineSerie(VertexHelper vh, Line serie) { if (!serie.show) { return; } if (serie.animation.HasFadeOut()) { return; } Axis axis; Axis relativedAxis; var isY = chart.GetSerieGridCoordAxis(serie, out axis, out relativedAxis); if (axis == null) { return; } if (relativedAxis == null) { return; } m_SerieGrid = chart.GetChartComponent <GridCoord>(axis.gridIndex); if (m_SerieGrid == null) { return; } if (m_EndLabel != null && !m_SerieGrid.context.endLabelList.Contains(m_EndLabel)) { m_SerieGrid.context.endLabelList.Add(m_EndLabel); } var visualMap = chart.GetVisualMapOfSerie(serie); var dataZoom = chart.GetDataZoomOfAxis(axis); var showData = serie.GetDataList(dataZoom); if (showData.Count <= 0) { return; } var axisLength = isY ? m_SerieGrid.context.height : m_SerieGrid.context.width; var scaleWid = AxisHelper.GetDataWidth(axis, axisLength, showData.Count, dataZoom); int maxCount = serie.maxShow > 0 ? (serie.maxShow > showData.Count ? showData.Count : serie.maxShow) : showData.Count; int rate = LineHelper.GetDataAverageRate(serie, m_SerieGrid, maxCount, false); var totalAverage = serie.sampleAverage > 0 ? serie.sampleAverage : DataHelper.DataAverage(ref showData, serie.sampleType, serie.minShow, maxCount, rate); var dataChanging = false; var dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); var interacting = false; var lineWidth = LineHelper.GetLineWidth(ref interacting, serie, chart.theme.serie.lineWidth); axis.context.scaleWidth = scaleWid; serie.containerIndex = m_SerieGrid.index; serie.containterInstanceId = m_SerieGrid.instanceId; Serie lastSerie = null; var isStack = SeriesHelper.IsStack <Line>(chart.series, serie.stack); if (isStack) { lastSerie = SeriesHelper.GetLastStackSerie(chart.series, serie); SeriesHelper.UpdateStackDataList(chart.series, serie, dataZoom, m_StackSerieData); } var lp = Vector3.zero; for (int i = serie.minShow; i < maxCount; i += rate) { var serieData = showData[i]; var isIgnore = serie.IsIgnoreValue(serieData); if (isIgnore) { serieData.context.stackHeight = 0; serieData.context.position = Vector3.zero; if (serie.ignoreLineBreak && serie.context.dataIgnores.Count > 0) { serie.context.dataIgnores[serie.context.dataIgnores.Count - 1] = true; } } else { var np = Vector3.zero; var xValue = axis.IsCategory() ? i : serieData.GetData(0, axis.inverse); var relativedValue = DataHelper.SampleValue(ref showData, serie.sampleType, rate, serie.minShow, maxCount, totalAverage, i, dataChangeDuration, ref dataChanging, relativedAxis); serieData.context.stackHeight = GetDataPoint(isY, axis, relativedAxis, m_SerieGrid, xValue, relativedValue, i, scaleWid, isStack, ref np); serieData.context.isClip = false; if (serie.clip && !m_SerieGrid.Contains(np)) { if (m_SerieGrid.BoundaryPoint(lp, np, ref np)) { serieData.context.isClip = true; } } serie.context.dataIgnores.Add(false); serieData.context.position = np; serie.context.dataPoints.Add(np); lp = np; } } if (dataChanging || interacting) { chart.RefreshPainter(serie); } if (serie.context.dataPoints.Count <= 0) { return; } serie.animation.InitProgress(serie.context.dataPoints, isY); VisualMapHelper.AutoSetLineMinMax(visualMap, serie, isY, axis, relativedAxis); LineHelper.UpdateSerieDrawPoints(serie, chart.settings, chart.theme, visualMap, lineWidth, isY); LineHelper.DrawSerieLineArea(vh, serie, lastSerie, chart.theme, visualMap, isY, axis, relativedAxis, m_SerieGrid); LineHelper.DrawSerieLine(vh, chart.theme, serie, visualMap, m_SerieGrid, axis, relativedAxis, lineWidth); serie.context.vertCount = vh.currentVertCount; if (!serie.animation.IsFinish()) { serie.animation.CheckProgress(); serie.animation.CheckSymbol(serie.symbol.GetSize(null, chart.theme.serie.lineSymbolSize)); chart.RefreshPainter(serie); } }
protected virtual void DrawScatterSerie(VertexHelper vh, BaseScatter serie) { if (serie.animation.HasFadeOut()) { return; } if (!serie.show) { return; } XAxis xAxis; if (!chart.TryGetChartComponent <XAxis>(out xAxis, serie.xAxisIndex)) { return; } YAxis yAxis; if (!chart.TryGetChartComponent <YAxis>(out yAxis, serie.yAxisIndex)) { return; } if (!chart.TryGetChartComponent <GridCoord>(out m_Grid, xAxis.gridIndex)) { return; } DataZoom xDataZoom; DataZoom yDataZoom; chart.GetDataZoomOfSerie(serie, out xDataZoom, out yDataZoom); var theme = chart.theme; int maxCount = serie.maxShow > 0 ? (serie.maxShow > serie.dataCount ? serie.dataCount : serie.maxShow) : serie.dataCount; serie.animation.InitProgress(0, 1); var rate = serie.animation.GetCurrRate(); var dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); var dataChanging = false; var interacting = false; var dataList = serie.GetDataList(xDataZoom); var isEffectScatter = serie is EffectScatter; var colorIndex = serie.context.colorIndex; serie.containerIndex = m_Grid.index; serie.containterInstanceId = m_Grid.instanceId; foreach (var serieData in dataList) { var symbol = SerieHelper.GetSerieSymbol(serie, serieData); if (!symbol.ShowSymbol(serieData.index, maxCount)) { continue; } var highlight = serie.highlight || serieData.context.highlight; var color = SerieHelper.GetItemColor(serie, serieData, theme, colorIndex, highlight); var toColor = SerieHelper.GetItemToColor(serie, serieData, theme, colorIndex, highlight); var emptyColor = SerieHelper.GetItemBackgroundColor(serie, serieData, theme, colorIndex, highlight, false); var symbolBorder = SerieHelper.GetSymbolBorder(serie, serieData, theme, highlight); var borderColor = SerieHelper.GetSymbolBorderColor(serie, serieData, 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 = m_Grid.context.x + xAxis.axisLine.GetWidth(theme.axis.lineWidth); float pY = m_Grid.context.y + yAxis.axisLine.GetWidth(theme.axis.lineWidth); float xDataHig = GetDataHig(xAxis, xValue, m_Grid.context.width); float yDataHig = GetDataHig(yAxis, yValue, m_Grid.context.height); var pos = new Vector3(pX + xDataHig, pY + yDataHig); if (!m_Grid.Contains(pos)) { continue; } serie.context.dataPoints.Add(pos); serieData.context.position = pos; var datas = serieData.data; var symbolSize = serie.highlight || serieData.context.highlight ? theme.serie.scatterSymbolSelectedSize : theme.serie.scatterSymbolSize; if (!serieData.interact.TryGetValue(ref symbolSize, ref interacting)) { symbolSize = highlight ? symbol.GetSelectedSize(serieData.data, symbolSize) : symbol.GetSize(serieData.data, symbolSize); serieData.interact.SetValue(ref interacting, symbolSize); } symbolSize *= rate; if (isEffectScatter) { for (int count = 0; count < symbol.animationSize.Count; count++) { var nowSize = symbol.animationSize[count]; color.a = (byte)(255 * (symbolSize - nowSize) / symbolSize); chart.DrawSymbol(vh, symbol.type, nowSize, symbolBorder, pos, color, toColor, emptyColor, borderColor, symbol.gap, cornerRadius); } chart.RefreshPainter(serie); } else { if (symbolSize > 100) { symbolSize = 100; } chart.DrawSymbol(vh, symbol.type, symbolSize, symbolBorder, pos, color, toColor, emptyColor, borderColor, symbol.gap, cornerRadius); } } if (!serie.animation.IsFinish()) { serie.animation.CheckProgress(1); chart.RefreshPainter(serie); } if (dataChanging || interacting) { chart.RefreshPainter(serie); } }
private void DrawBarSerie(VertexHelper vh, Bar serie, int colorIndex) { if (!serie.show || serie.animation.HasFadeOut()) { return; } Axis axis; Axis relativedAxis; var isY = chart.GetSerieGridCoordAxis(serie, out axis, out relativedAxis); m_SerieGrid = chart.GetChartComponent <GridCoord>(axis.gridIndex); if (axis == null) { return; } if (relativedAxis == null) { return; } if (m_SerieGrid == null) { return; } var dataZoom = chart.GetDataZoomOfAxis(axis); var showData = serie.GetDataList(dataZoom); if (showData.Count <= 0) { return; } var axisLength = isY ? m_SerieGrid.context.height : m_SerieGrid.context.width; var relativedAxisLength = isY ? m_SerieGrid.context.width : m_SerieGrid.context.height; var axisXY = isY ? m_SerieGrid.context.y : m_SerieGrid.context.x; var isStack = SeriesHelper.IsStack <Bar>(chart.series, serie.stack); if (isStack) { SeriesHelper.UpdateStackDataList(chart.series, serie, dataZoom, m_StackSerieData); } var barCount = chart.GetSerieBarRealCount <Bar>(); float categoryWidth = AxisHelper.GetDataWidth(axis, axisLength, showData.Count, dataZoom); float barGap = chart.GetSerieBarGap <Bar>(); float totalBarWidth = chart.GetSerieTotalWidth <Bar>(categoryWidth, barGap, barCount); float barWidth = serie.GetBarWidth(categoryWidth, barCount); float offset = (categoryWidth - totalBarWidth) * 0.5f; var serieReadIndex = chart.GetSerieIndexIfStack <Bar>(serie); float gap = serie.barGap == -1 ? offset : offset + chart.GetSerieTotalGap <Bar>(categoryWidth, barGap, serieReadIndex); int maxCount = serie.maxShow > 0 ? (serie.maxShow > showData.Count ? showData.Count : serie.maxShow) : showData.Count; var isPercentStack = SeriesHelper.IsPercentStack <Bar>(chart.series, serie.stack); bool dataChanging = false; float dataChangeDuration = serie.animation.GetUpdateAnimationDuration(); double yMinValue = relativedAxis.context.minValue; double yMaxValue = relativedAxis.context.maxValue; var areaColor = ColorUtil.clearColor32; var areaToColor = ColorUtil.clearColor32; var interacting = false; serie.containerIndex = m_SerieGrid.index; serie.containterInstanceId = m_SerieGrid.instanceId; serie.animation.InitProgress(axisXY, axisXY + axisLength); for (int i = serie.minShow; i < maxCount; i++) { var serieData = showData[i]; serieData.index = i; if (!serieData.show || serie.IsIgnoreValue(serieData)) { serie.context.dataPoints.Add(Vector3.zero); continue; } if (serieData.IsDataChanged()) { dataChanging = true; } var highlight = serieData.context.highlight || serie.highlight; var itemStyle = SerieHelper.GetItemStyle(serie, serieData, highlight); var value = axis.IsCategory() ? i : serieData.GetData(0, axis.inverse); var relativedValue = serieData.GetCurrData(1, dataChangeDuration, relativedAxis.inverse, yMinValue, yMaxValue); var borderWidth = relativedValue == 0 ? 0 : itemStyle.runtimeBorderWidth; var borderGap = relativedValue == 0 ? 0 : itemStyle.borderGap; var borderGapAndWidth = borderWidth + borderGap; if (!serieData.interact.TryGetColor(ref areaColor, ref areaToColor, ref interacting)) { areaColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, colorIndex, highlight); areaToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, colorIndex, highlight); serieData.interact.SetColor(ref interacting, areaColor, areaToColor); } var pX = 0f; var pY = 0f; UpdateXYPosition(m_SerieGrid, isY, axis, relativedAxis, i, categoryWidth, barWidth, isStack, value, ref pX, ref pY); var barHig = 0f; if (isPercentStack) { var valueTotal = chart.GetSerieSameStackTotalValue <Bar>(serie.stack, i); barHig = valueTotal != 0 ? (float)(relativedValue / valueTotal * relativedAxisLength) : 0; } else { barHig = AxisHelper.GetAxisValueLength(m_SerieGrid, relativedAxis, categoryWidth, relativedValue); } float currHig = AnimationStyleHelper.CheckDataAnimation(chart, serie, i, barHig); Vector3 plb, plt, prt, prb, top; UpdateRectPosition(m_SerieGrid, isY, relativedValue, pX, pY, gap, borderWidth, barWidth, currHig, out plb, out plt, out prt, out prb, out top); serieData.context.stackHeight = barHig; serieData.context.position = top; serieData.context.rect = Rect.MinMaxRect(plb.x + borderGapAndWidth, plb.y + borderGapAndWidth, prt.x - borderGapAndWidth, prt.y - borderGapAndWidth); serieData.context.backgroundRect = isY ? Rect.MinMaxRect(m_SerieGrid.context.x, plb.y, m_SerieGrid.context.x + relativedAxisLength, prt.y) : Rect.MinMaxRect(plb.x, m_SerieGrid.context.y, prb.x, m_SerieGrid.context.y + relativedAxisLength); if (!serie.clip || (serie.clip && m_SerieGrid.Contains(top))) { serie.context.dataPoints.Add(top); } else { continue; } if (serie.show && currHig != 0 && !serie.placeHolder) { switch (serie.barType) { case BarType.Normal: case BarType.Capsule: DrawNormalBar(vh, serie, serieData, itemStyle, colorIndex, highlight, gap, barWidth, pX, pY, plb, plt, prt, prb, isY, m_SerieGrid, axis, areaColor, areaToColor, relativedValue); break; case BarType.Zebra: DrawZebraBar(vh, serie, serieData, itemStyle, colorIndex, highlight, gap, barWidth, pX, pY, plb, plt, prt, prb, isY, m_SerieGrid, axis, areaColor, areaToColor); break; } } if (serie.animation.CheckDetailBreak(top, isY)) { break; } } if (!serie.animation.IsFinish()) { serie.animation.CheckProgress(); chart.RefreshPainter(serie); } if (dataChanging || interacting) { chart.RefreshPainter(serie); } }