3.0 - polar chart

Editor/Series/SerieListEditor.cs

@@ -189,7 +189,6 @@ namespace XCharts.Editor
         {
             m_SerializedObject.Update();
             var serieName = chart.GenerateDefaultSerieName();
-            UnityEngine.Debug.LogError("AddSerie:" + type);
             type.InvokeMember("AddDefaultSerie",
                 BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public, null, null,
                 new object[] { chart, serieName });

Editor/Windows/XChartsEditor.cs

@@ -139,6 +139,12 @@ namespace XCharts.Editor
         {
             AddChart<CandlestickChart>("CandlestickChart");
         }
+        [MenuItem("XCharts/PolarChart", priority = 54)]
+        [MenuItem("GameObject/XCharts/PolarChart", priority = 54)]
+        public static void PolarChart()
+        {
+            AddChart<PolarChart>("PolarChart");
+        }
 
         [MenuItem("XCharts/ParallelChart", priority = 55)]
         [MenuItem("GameObject/XCharts/ParallelChart", priority = 55)]

Examples/Runtime/Example_LargeData.cs

@@ -4,11 +4,11 @@ using UnityEngine;
 namespace XCharts.Example
 {
     [DisallowMultipleComponent]
-    //[ExecuteInEditMode]
+    [ExecuteInEditMode]
     [RequireComponent(typeof(BaseChart))]
     public class Example_LargeData : MonoBehaviour
     {
-        public int maxCacheDataNumber = 3000;
+        public int maxCacheDataNumber = 1000;
         public float initDataTime = 5;
 
         private BaseChart chart;

Runtime/Chart/PolarChart.cs

@@ -0,0 +1,37 @@
+
+
+using UnityEngine;
+
+namespace XCharts
+{
+    [AddComponentMenu("XCharts/PolarChart", 23)]
+    [ExecuteInEditMode]
+    [RequireComponent(typeof(RectTransform))]
+    [DisallowMultipleComponent]
+    public class PolarChart : BaseChart
+    {
+
+#if UNITY_EDITOR
+        protected override void Reset()
+        {
+            base.Reset();
+            AddChartComponentWhenNoExist<PolarCoord>();
+
+            var tooltip = GetChartComponent<Tooltip>();
+            tooltip.type = Tooltip.Type.Corss;
+            tooltip.trigger = Tooltip.Trigger.Axis;
+
+            RemoveData();
+            var serie = Line.AddDefaultSerie(this, GenerateDefaultSerieName());
+            serie.SetCoord<PolarCoord>();
+            serie.ClearData();
+            for (int i = 0; i <= 360; i++)
+            {
+                var t = i / 180f * Mathf.PI;
+                var r = Mathf.Sin(2 * t) * Mathf.Cos(2 * t) * 2;
+                AddData(0, Mathf.Abs(r), i);
+            }
+        }
+#endif
+    }
+}

Runtime/Chart/PolarChart.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 1fc3767ca43f44f77a6d017fd55c8fec
+guid: 574bcbd917fc148e8bb8735acda07f77
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Runtime/Component/Axis/AngleAxis/AngleAxis.cs

@@ -12,12 +12,11 @@ namespace XCharts
     [ComponentHandler(typeof(AngleAxisHandler), true)]
     public class AngleAxis : Axis
     {
-        [SerializeField] private float m_StartAngle = 90;
+        [SerializeField] private float m_StartAngle = 0;
 
         /// <summary>
-        /// Starting angle of axis. 90 degrees by default, standing for top position of center. 
+        /// Starting angle of axis. 0 degrees by default, standing for right position of center. 
-        /// 0 degree stands for right position of center.
+        /// 起始刻度的角度，默认为 0 度，即圆心的正右方。
-        /// 起始刻度的角度，默认为 90 度，即圆心的正上方。0 度为圆心的正右方。
         /// </summary>
         public float startAngle
         {
@@ -25,12 +24,17 @@ namespace XCharts
             set { if (PropertyUtil.SetStruct(ref m_StartAngle, value)) SetAllDirty(); }
         }
 
+        public float GetValueAngle(float value)
+        {
+            return (value + context.startAngle + 360) % 360;
+        }
+
         public override void SetDefaultValue()
         {
             m_Show = true;
             m_Type = AxisType.Value;
             m_SplitNumber = 12;
-            m_StartAngle = 90;
+            m_StartAngle = 0;
             m_BoundaryGap = false;
             m_Data = new List<string>(12);
             splitLine.show = true;

Runtime/Component/Axis/AngleAxis/AngleAxisHandler.cs

@@ -1,5 +1,3 @@
-
-using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.UI;
 using XUGL;
@@ -7,7 +5,7 @@ using XUGL;
 namespace XCharts
 {
     [UnityEngine.Scripting.Preserve]
-    internal sealed class AngleAxisHandler : MainComponentHandler<AngleAxis>
+    internal sealed class AngleAxisHandler : AxisHandler<AngleAxis>
     {
         public override void InitComponent()
         {
@@ -16,8 +14,9 @@ namespace XCharts
 
         public override void Update()
         {
-            component.startAngle = 90 - component.startAngle;
+            component.context.startAngle = 90 - component.startAngle;
             UpdateAxisMinMaxValue(component);
+            UpdatePointerValue(component);
         }
 
         public override void DrawBase(VertexHelper vh)
@@ -38,6 +37,8 @@ namespace XCharts
                 axis.UpdateMinMaxValue(tempMinValue, tempMaxValue);
                 axis.context.offset = 0;
                 axis.context.lastCheckInverse = axis.inverse;
+                UpdateAxisTickValueList(axis);
+
                 if (updateChart)
                 {
                     UpdateAxisLabelText(axis);
@@ -49,7 +50,10 @@ namespace XCharts
         internal void UpdateAxisLabelText(AngleAxis axis)
         {
             var runtimeWidth = 360;
-            axis.UpdateLabelText(runtimeWidth, null, false);
+            if (axis.context.labelObjectList.Count <= 0)
+                InitAngleAxis(axis);
+            else
+                axis.UpdateLabelText(runtimeWidth, null, false);
         }
 
         private void InitAngleAxis(AngleAxis axis)
@@ -59,8 +63,9 @@ namespace XCharts
             PolarHelper.UpdatePolarCenter(polar, chart.chartPosition, chart.chartWidth, chart.chartHeight);
             var radius = polar.context.radius;
             axis.context.labelObjectList.Clear();
+            axis.context.startAngle = 90 - axis.startAngle;
 
-            string objName = "axis_angle" + axis.index;
+            string objName = component.GetType().Name + axis.index;
             var axisObj = ChartHelper.AddObject(objName, chart.transform, chart.chartMinAnchor,
                 chart.chartMaxAnchor, chart.chartPivot, chart.chartSizeDelta);
             axisObj.transform.localPosition = Vector3.zero;
@@ -68,16 +73,16 @@ namespace XCharts
             axisObj.hideFlags = chart.chartHideFlags;
             ChartHelper.HideAllObject(axisObj);
             var splitNumber = AxisHelper.GetSplitNumber(axis, radius, null);
-            var totalAngle = axis.startAngle;
+            var totalAngle = axis.context.startAngle;
             var total = 360;
             var cenPos = polar.context.center;
             var txtHig = axis.axisLabel.textStyle.GetFontSize(chart.theme.axis) + 2;
-            var margin = axis.axisLabel.margin;
+            var margin = axis.axisLabel.margin + axis.axisTick.GetLength(chart.theme.axis.tickLength);
             var isCategory = axis.IsCategory();
             var isPercentStack = SeriesHelper.IsPercentStack<Bar>(chart.series);
             for (int i = 0; i < splitNumber; i++)
             {
-                float scaleAngle = AxisHelper.GetScaleWidth(axis, total, i, null);
+                float scaleAngle = AxisHelper.GetScaleWidth(axis, total, i + 1, null);
                 bool inside = axis.axisLabel.inside;
                 var labelName = AxisHelper.GetLabelName(axis, total, i, axis.context.minValue, axis.context.maxValue,
                     null, isPercentStack);
@@ -102,24 +107,31 @@ namespace XCharts
             var cenPos = polar.context.center;
             var total = 360;
             var size = AxisHelper.GetScaleNumber(angleAxis, total, null);
-            var currAngle = angleAxis.startAngle;
+            var currAngle = angleAxis.context.startAngle;
             var tickWidth = angleAxis.axisTick.GetWidth(chart.theme.axis.tickWidth);
             var tickLength = angleAxis.axisTick.GetLength(chart.theme.axis.tickLength);
-            for (int i = 0; i < size; i++)
+            var tickColor = angleAxis.axisTick.GetColor(chart.theme.axis.lineColor);
+            var lineColor = angleAxis.axisLine.GetColor(chart.theme.axis.lineColor);
+            var splitLineColor = angleAxis.splitLine.GetColor(chart.theme.axis.splitLineColor);
+            for (int i = 1; i < size; i++)
             {
                 var scaleWidth = AxisHelper.GetScaleWidth(angleAxis, total, i);
                 var pos = ChartHelper.GetPos(cenPos, radius, currAngle, true);
                 if (angleAxis.show && angleAxis.splitLine.show)
                 {
-                    var splitLineColor = angleAxis.splitLine.GetColor(chart.theme.axis.splitLineColor);
                     var lineWidth = angleAxis.splitLine.GetWidth(chart.theme.axis.splitLineWidth);
                     UGL.DrawLine(vh, cenPos, pos, lineWidth, splitLineColor);
                 }
                 if (angleAxis.show && angleAxis.axisTick.show)
                 {
-                    var tickY = radius + tickLength;
+                    if ((i == 1 && angleAxis.axisTick.showStartTick)
-                    var tickPos = ChartHelper.GetPos(cenPos, tickY, currAngle, true);
+                        || (i == size - 1 && angleAxis.axisTick.showEndTick)
-                    UGL.DrawLine(vh, pos, tickPos, tickWidth, chart.theme.axis.lineColor);
+                        || (i > 1 && i < size - 1))
+                    {
+                        var tickY = radius + tickLength;
+                        var tickPos = ChartHelper.GetPos(cenPos, tickY, currAngle, true);
+                        UGL.DrawLine(vh, pos, tickPos, tickWidth, tickColor);
+                    }
                 }
                 currAngle += scaleWidth;
             }
@@ -127,8 +139,26 @@ namespace XCharts
             {
                 var lineWidth = angleAxis.axisLine.GetWidth(chart.theme.axis.lineWidth);
                 var outsideRaidus = radius + lineWidth * 2;
-                UGL.DrawDoughnut(vh, cenPos, radius, outsideRaidus, chart.theme.axis.lineColor, Color.clear);
+                UGL.DrawDoughnut(vh, cenPos, radius, outsideRaidus, lineColor, Color.clear);
             }
         }
+
+        protected override void UpdatePointerValue(Axis axis)
+        {
+            var polar = chart.GetChartComponent<PolarCoord>(axis.polarIndex);
+            if (polar == null)
+                return;
+
+            if (!polar.context.isPointerEnter)
+            {
+                axis.context.pointerValue = double.PositiveInfinity;
+                return;
+            }
+
+            var dir = (chart.pointerPos - new Vector2(polar.context.center.x, polar.context.center.y)).normalized;
+            var angle = ChartHelper.GetAngle360(Vector2.up, dir);
+            axis.context.pointerValue = (angle - component.context.startAngle + 360) % 360;
+            axis.context.pointerLabelPosition = polar.context.center + new Vector3(dir.x, dir.y) * (polar.context.radius + 25);
+        }
     }
 }

Runtime/Component/Axis/AxisHandler.cs

@@ -24,9 +24,9 @@ namespace XCharts
             return Vector3.zero;
         }
 
-        protected virtual Orient orient { get; }
+        protected virtual Orient orient { get; set; }
 
-        protected void UpdatePointerValue(Axis axis)
+        protected virtual void UpdatePointerValue(Axis axis)
         {
             var grid = chart.GetChartComponent<GridCoord>(axis.gridIndex);
             if (grid == null)
@@ -256,6 +256,7 @@ namespace XCharts
 
         private static double GetTick(double max)
         {
+            if (max <= 1) return max / 5;
             var bigger = Math.Ceiling(Math.Abs(max));
             int n = 1;
             while (bigger / (Mathf.Pow(10, n)) > 10)

Runtime/Component/Axis/RadiusAxis/RadiusAxisHandler.cs

@@ -7,7 +7,7 @@ using XUGL;
 namespace XCharts
 {
     [UnityEngine.Scripting.Preserve]
-    internal sealed class RadiusAxisHandler : MainComponentHandler<RadiusAxis>
+    internal sealed class RadiusAxisHandler : AxisHandler<RadiusAxis>
     {
         public override void InitComponent()
         {
@@ -17,6 +17,7 @@ namespace XCharts
         public override void Update()
         {
             UpdateAxisMinMaxValue(component);
+            UpdatePointerValue(component);
         }
 
         public override void DrawBase(VertexHelper vh)
@@ -24,6 +25,28 @@ namespace XCharts
             DrawRadiusAxis(vh, component);
         }
 
+        protected override void UpdatePointerValue(Axis axis)
+        {
+            var polar = chart.GetChartComponent<PolarCoord>(axis.polarIndex);
+            if (polar == null)
+                return;
+
+            if (!polar.context.isPointerEnter)
+            {
+                axis.context.pointerValue = double.PositiveInfinity;
+                return;
+            }
+            var angleAxis = ComponentHelper.GetAngleAxis(chart.components, polar.index);
+            if (angleAxis == null)
+                return;
+
+            var startAngle = angleAxis.context.startAngle;
+
+            var dist = Vector3.Distance(chart.pointerPos, polar.context.center);
+            axis.context.pointerValue = axis.context.minValue + (dist / polar.context.radius) * axis.context.minMaxRange;
+            axis.context.pointerLabelPosition = GetLabelPosition(polar, axis, angleAxis.context.startAngle, dist);
+        }
+
         private void UpdateAxisMinMaxValue(RadiusAxis axis, bool updateChart = true)
         {
             if (axis.IsCategory() || !axis.show) return;
@@ -37,6 +60,7 @@ namespace XCharts
                 axis.UpdateMinMaxValue(tempMinValue, tempMaxValue);
                 axis.context.offset = 0;
                 axis.context.lastCheckInverse = axis.inverse;
+                UpdateAxisTickValueList(axis);
 
                 if (updateChart)
                 {
@@ -49,7 +73,10 @@ namespace XCharts
         internal void UpdateAxisLabelText(RadiusAxis axis)
         {
             var polar = chart.GetChartComponent<PolarCoord>(axis.polarIndex);
-            axis.UpdateLabelText(polar.context.radius, null, false);
+            if (axis.context.labelObjectList.Count <= 0)
+                InitRadiusAxis(axis);
+            else
+                axis.UpdateLabelText(polar.context.radius, null, false);
         }
 
         private void InitRadiusAxis(RadiusAxis axis)
@@ -65,7 +92,7 @@ namespace XCharts
             PolarHelper.UpdatePolarCenter(polar, chart.chartPosition, chart.chartWidth, chart.chartHeight);
             axis.context.labelObjectList.Clear();
             var radius = polar.context.radius;
-            var objName = "axis_radius" + axis.index;
+            var objName = component.GetType().Name + axis.index;
             var axisObj = ChartHelper.AddObject(objName, chart.transform, chart.chartMinAnchor,
                 chart.chartMaxAnchor, chart.chartPivot, chart.chartSizeDelta);
             axisObj.transform.localPosition = Vector3.zero;
@@ -73,18 +100,12 @@ namespace XCharts
             axisObj.hideFlags = chart.chartHideFlags;
             ChartHelper.HideAllObject(axisObj);
             var textStyle = axis.axisLabel.textStyle;
-            var splitNumber = AxisHelper.GetSplitNumber(axis, radius, null);
+            var splitNumber = AxisHelper.GetScaleNumber(axis, radius, null);
             var totalWidth = 0f;
-            var startAngle = angleAxis.startAngle;
-            var cenPos = polar.context.center;
             var txtHig = textStyle.GetFontSize(chart.theme.axis) + 2;
-            var dire = ChartHelper.GetDire(startAngle, true).normalized;
+            for (int i = 0; i < splitNumber; i++)
-            var tickWidth = axis.axisTick.GetLength(chart.theme.axis.tickWidth);
-            var tickVector = ChartHelper.GetVertialDire(dire)
-                * (tickWidth + axis.axisLabel.margin);
-            for (int i = 0; i <= splitNumber; i++)
             {
-                var labelWidth = AxisHelper.GetScaleWidth(axis, radius, i, null);
+                var labelWidth = AxisHelper.GetScaleWidth(axis, radius, i + 1, null);
                 var inside = axis.axisLabel.inside;
                 var isPercentStack = SeriesHelper.IsPercentStack<Bar>(chart.series);
                 var labelName = AxisHelper.GetLabelName(axis, radius, i, axis.context.minValue, axis.context.maxValue,
@@ -98,8 +119,9 @@ namespace XCharts
 
                 label.label.SetAlignment(textStyle.GetAlignment(TextAnchor.MiddleCenter));
                 label.SetText(labelName);
-                label.SetPosition(ChartHelper.GetPos(cenPos, totalWidth, startAngle, true) + tickVector);
+                label.SetPosition(GetLabelPosition(polar, axis, angleAxis.context.startAngle, totalWidth));
                 label.SetActive(true);
+                label.SetLabelActive(true);
 
                 axis.context.labelObjectList.Add(label);
 
@@ -107,6 +129,16 @@ namespace XCharts
             }
         }
 
+        private Vector3 GetLabelPosition(PolarCoord polar, Axis axis, float startAngle, float totalWidth)
+        {
+            var cenPos = polar.context.center;
+            var dire = ChartHelper.GetDire(startAngle, true).normalized;
+            var tickLength = axis.axisTick.GetLength(chart.theme.axis.tickLength);
+            var tickVector = ChartHelper.GetVertialDire(dire)
+                * (tickLength + axis.axisLabel.margin);
+            return ChartHelper.GetPos(cenPos, totalWidth, startAngle, true) + tickVector;
+        }
+
         private void DrawRadiusAxis(VertexHelper vh, RadiusAxis radiusAxis)
         {
             var polar = chart.GetChartComponent<PolarCoord>(radiusAxis.polarIndex);
@@ -117,19 +149,19 @@ namespace XCharts
             if (angleAxis == null)
                 return;
 
-            var startAngle = angleAxis.startAngle;
+            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.GetLength(chart.theme.axis.tickWidth);
+            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 - 1; i++)
+            for (int i = 0; i <= size; i++)
             {
                 var scaleWidth = AxisHelper.GetScaleWidth(radiusAxis, radius, i);
-                var pos = ChartHelper.GetPos(cenPos, totalWidth, startAngle, true);
+                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;
@@ -138,7 +170,12 @@ namespace XCharts
                 }
                 if (radiusAxis.show && radiusAxis.axisTick.show)
                 {
-                    UGL.DrawLine(vh, pos, pos + tickVetor, tickWidth, chart.theme.axis.lineColor);
+                    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;
             }

Runtime/Component/Tooltip/Tooltip.cs

@@ -355,10 +355,6 @@ namespace XCharts
         /// </summary>
         public List<int> runtimeDataIndex { get { return m_RuntimeDateIndex; } internal set { m_RuntimeDateIndex = value; } }
         private List<int> m_RuntimeDateIndex = new List<int>() { -1, -1 };
-        /// <summary>
-        /// 当前指示的角度。
-        /// </summary>
-        public float runtimeAngle { get; internal set; }
 
         /// <summary>
         /// Keep Tooltiop displayed at the top. 

Runtime/Component/Tooltip/TooltipContext.cs

@@ -19,6 +19,7 @@ namespace XCharts
         public Vector2 pointer;
         public float width;
         public float height;
+        public float angle;
         public TooltipData data = new TooltipData();
     }
 }

Runtime/Component/Tooltip/TooltipHandler.cs

@@ -98,6 +98,7 @@ namespace XCharts
                     if (SetSerieTooltip(tooltip, serie))
                     {
                         showTooltip = true;
+                        chart.RefreshTopPainter();
                         return;
                     }
                 }
@@ -112,7 +113,7 @@ namespace XCharts
             ListPool<Serie>.Release(containerSeries);
             if (!showTooltip)
             {
-                if (tooltip.type == Tooltip.Type.Corss && (m_PointerContainer == null || m_PointerContainer.IsPointerEnter()))
+                if (tooltip.type == Tooltip.Type.Corss && m_PointerContainer != null && m_PointerContainer.IsPointerEnter())
                 {
                     tooltip.SetActive(true);
                     tooltip.SetContentActive(false);
@@ -149,15 +150,24 @@ namespace XCharts
                                 if (axis.gridIndex == grid.index)
                                 {
                                     var label = GetIndicatorLabel(labelCount++);
-                                    if (label == null) continue;
+                                    SetTooltipIndicatorLabel(axis, label);
-                                    label.SetActive(true);
+                                }
-                                    label.SetPosition(axis.context.pointerLabelPosition);
+                            }
-                                    if (axis.IsCategory())
+                        }
-                                        label.SetText(axis.GetData((int)axis.context.pointerValue));
+                    }
-                                    else
+                    else if (m_PointerContainer is PolarCoord)
-                                        label.SetText(axis.context.pointerValue.ToString("f2"));
+                    {
-                                    var textColor = axis.axisLabel.textStyle.GetColor(chart.theme.axis.textColor);
+                        var polar = m_PointerContainer as PolarCoord;
-                                    label.labelBackground.color = textColor;
+                        ChartHelper.HideAllObject(m_LabelRoot);
+                        foreach (var component in chart.components)
+                        {
+                            if (component is AngleAxis || component is RadiusAxis)
+                            {
+                                var axis = component as Axis;
+                                if (axis.polarIndex == polar.index)
+                                {
+                                    var label = GetIndicatorLabel(labelCount++);
+                                    SetTooltipIndicatorLabel(axis, label);
                                 }
                             }
                         }
@@ -166,6 +176,21 @@ namespace XCharts
             }
         }
 
+        private void SetTooltipIndicatorLabel(Axis axis, ChartLabel label)
+        {
+            if (label == null) return;
+            label.SetActive(true);
+            label.SetLabelActive(true);
+            label.SetPosition(axis.context.pointerLabelPosition);
+            if (axis.IsCategory())
+                label.SetText(axis.GetData((int)axis.context.pointerValue));
+            else
+                label.SetText(axis.context.pointerValue.ToString("f2"));
+            var textColor = axis.axisLabel.textStyle.GetColor(chart.theme.axis.textColor);
+            label.labelBackground.color = textColor;
+            label.SetTextColor(Color.white);
+        }
+
         private ISerieContainer GetPointerContainerAndSeries(Tooltip tooltip, List<Serie> list)
         {
             list.Clear();
@@ -191,6 +216,11 @@ namespace XCharts
                                         serie.context.pointerEnter = true;
                                         UpdateAxisPointerDataIndex(serie, xAxis, yAxis, container as GridCoord);
                                     }
+                                    else if (container is PolarCoord)
+                                    {
+                                        var m_AngleAxis = ComponentHelper.GetAngleAxis(chart.components, container.index);
+                                        tooltip.context.angle = (float)m_AngleAxis.context.pointerValue;
+                                    }
                                     list.Add(serie);
                                 }
                                 else if (serie.context.pointerEnter)
@@ -351,14 +381,15 @@ namespace XCharts
                     else
                         tooltip.context.data.title = category;
                 }
-
             }
+
             for (int i = 0; i < series.Count; i++)
             {
                 var serie = series[i];
                 serie.context.isTriggerByAxis = isTriggerByAxis;
                 if (isTriggerByAxis && dataIndex >= 0)
                     serie.context.pointerItemDataIndex = dataIndex;
+
                 serie.handler.UpdateTooltipSerieParams(dataIndex, showCategory, category,
                     tooltip.marker, tooltip.itemFormatter, tooltip.numericFormatter,
                     ref tooltip.context.data.param,
@@ -447,7 +478,22 @@ namespace XCharts
                             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 (xAxis.IsCategory())
+                            {
+                                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);
+                            }
+                            else
+                            {
+                                ChartDrawer.DrawLineStyle(vh, lineType, lineWidth, sp, ep, lineColor);
+                            }
                             if (tooltip.type == Tooltip.Type.Corss)
                             {
                                 sp = new Vector2(grid.context.x, chart.pointerPos.y);
@@ -496,7 +542,22 @@ namespace XCharts
                             Vector2 sp = new Vector2(grid.context.x, pY);
                             Vector2 ep = new Vector2(grid.context.x + grid.context.width, pY);
                             var lineColor = TooltipHelper.GetLineColor(tooltip, chart.theme);
-                            ChartDrawer.DrawLineStyle(vh, lineType, lineWidth, sp, ep, lineColor);
+                            if (yAxis.IsCategory())
+                            {
+                                float tooltipSplitWid = splitWidth < 1 ? 1 : splitWidth;
+                                float pX = grid.context.x + grid.context.width;
+                                pY = (float)(grid.context.y + splitWidth * yAxis.context.pointerValue -
+                                    (yAxis.boundaryGap ? 0 : splitWidth / 2));
+                                Vector3 p1 = new Vector3(grid.context.x, pY);
+                                Vector3 p2 = new Vector3(grid.context.x, pY + tooltipSplitWid);
+                                Vector3 p3 = new Vector3(pX, pY + tooltipSplitWid);
+                                Vector3 p4 = new Vector3(pX, pY);
+                                UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, chart.theme.tooltip.areaColor);
+                            }
+                            else
+                            {
+                                ChartDrawer.DrawLineStyle(vh, lineType, lineWidth, sp, ep, lineColor);
+                            }
                             if (tooltip.type == Tooltip.Type.Corss)
                             {
                                 sp = new Vector2(chart.pointerPos.x, grid.context.y);
@@ -525,7 +586,7 @@ namespace XCharts
 
         private void DrawPolarIndicator(VertexHelper vh, Tooltip tooltip, PolarCoord m_Polar)
         {
-            if (tooltip.runtimeAngle < 0) return;
+            if (tooltip.context.angle < 0) return;
             var theme = chart.theme;
             var m_AngleAxis = ComponentHelper.GetAngleAxis(chart.components, m_Polar.index);
             var lineColor = TooltipHelper.GetLineColor(tooltip, theme);
@@ -534,7 +595,8 @@ namespace XCharts
             var cenPos = m_Polar.context.center;
             var radius = m_Polar.context.radius;
             var sp = m_Polar.context.center;
-            var tooltipAngle = tooltip.runtimeAngle + m_AngleAxis.startAngle;
+            var tooltipAngle = m_AngleAxis.GetValueAngle(tooltip.context.angle);
+
             var ep = ChartHelper.GetPos(sp, radius, tooltipAngle, true);
 
             switch (tooltip.type)

Runtime/Coord/Grid/GridCoord.cs

@@ -1,6 +1,7 @@
 
 using System;
 using UnityEngine;
+using XUGL;
 
 namespace XCharts
 {
@@ -112,5 +113,33 @@ namespace XCharts
             }
             return true;
         }
+
+        /// <summary>
+        /// 给定的线段和Grid边界的交点
+        /// </summary>
+        /// <param name="sp"></param>
+        /// <param name="ep"></param>
+        /// <returns></returns>
+        public bool BoundaryPoint(Vector3 sp, Vector3 ep, ref Vector3 point)
+        {
+            if (Contains(sp) && Contains(ep))
+            {
+                point = ep;
+                return false;
+            }
+            var lb = new Vector3(context.x, context.y);
+            var lt = new Vector3(context.x, context.y + context.height);
+            var rt = new Vector3(context.x + context.width, context.y + context.height);
+            var rb = new Vector3(context.x + context.width, context.y);
+            if (UGLHelper.GetIntersection(sp, ep, rb, rt, ref point))
+                return true;
+            if (UGLHelper.GetIntersection(sp, ep, lt, rt, ref point))
+                return true;
+            if (UGLHelper.GetIntersection(sp, ep, lb, rb, ref point))
+                return true;
+            if (UGLHelper.GetIntersection(sp, ep, lb, lt, ref point))
+                return true;
+            return false;
+        }
     }
 }

Runtime/Coord/Polar/PolarCoord.cs

@@ -14,7 +14,7 @@ namespace XCharts
     [Serializable]
     [ComponentHandler(typeof(PolarCoordHandler), true)]
     [RequireChartComponent(typeof(AngleAxis), typeof(RadiusAxis))]
-    public class PolarCoord : CoordSystem
+    public class PolarCoord : CoordSystem, ISerieContainer
     {
         [SerializeField] private bool m_Show = true;
         [SerializeField] private float[] m_Center = new float[2] { 0.5f, 0.45f };
@@ -63,5 +63,14 @@ namespace XCharts
             set { if (PropertyUtil.SetColor(ref m_BackgroundColor, value)) SetVerticesDirty(); }
         }
 
+        public bool IsPointerEnter()
+        {
+            return context.isPointerEnter;
+        }
+
+        public bool Contains(Vector3 pos)
+        {
+            return Vector3.Distance(pos, context.center) < context.radius;
+        }
     }
 }

Runtime/Coord/Polar/PolarCoordContext.cs

@@ -16,5 +16,6 @@ namespace XCharts
         /// 极坐标的运行时实际半径。
         /// </summary>
         public float radius { get; internal set; }
+        public bool isPointerEnter { get; set; }
     }
 }

Runtime/Coord/Polar/PolarCoordHandler.cs

@@ -12,6 +12,11 @@ namespace XCharts
         public override void Update()
         {
             PolarHelper.UpdatePolarCenter(component, chart.chartPosition, chart.chartWidth, chart.chartHeight);
+
+            if (chart.isPointerInChart)
+                component.context.isPointerEnter = component.Contains(chart.pointerPos);
+            else
+                component.context.isPointerEnter = false;
         }
 
         public override void DrawBase(VertexHelper vh)

Runtime/Internal/BaseChart.API.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: ec7d385a69cce42fda86960eb0b23c3b
+guid: 62d2f81e569a4477aab2091dc0b8dba7
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Runtime/Internal/BaseGraph.API.cs

@@ -11,12 +11,6 @@ namespace XCharts
     /// </summary>
     public partial class BaseGraph
     {
-        /// <summary>
-        /// The background component.
-        /// 背景组件。
-        /// </summary>
-        /// <value></value>
-        ///public Background background { get { return m_Background; } }
         /// <summary>
         /// The x of graph. 
         /// 图形的X

Runtime/Internal/BaseGraph.API.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 46b27d174989044f3b63eaf0c3b21fcd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Internal/XChartsMgr.cs

@@ -1,12 +1,5 @@
-
-
-
-using System.Text;
-using System.Collections;
 using System.Collections.Generic;
-using System.Text.RegularExpressions;
 using UnityEngine;
-using UnityEngine.Networking;
 using UnityEngine.SceneManagement;
 using System.IO;
 #if UNITY_EDITOR

Runtime/Serie/Bar/Bar.cs

@@ -19,13 +19,14 @@ namespace XCharts
         public int containerIndex { get; internal set; }
         public int containterInstanceId { get; internal set; }
 
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<Bar>(serieName);
             for (int i = 0; i < 5; i++)
             {
                 chart.AddData(serie.index, UnityEngine.Random.Range(10, 90));
             }
+            return serie;
         }
 
         public static Bar CovertSerie(Serie serie)

Runtime/Serie/Bar/BarHandler.cs

@@ -228,7 +228,10 @@ namespace XCharts
                 serieData.context.stackHeight = barHig;
                 serieData.context.position = top;
                 serieData.context.rect = Rect.MinMaxRect(plb.x, plb.y, prb.x, prt.y);
-                serie.context.dataPoints.Add(top);
+                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)

Runtime/Serie/Bar/SimplifiedBar.cs

@@ -15,7 +15,7 @@ namespace XCharts
         public int containerIndex { get; internal set; }
         public int containterInstanceId { get; internal set; }
 
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<SimplifiedBar>(serieName);
             serie.symbol.show = false;
@@ -28,6 +28,7 @@ namespace XCharts
                     lastValue += UnityEngine.Random.Range(-3, 5);
                 chart.AddData(serie.index, lastValue);
             }
+            return serie;
         }
 
         public static SimplifiedBar CovertSerie(Serie serie)

Runtime/Serie/Candlestick/Candlestick.cs

@@ -11,7 +11,7 @@ namespace XCharts
     {
         public int containerIndex { get; internal set; }
         public int containterInstanceId { get; internal set; }
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<Candlestick>(serieName);
             var defaultDataCount = 5;
@@ -23,6 +23,7 @@ namespace XCharts
                 var heighest = Random.Range(50, 100);
                 chart.AddData(serie.index, open, close, lowest, heighest);
             }
+            return serie;
         }
     }
 }

Runtime/Serie/Candlestick/SimplifiedCandlestick.cs

@@ -12,7 +12,7 @@ namespace XCharts
         public int containerIndex { get; internal set; }
         public int containterInstanceId { get; internal set; }
 
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<SimplifiedCandlestick>(serieName);
 
@@ -26,6 +26,7 @@ namespace XCharts
                 var heighest = lastValue + Random.Range(10, 20);
                 chart.AddData(serie.index, open, close, lowest, heighest);
             }
+            return serie;
         }
 
         public static SimplifiedCandlestick CovertSerie(Serie serie)

Runtime/Serie/Heatmap/Heatmap.cs

@@ -11,7 +11,7 @@ namespace XCharts
     {
         public int containerIndex { get; internal set; }
         public int containterInstanceId { get; internal set; }
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<Heatmap>(serieName);
             serie.itemStyle.show = true;
@@ -23,6 +23,7 @@ namespace XCharts
             emphasis.itemStyle.show = true;
             emphasis.itemStyle.borderWidth = 1;
             emphasis.itemStyle.borderColor = Color.black;
+            return serie;
         }
     }
 }

Runtime/Serie/Line/Line.cs

@@ -20,7 +20,7 @@ namespace XCharts
     {
         public int containerIndex { get; internal set; }
         public int containterInstanceId { get; internal set; }
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<Line>(serieName);
             serie.symbol.show = true;
@@ -28,6 +28,7 @@ namespace XCharts
             {
                 chart.AddData(serie.index, UnityEngine.Random.Range(10, 90));
             }
+            return serie;
         }
 
         public static Line CovertSerie(Serie serie)

Runtime/Serie/Line/LineHandler.GridCoord.cs

@@ -10,58 +10,12 @@ namespace XCharts
     /// <summary>
     /// For grid coord
     /// </summary>
-    [UnityEngine.Scripting.Preserve]
     internal sealed partial class LineHandler : SerieHandler<Line>
     {
         List<List<SerieData>> m_StackSerieData = new List<List<SerieData>>();
         private GridCoord m_SerieGrid;
 
-        public override void Update()
+        private void UpdateSerieGridContext()
-        {
-            base.Update();
-            UpdateSerieContext();
-        }
-
-        public override void UpdateTooltipSerieParams(int dataIndex, bool showCategory, string category,
-            string marker, string itemFormatter, string numericFormatter,
-            ref List<SerieParams> paramList, ref string title)
-        {
-            UpdateCoordSerieParams(ref paramList, ref title, dataIndex, showCategory, category,
-                marker, itemFormatter, numericFormatter);
-        }
-
-        public override void DrawSerie(VertexHelper vh)
-        {
-            if (serie.IsUseCoord<PolarCoord>())
-            {
-                DrawPolarLine(vh, serie);
-                DrawPolarLineSymbol(vh);
-            }
-            else if (serie.IsUseCoord<GridCoord>())
-            {
-                DrawLineSerie(vh, serie);
-
-                if (!SeriesHelper.IsStack(chart.series))
-                {
-                    DrawLinePoint(vh, serie);
-                    DrawLineArrow(vh, serie);
-                }
-            }
-        }
-
-        public override void DrawTop(VertexHelper vh)
-        {
-            if (serie.IsUseCoord<GridCoord>())
-            {
-                if (SeriesHelper.IsStack(chart.series))
-                {
-                    DrawLinePoint(vh, serie);
-                    DrawLineArrow(vh, serie);
-                }
-            }
-        }
-
-        private void UpdateSerieContext()
         {
             if (m_SerieGrid == null)
                 return;
@@ -185,13 +139,13 @@ namespace XCharts
             var theme = chart.theme;
             var interacting = false;
             var lineArrow = serie.lineArrow;
-            //var isY = ComponentHelper.IsAnyCategoryOfYAxis(chart.components);
-
             for (int i = 0; i < count; i++)
             {
                 var serieData = serie.GetSerieData(i);
                 if (serieData == null)
                     continue;
+                if (serieData.context.isClip)
+                    continue;
 
                 var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
 
@@ -199,10 +153,6 @@ namespace XCharts
                     continue;
 
                 var pos = serie.context.dataPoints[i];
-                // if (serie.animation.CheckDetailBreak(pos, isY))
-                // {
-                //     continue;
-                // }
                 if (lineArrow != null && lineArrow.show)
                 {
                     if (lineArrow.position == LineArrow.Position.Start && i == 0)
@@ -308,12 +258,13 @@ namespace XCharts
                 axis = chart.GetChartComponent<XAxis>(serie.xAxisIndex);
                 relativedAxis = chart.GetChartComponent<YAxis>(serie.yAxisIndex);
             }
-            m_SerieGrid = chart.GetChartComponent<GridCoord>(axis.gridIndex);
 
             if (axis == null)
                 return;
             if (relativedAxis == null)
                 return;
+
+            m_SerieGrid = chart.GetChartComponent<GridCoord>(axis.gridIndex);
             if (m_SerieGrid == null)
                 return;
 
@@ -351,7 +302,7 @@ namespace XCharts
                 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];
@@ -374,11 +325,18 @@ namespace XCharts
 
                     serieData.context.stackHeight = GetDataPoint(isY, axis, relativedAxis, m_SerieGrid, xValue, relativedValue,
                         i, scaleWid, isStack, ref np);
-
+                    serieData.context.isClip = false;
-                    serieData.context.position = np;
+                    if (serie.clip && !m_SerieGrid.Contains(np))
-
+                    {
-                    serie.context.dataPoints.Add(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;
                 }
             }
 

Runtime/Serie/Line/LineHandler.PolarCoord.cs

@@ -10,29 +10,117 @@ namespace XCharts
     /// </summary>
     internal sealed partial class LineHandler
     {
+        private PolarCoord m_SeriePolar;
+
+        private void UpdateSeriePolarContext()
+        {
+            if (m_SeriePolar == null)
+                return;
+
+            var needCheck = (chart.isPointerInChart && m_SeriePolar.IsPointerEnter()) || m_LegendEnter;
+            var lineWidth = 0f;
+            if (!needCheck)
+            {
+                if (m_LastCheckContextFlag != needCheck)
+                {
+                    var needAnimation1 = false;
+                    lineWidth = serie.lineStyle.GetWidth(chart.theme.serie.lineWidth);
+                    m_LastCheckContextFlag = needCheck;
+                    serie.context.pointerItemDataIndex = -1;
+                    serie.context.pointerEnter = false;
+                    serie.interact.SetValue(ref needAnimation1, lineWidth, false);
+                    foreach (var serieData in serie.data)
+                    {
+                        var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
+                        var symbolSize = symbol.GetSize(serieData.data, chart.theme.serie.lineSymbolSize);
+                        serieData.context.highlight = false;
+                        serieData.interact.SetValue(ref needAnimation1, symbolSize);
+                    }
+                    if (needAnimation1)
+                    {
+                        if (SeriesHelper.IsStack(chart.series))
+                            chart.RefreshTopPainter();
+                        else
+                            chart.RefreshPainter(serie);
+                    }
+                }
+                return;
+            }
+            m_LastCheckContextFlag = needCheck;
+            var themeSymbolSize = chart.theme.serie.lineSymbolSize;
+            var themeSymbolSelectedSize = chart.theme.serie.lineSymbolSelectedSize;
+            lineWidth = serie.lineStyle.GetWidth(chart.theme.serie.lineWidth);
+
+            var needInteract = false;
+            if (m_LegendEnter)
+            {
+                serie.interact.SetValue(ref needInteract, lineWidth, true, chart.theme.serie.selectedRate);
+                for (int i = 0; i < serie.dataCount; i++)
+                {
+                    var serieData = serie.data[i];
+                    var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
+                    var symbolSelectedSize = symbol.GetSelectedSize(serieData.data, themeSymbolSelectedSize);
+
+                    serieData.context.highlight = true;
+                    serieData.interact.SetValue(ref needInteract, symbolSelectedSize);
+                }
+            }
+            else
+            {
+                serie.context.pointerItemDataIndex = -1;
+                serie.context.pointerEnter = false;
+                var dir = chart.pointerPos - new Vector2(m_SeriePolar.context.center.x, m_SeriePolar.context.center.y);
+                var pointerAngle = ChartHelper.GetAngle360(Vector2.up, dir);
+                for (int i = 0; i < serie.dataCount; i++)
+                {
+                    var serieData = serie.data[i];
+                    var angle0 = serieData.context.angle;
+                    var angle1 = i >= serie.dataCount - 1 ? angle0 : serie.data[i + 1].context.angle;
+                    
+                    if (pointerAngle >= angle0 && pointerAngle < angle1)
+                    {
+                        serie.context.pointerItemDataIndex = i;
+                        serie.context.pointerEnter = true;
+                        serieData.context.highlight = true;
+                    }
+                    else
+                    {
+                        serieData.context.highlight = false;
+                    }
+                }
+            }
+            if (needInteract)
+            {
+                if (SeriesHelper.IsStack(chart.series))
+                    chart.RefreshTopPainter();
+                else
+                    chart.RefreshPainter(serie);
+            }
+        }
+
         private void DrawPolarLine(VertexHelper vh, Serie serie)
         {
             var datas = serie.data;
             if (datas.Count <= 0)
                 return;
 
-            var m_Polar = chart.GetChartComponent<PolarCoord>(serie.polarIndex);
+            m_SeriePolar = chart.GetChartComponent<PolarCoord>(serie.polarIndex);
-            if (m_Polar == null)
+            if (m_SeriePolar == null)
                 return;
 
-            var m_AngleAxis = ComponentHelper.GetAngleAxis(chart.components, m_Polar.index);
+            var m_AngleAxis = ComponentHelper.GetAngleAxis(chart.components, m_SeriePolar.index);
-            var m_RadiusAxis = ComponentHelper.GetRadiusAxis(chart.components, m_Polar.index);
+            var m_RadiusAxis = ComponentHelper.GetRadiusAxis(chart.components, m_SeriePolar.index);
             if (m_AngleAxis == null || m_RadiusAxis == null)
                 return;
 
             var startAngle = m_AngleAxis.startAngle;
-            var radius = m_Polar.context.radius;
+            var radius = m_SeriePolar.context.radius;
 
             var min = m_RadiusAxis.context.minValue;
             var max = m_RadiusAxis.context.maxValue;
             var firstSerieData = datas[0];
-            var startPos = GetPolarPos(m_Polar, m_AngleAxis, firstSerieData, min, max, radius);
+            var lp = GetPolarPos(m_SeriePolar, m_AngleAxis, firstSerieData, min, max, radius);
-            var nextPos = Vector3.zero;
+            var cp = Vector3.zero;
             var lineColor = SerieHelper.GetLineColor(serie, null, chart.theme, serie.index, serie.highlight);
             var lineWidth = serie.lineStyle.GetWidth(chart.theme.serie.lineWidth);
             var currDetailProgress = 0f;
@@ -40,15 +128,62 @@ namespace XCharts
 
             serie.animation.InitProgress(currDetailProgress, totalDetailProgress);
 
+            var ltp = Vector3.zero;
+            var lbp = Vector3.zero;
+            var ntp = Vector3.zero;
+            var nbp = Vector3.zero;
+            var itp = Vector3.zero;
+            var ibp = Vector3.zero;
+            var clp = Vector3.zero;
+            var crp = Vector3.zero;
+            bool bitp = true, bibp = true;
             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);
+                cp = GetPolarPos(m_SeriePolar, m_AngleAxis, datas[i], min, max, radius);
-                startPos = nextPos;
+                var np = i == datas.Count - 1 ? cp :
+                     GetPolarPos(m_SeriePolar, m_AngleAxis, datas[i + 1], min, max, radius);
+
+                UGLHelper.GetLinePoints(lp, cp, np, lineWidth,
+                    ref ltp, ref lbp,
+                    ref ntp, ref nbp,
+                    ref itp, ref ibp,
+                    ref clp, ref crp,
+                    ref bitp, ref bibp, i);
+
+                if (i == 1)
+                {
+                    UGL.AddVertToVertexHelper(vh, ltp, lbp, lineColor, false);
+                }
+
+                if (bitp == bibp)
+                {
+                    if (bitp)
+                        UGL.AddVertToVertexHelper(vh, itp, ibp, lineColor, true);
+                    else
+                    {
+                        UGL.AddVertToVertexHelper(vh, ltp, clp, lineColor, true);
+                        UGL.AddVertToVertexHelper(vh, ltp, crp, lineColor, true);
+                    }
+                }
+                else
+                {
+                    if (bitp)
+                    {
+                        UGL.AddVertToVertexHelper(vh, itp, clp, lineColor, true);
+                        UGL.AddVertToVertexHelper(vh, itp, crp, lineColor, true);
+                    }
+                    else if (bibp)
+                    {
+                        UGL.AddVertToVertexHelper(vh, clp, ibp, lineColor, true);
+                        UGL.AddVertToVertexHelper(vh, crp, ibp, lineColor, true);
+                    }
+                }
+                lp = cp;
             }
 
             if (!serie.animation.IsFinish())
@@ -108,11 +243,11 @@ namespace XCharts
 
             if (!m_AngleAxis.clockwise)
             {
-                angle = m_AngleAxis.startAngle - (float)serieData.GetData(1);
+                angle = m_AngleAxis.GetValueAngle((float)serieData.GetData(1));
             }
             else
             {
-                angle = m_AngleAxis.startAngle + (float)serieData.GetData(1);
+                angle = m_AngleAxis.GetValueAngle((float)serieData.GetData(1));
             }
 
             var value = serieData.GetData(0);

Runtime/Serie/Line/LineHandler.cs

@@ -0,0 +1,64 @@
+
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+using UnityEngine.UI;
+using XUGL;
+
+namespace XCharts
+{
+    /// <summary>
+    /// For grid coord
+    /// </summary>
+    [UnityEngine.Scripting.Preserve]
+    internal sealed partial class LineHandler : SerieHandler<Line>
+    {
+        public override void Update()
+        {
+            base.Update();
+            if (serie.IsUseCoord<GridCoord>())
+                UpdateSerieGridContext();
+            else if (serie.IsUseCoord<PolarCoord>())
+                UpdateSeriePolarContext();
+        }
+
+        public override void UpdateTooltipSerieParams(int dataIndex, bool showCategory, string category,
+            string marker, string itemFormatter, string numericFormatter,
+            ref List<SerieParams> paramList, ref string title)
+        {
+            UpdateCoordSerieParams(ref paramList, ref title, dataIndex, showCategory, category,
+                marker, itemFormatter, numericFormatter);
+        }
+
+        public override void DrawSerie(VertexHelper vh)
+        {
+            if (serie.IsUseCoord<PolarCoord>())
+            {
+                DrawPolarLine(vh, serie);
+                DrawPolarLineSymbol(vh);
+            }
+            else if (serie.IsUseCoord<GridCoord>())
+            {
+                DrawLineSerie(vh, serie);
+
+                if (!SeriesHelper.IsStack(chart.series))
+                {
+                    DrawLinePoint(vh, serie);
+                    DrawLineArrow(vh, serie);
+                }
+            }
+        }
+
+        public override void DrawTop(VertexHelper vh)
+        {
+            if (serie.IsUseCoord<GridCoord>())
+            {
+                if (SeriesHelper.IsStack(chart.series))
+                {
+                    DrawLinePoint(vh, serie);
+                    DrawLineArrow(vh, serie);
+                }
+            }
+        }
+    }
+}

Runtime/Serie/Line/LineHandler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6e3a076ca3ee241c3b8b1088d4519dfa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Serie/Line/SimplifiedLine.cs

@@ -15,7 +15,7 @@ namespace XCharts
         public int containerIndex { get; internal set; }
         public int containterInstanceId { get; internal set; }
 
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<SimplifiedLine>(serieName);
             serie.symbol.show = false;
@@ -28,6 +28,7 @@ namespace XCharts
                     lastValue += UnityEngine.Random.Range(-3, 5);
                 chart.AddData(serie.index, lastValue);
             }
+            return serie;
         }
 
         public static SimplifiedLine CovertSerie(Serie serie)

Runtime/Serie/Liquid/Liquid.cs

@@ -50,7 +50,7 @@ namespace XCharts
         public int containerIndex { get { return vesselIndex; } }
         public int containterInstanceId { get; internal set; }
 
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             chart.AddChartComponentWhenNoExist<Vessel>();
             var serie = chart.AddSerie<Liquid>(serieName);
@@ -62,6 +62,7 @@ namespace XCharts
             serie.label.formatter = "{d}%";
             serie.label.textStyle.color = new Color32(70, 70, 240, 255);
             chart.AddData(serie.index, UnityEngine.Random.Range(0, 100));
+            return serie;
         }
     }
 }

Runtime/Serie/Parallel/Parallel.cs

@@ -11,7 +11,7 @@ namespace XCharts
     {
         public int containerIndex { get; internal set; }
         public int containterInstanceId { get; internal set; }
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<Parallel>(serieName);
             serie.lineStyle.width = 0.8f;
@@ -28,6 +28,7 @@ namespace XCharts
                 serie.AddData(data, "data" + i);
             }
             chart.RefreshChart();
+            return serie;
         }
     }
 }

Runtime/Serie/Pie/Pie.cs

@@ -10,12 +10,13 @@ namespace XCharts
     {
         public override bool useDataNameForColor { get { return true; } }
 
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<Pie>(serieName);
             chart.AddData(serie.index, 70, "pie1");
             chart.AddData(serie.index, 20, "pie2");
             chart.AddData(serie.index, 10, "pie3");
+            return serie;
         }
 
         public static Pie CovertSerie(Serie serie)

Runtime/Serie/Radar/Radar.cs

@@ -14,7 +14,7 @@ namespace XCharts
         public int containterInstanceId { get; internal set; }
 
         public override bool useDataNameForColor { get { return true; } }
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             chart.AddChartComponentWhenNoExist<RadarCoord>();
             var serie = chart.AddSerie<Radar>(serieName);
@@ -27,6 +27,7 @@ namespace XCharts
                 data.Add(Random.Range(20, 90));
             }
             chart.AddData(serie.index, data, "legendName");
+            return serie;
         }
     }
 }

Runtime/Serie/Ring/Ring.cs

@@ -9,7 +9,7 @@ namespace XCharts
     public class Ring : Serie
     {
         public override bool useDataNameForColor { get { return true; } }
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<Ring>(serieName);
             serie.roundCap = true;
@@ -24,6 +24,7 @@ namespace XCharts
             var value = Random.Range(30, 90);
             var max = 100;
             chart.AddData(serie.index, value, max, "data1");
+            return serie;
         }
     }
 }

Runtime/Serie/Scatter/EffectScatter.cs

@@ -9,7 +9,7 @@ namespace XCharts
     [SerieExtraComponent(typeof(LabelStyle), typeof(Emphasis))]
     public class EffectScatter : BaseScatter
     {
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<EffectScatter>(serieName);
             serie.symbol.show = true;
@@ -20,6 +20,7 @@ namespace XCharts
             {
                 chart.AddData(serie.index, Random.Range(10, 100), Random.Range(10, 100));
             }
+            return serie;
         }
     }
 }

Runtime/Serie/Scatter/Scatter.cs

@@ -11,7 +11,7 @@ namespace XCharts
     [SerieExtraComponent(typeof(LabelStyle), typeof(Emphasis))]
     public class Scatter : BaseScatter
     {
-        public static void AddDefaultSerie(BaseChart chart, string serieName)
+        public static Serie AddDefaultSerie(BaseChart chart, string serieName)
         {
             var serie = chart.AddSerie<Scatter>(serieName);
             serie.symbol.show = true;
@@ -22,6 +22,7 @@ namespace XCharts
             {
                 chart.AddData(serie.index, Random.Range(10, 100), Random.Range(10, 100));
             }
+            return serie;
         }
     }
 }

Runtime/Serie/SerieDataContext.cs

@@ -47,6 +47,7 @@ namespace XCharts
         public float angle { get; set; }
         public Vector3 offsetCenter { get; set; }
         public float stackHeight { get; set; }
+        public bool isClip { get; set; }
 
         public bool canShowLabel = true;
         public Image symbol { get; set; }