private void DrawLineStyle(VertexHelper vh, Serie serie)
{
if (serie.gaugeType != GaugeType.Pointer)
{
return;
}
if (!serie.gaugeAxis.show || !serie.gaugeAxis.splitLine.show)
{
return;
}
if (serie.splitNumber <= 0)
{
return;
}
var splitLine = serie.gaugeAxis.splitLine;
var totalAngle = serie.endAngle - serie.startAngle;
var diffAngle = totalAngle / serie.splitNumber;
var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth);
var splitLineWidth = splitLine.GetWidth(chart.theme.gauge.splitLineWidth);
var splitLineLength = splitLine.GetLength(chart.theme.gauge.splitLineLength);
var outsideRadius = serie.runtimeInsideRadius + lineWidth;
var insideRadius = outsideRadius - splitLineLength;
for (int i = 0; i < serie.splitNumber + 1; i++)
{
var angle = serie.startAngle + i * diffAngle;
var lineColor = serie.gaugeAxis.GetSplitLineColor(chart.theme.gauge.splitLineColor, serie.index, angle);
var p1 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, insideRadius);
var p2 = ChartHelper.GetPosition(serie.runtimeCenterPos, angle, outsideRadius);
UGL.DrawLine(vh, p1, p2, splitLineWidth, lineColor);
}
}
private void DrawNormalBar(VertexHelper vh, Serie serie, SerieData serieData, ItemStyle itemStyle, int colorIndex,
bool highlight, float gap, float barWidth, float pX, float pY, Vector3 plb, Vector3 plt, Vector3 prt,
Vector3 prb, bool isYAxis, GridCoord grid, Axis axis, Color32 areaColor, Color32 areaToColor, double value)
{
var borderWidth = itemStyle.runtimeBorderWidth;
var backgroundColor = SerieHelper.GetItemBackgroundColor(serie, serieData, chart.theme, colorIndex, highlight, false);
var cornerRadius = serie.barType == BarType.Capsule && !itemStyle.IsNeedCorner() ?
m_CapusleDefaultCornerRadius :
itemStyle.cornerRadius;
var invert = value < 0;
if (!ChartHelper.IsClearColor(backgroundColor))
{
UGL.DrawRoundRectangle(vh, serieData.context.backgroundRect, backgroundColor, backgroundColor, 0,
cornerRadius, isYAxis, chart.settings.cicleSmoothness, invert);
}
UGL.DrawRoundRectangle(vh, serieData.context.rect, areaColor, areaToColor, 0,
cornerRadius, isYAxis, chart.settings.cicleSmoothness, invert);
if (serie.barType == BarType.Capsule)
{
UGL.DrawBorder(vh, serieData.context.backgroundRect, borderWidth, itemStyle.borderColor,
0, cornerRadius, isYAxis, chart.settings.cicleSmoothness, invert, -borderWidth);
}
else
{
UGL.DrawBorder(vh, serieData.context.rect, borderWidth, itemStyle.borderColor,
0, cornerRadius, isYAxis, chart.settings.cicleSmoothness, invert, itemStyle.borderGap);
}
}
void Awake()
{
chart = gameObject.GetComponent <LineChart>();
if (chart == null)
{
return;
}
chart.onDraw = delegate(VertexHelper vh) { };
// or
chart.onDrawBeforeSerie = delegate(VertexHelper vh, Serie serie) { };
// or
chart.onDrawAfterSerie = delegate(VertexHelper vh, Serie serie)
{
if (serie.index != 0)
{
return;
}
var dataPoints = serie.context.dataPoints;
if (dataPoints.Count > 0)
{
var pos = dataPoints[3];
var grid = chart.GetChartComponent <GridCoord>();
var zeroPos = new Vector3(grid.context.x, grid.context.y);
var startPos = new Vector3(pos.x, zeroPos.y);
var endPos = new Vector3(pos.x, zeroPos.y + grid.context.height);
UGL.DrawLine(vh, startPos, endPos, chart.theme.serie.lineWidth, Color.blue);
UGL.DrawCricle(vh, pos, 5, Color.blue);
}
};
// or
chart.onDrawTop = delegate(VertexHelper vh) { };
}
private void DrawZebraBar(VertexHelper vh, Serie serie, SerieData serieData, ItemStyle itemStyle, int colorIndex,
bool highlight, float gap, float barWidth, float pX, float pY, Vector3 plb, Vector3 plt, Vector3 prt,
Vector3 prb, bool isYAxis, GridCoord grid, Axis axis, Color32 barColor, Color32 barToColor)
{
var backgroundColor = SerieHelper.GetItemBackgroundColor(serie, serieData, chart.theme, colorIndex, highlight, false);
if (!ChartHelper.IsClearColor(backgroundColor))
{
UGL.DrawRoundRectangle(vh, serieData.context.backgroundRect, backgroundColor, backgroundColor, 0,
null, isYAxis, chart.settings.cicleSmoothness, false);
}
if (isYAxis)
{
plt = (plb + plt) / 2;
prt = (prt + prb) / 2;
chart.DrawClipZebraLine(vh, plt, prt, barWidth / 2, serie.barZebraWidth, serie.barZebraGap,
barColor, barToColor, serie.clip, grid, grid.context.width);
}
else
{
plb = (prb + plb) / 2;
plt = (plt + prt) / 2;
chart.DrawClipZebraLine(vh, plb, plt, barWidth / 2, serie.barZebraWidth, serie.barZebraGap,
barColor, barToColor, serie.clip, grid, grid.context.height);
}
}
public void DrawClipZebraLine(VertexHelper vh, Vector3 p1, Vector3 p2, float size, float zebraWidth,
float zebraGap, Color32 color, Color32 toColor, bool clip, GridCoord grid, float maxDistance)
{
ClampInChart(ref p1);
ClampInChart(ref p2);
UGL.DrawZebraLine(vh, p1, p2, size, zebraWidth, zebraGap, color, toColor, maxDistance);
}
private void DrawVesselBackground(VertexHelper vh, Serie serie)
{
var vessel = chart.GetVessel(serie.vesselIndex);
if (vessel != null)
{
if (vessel.backgroundColor.a != 0)
{
switch (vessel.shape)
{
case Vessel.Shape.Circle:
var cenPos = vessel.runtimeCenterPos;
var radius = vessel.runtimeRadius;
UGL.DrawCricle(vh, cenPos, vessel.runtimeInnerRadius + vessel.gap, vessel.backgroundColor,
chart.settings.cicleSmoothness);
UGL.DrawDoughnut(vh, cenPos, vessel.runtimeInnerRadius, vessel.runtimeInnerRadius + vessel.gap,
vessel.backgroundColor, Color.clear, chart.settings.cicleSmoothness);
break;
case Vessel.Shape.Rect:
UGL.DrawRectangle(vh, vessel.runtimeCenterPos, vessel.runtimeWidth / 2, vessel.runtimeHeight / 2,
vessel.backgroundColor);
break;
default:
break;
}
}
}
}
private static void AddLineVertToVertexHelper(VertexHelper vh, Vector3 tp, Vector3 bp,
Color32 lineColor, bool visualMapGradient, bool lineStyleGradient, VisualMap visualMap,
LineStyle lineStyle, GridCoord grid, Axis axis, Axis relativedAxis, bool needTriangle,
bool lastIgnore, bool ignore)
{
if (lastIgnore && needTriangle)
{
UGL.AddVertToVertexHelper(vh, tp, bp, ColorUtil.clearColor32, true);
}
if (visualMapGradient)
{
var color1 = VisualMapHelper.GetLineGradientColor(visualMap, tp, grid, axis, relativedAxis, lineColor);
var color2 = VisualMapHelper.GetLineGradientColor(visualMap, bp, grid, axis, relativedAxis, lineColor);
UGL.AddVertToVertexHelper(vh, tp, bp, color1, color2, needTriangle);
}
else if (lineStyleGradient)
{
var color1 = VisualMapHelper.GetLineStyleGradientColor(lineStyle, tp, grid, axis, lineColor);
var color2 = VisualMapHelper.GetLineStyleGradientColor(lineStyle, bp, grid, axis, lineColor);
UGL.AddVertToVertexHelper(vh, tp, bp, color1, color2, needTriangle);
}
else
{
UGL.AddVertToVertexHelper(vh, tp, bp, lineColor, needTriangle);
}
if (lastIgnore && !needTriangle)
{
UGL.AddVertToVertexHelper(vh, tp, bp, ColorUtil.clearColor32, false);
}
if (ignore && needTriangle)
{
UGL.AddVertToVertexHelper(vh, tp, bp, ColorUtil.clearColor32, false);
}
}
private void DrawStageColor(VertexHelper vh, Serie serie)
{
if (serie.gaugeType != GaugeType.Pointer)
{
return;
}
if (!serie.gaugeAxis.show || !serie.gaugeAxis.axisLine.show)
{
return;
}
var totalAngle = serie.endAngle - serie.startAngle;
var tempStartAngle = serie.startAngle;
var tempEndAngle = serie.startAngle;
var lineWidth = serie.gaugeAxis.axisLine.GetWidth(chart.theme.gauge.lineWidth);
var outsideRadius = serie.runtimeInsideRadius + lineWidth;
serie.gaugeAxis.runtimeStageAngle.Clear();
for (int i = 0; i < serie.gaugeAxis.axisLine.stageColor.Count; i++)
{
var stageColor = serie.gaugeAxis.axisLine.stageColor[i];
tempEndAngle = serie.startAngle + totalAngle * stageColor.percent;
serie.gaugeAxis.runtimeStageAngle.Add(tempEndAngle);
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, serie.runtimeInsideRadius, outsideRadius,
stageColor.color, stageColor.color, Color.clear, tempStartAngle, tempEndAngle, 0, Color.clear,
0, chart.settings.cicleSmoothness);
tempStartAngle = tempEndAngle;
}
}
public static void DrawLineStyle(VertexHelper vh, LineStyle.Type lineType, float lineWidth,
Vector3 startPos, Vector3 endPos, Color32 color, Color32 toColor)
{
switch (lineType)
{
case LineStyle.Type.Dashed:
UGL.DrawDashLine(vh, startPos, endPos, lineWidth, color, toColor);
break;
case LineStyle.Type.Dotted:
UGL.DrawDotLine(vh, startPos, endPos, lineWidth, color, toColor);
break;
case LineStyle.Type.Solid:
UGL.DrawLine(vh, startPos, endPos, lineWidth, color, toColor);
break;
case LineStyle.Type.DashDot:
UGL.DrawDashDotLine(vh, startPos, endPos, lineWidth, color);
break;
case LineStyle.Type.DashDotDot:
UGL.DrawDashDotDotLine(vh, startPos, endPos, lineWidth, color);
break;
}
}
private void DrawPiecewiseVisualMap(VertexHelper vh, VisualMap visualMap)
{
var centerPos = chart.chartPosition + visualMap.location.GetPosition(chart.chartWidth, chart.chartHeight);
var pos1 = Vector3.zero;
var pos2 = Vector3.zero;
var dir = Vector3.zero;
var halfWid = visualMap.itemWidth / 2;
var halfHig = visualMap.itemHeight / 2;
switch (visualMap.orient)
{
case Orient.Horizonal:
for (int i = 0; i < visualMap.inRange.Count; i++)
{
var piece = visualMap.inRange[i];
}
break;
case Orient.Vertical:
var each = visualMap.itemHeight + visualMap.itemGap;
for (int i = 0; i < visualMap.inRange.Count; i++)
{
var piece = visualMap.inRange[i];
var pos = new Vector3(centerPos.x, centerPos.y - each * i);
UGL.DrawRectangle(vh, pos, halfWid, halfHig, piece.color);
}
break;
}
}
private void DrawPieCenter(VertexHelper vh, Serie serie, ItemStyle itemStyle, float insideRadius)
{
if (!ChartHelper.IsClearColor(itemStyle.centerColor))
{
var radius = insideRadius - itemStyle.centerGap;
UGL.DrawCricle(vh, serie.runtimeCenterPos, radius, itemStyle.centerColor, chart.settings.cicleSmoothness);
}
}
private void DrawPolar(VertexHelper vh, PolarCoord polar)
{
PolarHelper.UpdatePolarCenter(polar, chart.chartPosition, chart.chartWidth, chart.chartHeight);
if (!ChartHelper.IsClearColor(polar.backgroundColor))
{
UGL.DrawCricle(vh, polar.context.center, polar.context.radius, polar.backgroundColor);
}
}
private static void AddVertToVertexHelperWithLerpColor(VertexHelper vh, Vector3 tp, Vector3 bp,
Color32 color, Color32 toColor, bool isY, float min, float max, bool needTriangle)
{
var range = max - min;
var color1 = Color32.Lerp(color, toColor, ((isY ? tp.x : tp.y) - min) / range);
var color2 = Color32.Lerp(color, toColor, ((isY ? bp.x : bp.y) - min) / range);
UGL.AddVertToVertexHelper(vh, tp, bp, color1, color2, needTriangle);
}
private void DrawCirleVessel(VertexHelper vh, Vessel vessel)
{
var cenPos = vessel.runtimeCenterPos;
var radius = vessel.runtimeRadius;
var serie = SeriesHelper.GetSerieByVesselIndex(chart.series, vessel.index);
var vesselColor = VesselHelper.GetColor(vessel, serie, chart.theme, chart.m_LegendRealShowName);
UGL.DrawDoughnut(vh, cenPos, radius - vessel.shapeWidth, radius, vesselColor, Color.clear, chart.settings.cicleSmoothness);
}
private void Awake()
{
UGL.ProvideContentsManager();
foreach (var VARIABLE in containers)
{
UGL.contentsManager.CreateInstancePool(new InstancePool(VARIABLE.name, VARIABLE.prefab, VARIABLE.count));
}
}
private void DrawXAxisIndicator(VertexHelper vh, Tooltip tooltip, GridCoord grid)
{
var xAxes = chart.GetChartComponents <XAxis>();
var lineType = tooltip.lineStyle.GetType(chart.theme.tooltip.lineType);
var lineWidth = tooltip.lineStyle.GetWidth(chart.theme.tooltip.lineWidth);
foreach (var component in xAxes)
{
var xAxis = component as XAxis;
if (xAxis.gridIndex == grid.index)
{
if (double.IsInfinity(xAxis.context.pointerValue))
{
continue;
}
var dataZoom = chart.GetDataZoomOfAxis(xAxis);
int dataCount = chart.series.Count > 0 ? chart.series[0].GetDataList(dataZoom).Count : 0;
float splitWidth = AxisHelper.GetDataWidth(xAxis, grid.context.width, dataCount, dataZoom);
switch (tooltip.type)
{
case Tooltip.Type.Corss:
case Tooltip.Type.Line:
float pX = grid.context.x;
pX += xAxis.IsCategory() ?
(float)(xAxis.context.pointerValue * splitWidth + (xAxis.boundaryGap ? splitWidth / 2 : 0)) :
xAxis.GetDistance(xAxis.context.axisTooltipValue, grid.context.width);
Vector2 sp = new Vector2(pX, grid.context.y);
Vector2 ep = new Vector2(pX, grid.context.y + grid.context.height);
var lineColor = TooltipHelper.GetLineColor(tooltip, chart.theme);
ChartDrawer.DrawLineStyle(vh, lineType, lineWidth, sp, ep, lineColor);
if (tooltip.type == Tooltip.Type.Corss)
{
sp = new Vector2(grid.context.x, chart.pointerPos.y);
ep = new Vector2(grid.context.x + grid.context.width, chart.pointerPos.y);
ChartDrawer.DrawLineStyle(vh, lineType, lineWidth, sp, ep, lineColor);
}
break;
case Tooltip.Type.Shadow:
if (xAxis.IsCategory() && !double.IsInfinity(xAxis.context.pointerValue))
{
float tooltipSplitWid = splitWidth < 1 ? 1 : splitWidth;
pX = (float)(grid.context.x + splitWidth * xAxis.context.pointerValue -
(xAxis.boundaryGap ? 0 : splitWidth / 2));
float pY = grid.context.y + grid.context.height;
Vector3 p1 = new Vector3(pX, grid.context.y);
Vector3 p2 = new Vector3(pX, pY);
Vector3 p3 = new Vector3(pX + tooltipSplitWid, pY);
Vector3 p4 = new Vector3(pX + tooltipSplitWid, grid.context.y);
UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, chart.theme.tooltip.areaColor);
}
break;
}
}
}
}
protected override void DrawBackground(VertexHelper vh)
{
Vector3 p1 = new Vector3(chartX, chartY + chartHeight);
Vector3 p2 = new Vector3(chartX + chartWidth, chartY + chartHeight);
Vector3 p3 = new Vector3(chartX + chartWidth, chartY);
Vector3 p4 = new Vector3(chartX, chartY);
var backgroundColor = ThemeHelper.GetBackgroundColor(m_Theme, m_Background);
UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, backgroundColor);
}
private void DrawPolarLine(VertexHelper vh, Serie serie)
{
var m_Polar = GetPolar(serie.polarIndex);
if (m_Polar == null)
{
return;
}
var m_AngleAxis = GetAngleAxis(m_Polar.index);
var m_RadiusAxis = GetRadiusAxis(m_Polar.index);
if (m_AngleAxis == null || m_RadiusAxis == null)
{
return;
}
var startAngle = m_AngleAxis.runtimeStartAngle;
var radius = m_Polar.runtimeRadius;
var datas = serie.data;
if (datas.Count <= 0)
{
return;
}
float dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
float min = m_RadiusAxis.GetCurrMinValue(dataChangeDuration);
float max = m_RadiusAxis.GetCurrMaxValue(dataChangeDuration);
var firstSerieData = datas[0];
var startPos = GetPolarPos(m_Polar, m_AngleAxis, firstSerieData, min, max, radius);
var nextPos = Vector3.zero;
var lineColor = SerieHelper.GetLineColor(serie, m_Theme, serie.index, serie.highlighted);
var lineWidth = serie.lineStyle.GetWidth(m_Theme.serie.lineWidth);
float currDetailProgress = 0;
float totalDetailProgress = datas.Count;
serie.animation.InitProgress(serie.dataPoints.Count, currDetailProgress, totalDetailProgress);
serie.animation.SetDataFinish(0);
for (int i = 1; i < datas.Count; i++)
{
if (serie.animation.CheckDetailBreak(i))
{
break;
}
var serieData = datas[i];
nextPos = GetPolarPos(m_Polar, m_AngleAxis, datas[i], min, max, radius);
UGL.DrawLine(vh, startPos, nextPos, lineWidth, lineColor);
startPos = nextPos;
}
if (!serie.animation.IsFinish())
{
serie.animation.CheckProgress(totalDetailProgress);
serie.animation.CheckSymbol(serie.symbol.GetSize(null, m_Theme.serie.lineSymbolSize));
m_IsPlayingAnimation = true;
RefreshChart();
}
}
private void DrawRadiusAxis(VertexHelper vh, RadiusAxis radiusAxis)
{
var polar = chart.GetChartComponent <PolarCoord>(radiusAxis.polarIndex);
if (polar == null)
{
return;
}
var angleAxis = ComponentHelper.GetAngleAxis(chart.components, polar.index);
if (angleAxis == null)
{
return;
}
var startAngle = angleAxis.context.startAngle;
var radius = polar.context.radius;
var cenPos = polar.context.center;
var size = AxisHelper.GetScaleNumber(radiusAxis, radius, null);
var totalWidth = 0f;
var dire = ChartHelper.GetDire(startAngle, true).normalized;
var tickWidth = radiusAxis.axisTick.GetWidth(chart.theme.axis.tickWidth);
var tickLength = radiusAxis.axisTick.GetLength(chart.theme.axis.tickLength);
var tickVetor = ChartHelper.GetVertialDire(dire) * tickLength;
for (int i = 0; i <= size; i++)
{
var scaleWidth = AxisHelper.GetScaleWidth(radiusAxis, radius, i);
var pos = ChartHelper.GetPos(cenPos, totalWidth + tickWidth, startAngle, true);
if (radiusAxis.show && radiusAxis.splitLine.show)
{
var outsideRaidus = totalWidth + radiusAxis.splitLine.GetWidth(chart.theme.axis.splitLineWidth) * 2;
var splitLineColor = radiusAxis.splitLine.GetColor(chart.theme.axis.splitLineColor);
UGL.DrawDoughnut(vh, cenPos, totalWidth, outsideRaidus, splitLineColor, Color.clear);
}
if (radiusAxis.show && radiusAxis.axisTick.show)
{
if ((i == 0 && radiusAxis.axisTick.showStartTick) ||
(i == size && radiusAxis.axisTick.showEndTick) ||
(i > 0 && i < size))
{
UGL.DrawLine(vh, pos, pos + tickVetor, tickWidth, chart.theme.axis.lineColor);
}
}
totalWidth += scaleWidth;
}
if (radiusAxis.show && radiusAxis.axisLine.show)
{
var lineStartPos = polar.context.center - dire * tickWidth;
var lineEndPos = polar.context.center + dire * (radius + tickWidth);
var lineWidth = radiusAxis.axisLine.GetWidth(chart.theme.axis.lineWidth);
UGL.DrawLine(vh, lineStartPos, lineEndPos, lineWidth, chart.theme.axis.lineColor);
}
}
private void DrawPolar(VertexHelper vh)
{
UpdateRuntimeValue();
foreach (var polar in m_Polars)
{
if (!ChartHelper.IsClearColor(polar.backgroundColor))
{
UGL.DrawCricle(vh, polar.runtimeCenterPos, polar.runtimeRadius, polar.backgroundColor);
}
}
}
private void DrawCenter(VertexHelper vh, Serie serie, SerieData serieData, float insideRadius, bool last)
{
var itemStyle = SerieHelper.GetItemStyle(serie, serieData);
if (!ChartHelper.IsClearColor(itemStyle.centerColor) && last)
{
var radius = insideRadius - itemStyle.centerGap;
var smoothness = chart.settings.cicleSmoothness;
UGL.DrawCricle(vh, serie.runtimeCenterPos, radius, itemStyle.centerColor, smoothness);
}
}
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 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);
}
}
private void DrawPolygonRadar(VertexHelper vh, RadarCoord radar)
{
float insideRadius = 0, outsideRadius = 0;
float block = radar.context.radius / radar.splitNumber;
int indicatorNum = radar.indicatorList.Count;
Vector3 p1, p2, p3, p4;
Vector3 p = radar.context.center;
float angle = 2 * Mathf.PI / indicatorNum;
var lineColor = radar.axisLine.GetColor(chart.theme.axis.splitLineColor);
var lineWidth = radar.axisLine.GetWidth(chart.theme.axis.lineWidth);
var lineType = radar.axisLine.GetType(chart.theme.axis.lineType);
var splitLineColor = radar.splitLine.GetColor(chart.theme.axis.splitLineColor);
var splitLineWidth = radar.splitLine.GetWidth(chart.theme.axis.splitLineWidth);
var splitLineType = radar.splitLine.GetType(chart.theme.axis.splitLineType);
for (int i = 0; i < radar.splitNumber; i++)
{
var color = radar.splitArea.GetColor(i, chart.theme.axis);
outsideRadius = insideRadius + block;
p1 = new Vector3(p.x + insideRadius * Mathf.Sin(0), p.y + insideRadius * Mathf.Cos(0));
p2 = new Vector3(p.x + outsideRadius * Mathf.Sin(0), p.y + outsideRadius * Mathf.Cos(0));
for (int j = 0; j <= indicatorNum; j++)
{
float currAngle = j * angle;
p3 = new Vector3(p.x + outsideRadius * Mathf.Sin(currAngle),
p.y + outsideRadius * Mathf.Cos(currAngle));
p4 = new Vector3(p.x + insideRadius * Mathf.Sin(currAngle),
p.y + insideRadius * Mathf.Cos(currAngle));
if (radar.splitArea.show)
{
UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, color);
}
if (radar.splitLine.NeedShow(i))
{
ChartDrawer.DrawLineStyle(vh, splitLineType, splitLineWidth, p2, p3, splitLineColor);
}
p1 = p4;
p2 = p3;
}
insideRadius = outsideRadius;
}
if (radar.axisLine.show)
{
for (int j = 0; j <= indicatorNum; j++)
{
float currAngle = j * angle;
p3 = new Vector3(p.x + outsideRadius * Mathf.Sin(currAngle),
p.y + outsideRadius * Mathf.Cos(currAngle));
ChartDrawer.DrawLineStyle(vh, lineType, lineWidth, p, p3, lineColor);
}
}
}
private void DrawRectVessel(VertexHelper vh, Vessel vessel)
{
var serie = SeriesHelper.GetSerieByVesselIndex(chart.series, vessel.index);
var vesselColor = VesselHelper.GetColor(vessel, serie, chart.theme, chart.m_LegendRealShowName);
if (vessel.gap != 0)
{
UGL.DrawBorder(vh, vessel.runtimeCenterPos, vessel.runtimeWidth,
vessel.runtimeHeight, vessel.gap, vessel.backgroundColor, 0, vessel.cornerRadius);
}
UGL.DrawBorder(vh, vessel.runtimeCenterPos, vessel.runtimeWidth + 2 * vessel.gap,
vessel.runtimeHeight + 2 * vessel.gap, vessel.shapeWidth, vesselColor, 0, vessel.cornerRadius);
}
private void DrawCoord(VertexHelper vh)
{
var grid = component;
if (grid.show && !ChartHelper.IsClearColor(grid.backgroundColor))
{
var p1 = new Vector2(grid.context.x, grid.context.y);
var p2 = new Vector2(grid.context.x, grid.context.y + grid.context.height);
var p3 = new Vector2(grid.context.x + grid.context.width, grid.context.y + grid.context.height);
var p4 = new Vector2(grid.context.x + grid.context.width, grid.context.y);
UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, grid.backgroundColor);
}
}
private void DrawPosList(VertexHelper vh, List <Vector3> posList)
{
if (mirrorY)
{
for (int i = posList.Count - 1; i >= 0; i--)
{
var pos = posList[i];
posList[i] = new Vector3(pos.x, -pos.y);
}
}
UGL.DrawLine(vh, posList, 1f, Color.red, false);
posList.Clear();
}
private void DrawVesselBackground(VertexHelper vh, Serie serie)
{
var vessel = chart.GetVessel(serie.vesselIndex);
if (vessel != null)
{
if (vessel.backgroundColor.a != 0)
{
var cenPos = vessel.runtimeCenterPos;
var radius = vessel.runtimeRadius;
UGL.DrawCricle(vh, cenPos, vessel.runtimeInnerRadius, vessel.backgroundColor, chart.settings.cicleSmoothness);
}
}
}
private void DrawBorder(VertexHelper vh, Serie serie, SerieData serieData, float insideRadius, float outsideRadius)
{
var itemStyle = SerieHelper.GetItemStyle(serie, serieData);
if (itemStyle.show && itemStyle.borderWidth > 0 && !ChartHelper.IsClearColor(itemStyle.borderColor))
{
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, outsideRadius,
outsideRadius + itemStyle.borderWidth, itemStyle.borderColor,
Color.clear, chart.settings.cicleSmoothness);
UGL.DrawDoughnut(vh, serie.runtimeCenterPos, insideRadius,
insideRadius + itemStyle.borderWidth, itemStyle.borderColor,
Color.clear, chart.settings.cicleSmoothness);
}
}
