重命名为xcharts

Demo.cs

@@ -0,0 +1,23 @@
+using UnityEngine;
+using xcharts;
+
+public class Demo : MonoBehaviour
+{
+    private LineChart lineChart;
+    private float time;
+
+    void Awake () {
+        lineChart = transform.Find("line_chart").GetComponent<LineChart>();
+    }
+
+	void Update () {
+        time += Time.deltaTime;
+        if (time >= 1)
+        {
+            time = 0;
+            lineChart.AddPoint("fps", Random.Range(24.0f, 60.0f));
+            lineChart.AddPoint("rtt", Random.Range(15, 30));
+            lineChart.AddPoint("ping", Random.Range(0, 100));
+        }
+    }
+}

Demo.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: e6bd57e81d68cac47a78ccb7a452c8d7
+timeCreated: 1536708123
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: dd29cbce72290724b8772e66460b2a1d
+folderAsset: yes
+timeCreated: 1536101222
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/BarChart.cs

@@ -0,0 +1,101 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace xcharts
+{
+    [System.Serializable]
+    public class BarGroup
+    {
+        [SerializeField]
+        public string name;
+        [SerializeField]
+        public Color color;
+    }
+
+    [System.Serializable]
+    public class BarData
+    {
+        [SerializeField]
+        public string group;
+        [SerializeField]
+        public string key;
+        [SerializeField]
+        public float value;
+    }
+
+    public class BarChart : MaskableGraphic
+    {
+        [SerializeField]
+        private float keyRectWidth = 50;
+        [SerializeField]
+        private float valueRectWidth = 50;
+        [SerializeField]
+        private float barWidth = 50;
+        [SerializeField]
+        private float barSpace = 20;
+        [SerializeField] 
+        private Color backgroundColor = Color.black;
+
+        [SerializeField]
+        private List<BarGroup> groupList = new List<BarGroup>();
+        [SerializeField]
+        private List<BarData> dataList = new List<BarData>();
+
+        private float dataTotal = 0;
+        private List<Text> keyTextList = new List<Text>();
+        private List<Text> valueTextList = new List<Text>();
+
+        private float chartWid { get { return rectTransform.sizeDelta.x; } }
+        private float chartHig { get { return rectTransform.sizeDelta.y; } }
+        
+
+        void Awake()
+        {
+            dataTotal = getDataTotal();
+        }
+
+        void Update()
+        {
+
+        }
+
+        private float getDataTotal()
+        {
+            float total = 0;
+            foreach (var data in dataList)
+            {
+                total += data.value;
+            }
+            return total;
+        }
+
+        protected override void OnPopulateMesh(VertexHelper vh)
+        {
+            vh.Clear();
+            // draw bg
+            Vector3 p1 = new Vector3(-keyRectWidth, 0);
+            Vector3 p2 = new Vector3(chartWid, 0);
+            Vector3 p3 = new Vector3(chartWid, -chartHig);
+            Vector3 p4 = new Vector3(-keyRectWidth, -chartHig);
+            ChartUtils.DrawPolygon(vh, p1, p2, p3, p4, backgroundColor);
+
+            //draw data bar
+
+            dataTotal = getDataTotal();
+            for(int i=0;i<dataList.Count;i++)
+            {
+                BarData data = dataList[i];
+                float barLen = data.value / dataTotal * (chartWid - valueRectWidth);
+                float posY = i * (barWidth + barSpace);
+                p1 = new Vector3(0,-posY);
+                p2 = new Vector3(barLen, -posY);
+                p3 = new Vector3(barLen, -(posY + barWidth));
+                p4 = new Vector3(0, -(posY + barWidth));
+                ChartUtils.DrawPolygon(vh, p1, p2, p3, p4, Color.grey);
+            }
+
+            ChartUtils.DrawLine(vh, new Vector3(0, 0), new Vector3(0, -chartHig), 1.5f, Color.white);
+        }
+    }
+}

Scripts/BarChart.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 535d2697503c2a94a887354e22a5414d
+timeCreated: 1536795169
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/ChartUtils.cs

@@ -0,0 +1,177 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace xcharts
+{
+    public static class ChartUtils
+    {
+        public static Text AddTextObject(string name, Transform parent, Font font, TextAnchor anchor,
+            Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 sizeDelta)
+        {
+            GameObject txtObj;
+            if (parent.Find(name))
+            {
+                txtObj = parent.Find(name).gameObject;
+                txtObj.SetActive(true);
+            }
+            else
+            {
+                txtObj = new GameObject();
+                txtObj.name = name;
+                txtObj.transform.parent = parent;
+                txtObj.transform.localPosition = Vector3.zero;
+                txtObj.transform.localScale = Vector3.one;
+                Text txt = txtObj.AddComponent<Text>();
+                txt.font = font;
+                txt.text = "Text";
+                txt.alignment = anchor;
+                txt.horizontalOverflow = HorizontalWrapMode.Overflow;
+                txt.verticalOverflow = VerticalWrapMode.Overflow;
+            }
+            RectTransform rect = txtObj.GetComponent<RectTransform>();
+            rect.anchorMin = anchorMin;
+            rect.anchorMax = anchorMax;
+            rect.pivot = pivot;
+            rect.sizeDelta = sizeDelta;
+            return txtObj.GetComponent<Text>();
+        }
+
+        public static Button AddButtonObject(string name,Transform parent,Font font,
+            Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 sizeDelta)
+        {
+            GameObject btnObj;
+            if (parent.Find(name))
+            {
+                btnObj = parent.Find(name).gameObject;
+                btnObj.SetActive(true);
+            }
+            else
+            {
+                btnObj = new GameObject();
+                btnObj.name = name;
+                btnObj.transform.parent = parent;
+                btnObj.transform.localPosition = Vector3.zero;
+                btnObj.transform.localScale = Vector3.one;
+                btnObj.AddComponent<Image>();
+                btnObj.AddComponent<Button>();
+
+                Text txt = AddTextObject("Text", btnObj.transform, font, TextAnchor.MiddleCenter, Vector2.zero,
+                    Vector2.zero, Vector2.zero, sizeDelta);
+                txt.text = "Text";
+            }
+            RectTransform rect = btnObj.GetComponent<RectTransform>();
+            if (rect == null)
+            {
+                rect = btnObj.AddComponent<RectTransform>();
+            }
+            rect.anchorMax = anchorMax;
+            rect.anchorMin = anchorMin;
+            rect.pivot = pivot;
+            rect.sizeDelta = sizeDelta;
+            return btnObj.GetComponent<Button>();
+        }
+
+        public static void DrawLine(VertexHelper vh, Vector3 p1, Vector3 p2, float size, Color color)
+        {
+            Vector3 v = Vector3.Cross(p2 - p1, Vector3.forward).normalized * size;
+
+            UIVertex[] vertex = new UIVertex[4];
+            vertex[0].position = p1 + v;
+            vertex[1].position = p2 + v;
+            vertex[2].position = p2 - v;
+            vertex[3].position = p1 - v;
+            for (int j = 0; j < 4; j++)
+            {
+                vertex[j].color = color;
+                vertex[j].uv0 = Vector2.zero;
+            }
+            vh.AddUIVertexQuad(vertex);
+        }
+
+        public static void DrawPolygon(VertexHelper vh, Vector3 p, float size, Color color)
+        {
+            Vector3 p1 = new Vector3(p.x - size, p.y - size);
+            Vector3 p2 = new Vector3(p.x + size, p.y - size);
+            Vector3 p3 = new Vector3(p.x + size, p.y + size);
+            Vector3 p4 = new Vector3(p.x - size, p.y + size);
+            DrawPolygon(vh, p1, p2, p3, p4, color);
+        }
+
+        public static void DrawPolygon(VertexHelper vh, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4,
+            Color color)
+        {
+            UIVertex[] vertex = new UIVertex[4];
+            vertex[0].position = p1;
+            vertex[1].position = p2;
+            vertex[2].position = p3;
+            vertex[3].position = p4;
+            for (int j = 0; j < 4; j++)
+            {
+                vertex[j].color = color;
+                vertex[j].uv0 = Vector2.zero;
+            }
+            vh.AddUIVertexQuad(vertex);
+        }
+
+        public static void DrawTriangle(VertexHelper vh, Vector3 p1, Vector3 p2, Vector3 p3, 
+            Color color)
+        {
+            List<UIVertex> vertexs = new List<UIVertex>();
+            vh.GetUIVertexStream(vertexs);
+            DrawTriangle(vh, vertexs, p1, p2, p3, color);
+        }
+
+        public static void DrawTriangle(VertexHelper vh, List<UIVertex> vertexs, Vector3 p1, 
+            Vector3 p2, Vector3 p3, Color color)
+        {
+            UIVertex v1 = new UIVertex();
+            v1.position = p1;
+            v1.color = color;
+            v1.uv0 = Vector3.zero;
+            vertexs.Add(v1);
+            UIVertex v2 = new UIVertex();
+            v2.position = p2;
+            v2.color = color;
+            v2.uv0 = Vector3.zero;
+            vertexs.Add(v2);
+            UIVertex v3 = new UIVertex();
+            v3.position = p3;
+            v3.color = color;
+            v3.uv0 = Vector3.zero;
+            vertexs.Add(v3);
+            vh.AddUIVertexTriangleStream(vertexs);
+        }
+
+        public static void DrawCricle(VertexHelper vh, Vector3 p, float radius, Color color, 
+            int segments)
+        {
+            List<UIVertex> vertexs = new List<UIVertex>();
+            vh.GetUIVertexStream(vertexs);
+            float angle = 2 * Mathf.PI / segments;
+            float cos = Mathf.Cos(angle);
+            float sin = Mathf.Sin(angle);
+            float cx = radius, cy = 0;
+
+            List<UIVertex> vs = new List<UIVertex>();
+
+            segments--;
+            Vector3 p2, p3;
+            for (int i = 0; i < segments; i++)
+            {
+                p2 = new Vector3(p.x + cx, p.y + cy);
+                float temp = cx;
+                cx = cos * cx - sin * cy;
+                cy = sin * temp + cos * cy;
+                p3 = new Vector3(p.x + cx, p.y + cy);
+                DrawTriangle(vh, vertexs, p, p2, p3, color);
+            }
+            p2 = new Vector3(p.x + cx, p.y + cy);
+            cx = radius;
+            cy = 0;
+            p3 = new Vector3(p.x + cx, p.y + cy);
+            DrawTriangle(vh, vertexs, p, p2, p3, color);
+        }
+
+    }
+}

Scripts/ChartUtils.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 049a2733eed58154eb8336d4e17312ad
+timeCreated: 1536792022
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/LineChart.cs

@@ -0,0 +1,462 @@
+
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace xcharts
+{
+    [System.Serializable]
+    public class LineData
+    {
+        [SerializeField]
+        public string name;
+        [SerializeField]
+        public string key;
+        [SerializeField]
+        public Color lineColor;
+        [SerializeField]
+        public Color pointColor;
+        [SerializeField]
+        public Button button;
+
+        private List<float> _dataList = new List<float>();
+        public List<float> dataList
+        {
+            get { return _dataList; }
+        }
+
+        private bool _visible = true;
+        public bool visible
+        {
+            get { return _visible; }
+            set
+            {
+                _visible = value;
+                if (button)
+                {
+                    button.GetComponent<Image>().color = visible ? lineColor : Color.grey;
+                }
+            }
+        }
+
+        private int _min = 0;
+        public int min
+        {
+            get { return _min; }
+        }
+
+        private int _max = 10;
+        public int max
+        {
+            get { return _max; }
+        }
+        private int _step = 10;
+        public int step
+        {
+            get { return _step; }
+            set { _step = value; }
+        }
+
+        public void AddData(float data, int maxCount)
+        {
+            dataList.Add(data);
+            if (dataList.Count > maxCount)
+            {
+                dataList.RemoveAt(0);
+                UpdateMinMax();
+            }
+            else
+            {
+                if (data < _min)
+                {
+                    _min = (int)data;
+                }
+                if (data > _max)
+                {
+                    _max = (int)data;
+                }
+                CheckMax();
+            }
+        }
+
+        public void ClearData()
+        {
+            _dataList.Clear();
+        }
+
+        public void UpdateMinMax()
+        {
+            _min = 0;
+            _max = 4;
+            foreach (var data in dataList)
+            {
+                if (data < _min)
+                {
+                    _min = (int)data;
+                }
+                if (data > _max)
+                {
+                    _max = (int)data;
+                }
+            }
+            CheckMax();
+        }
+
+        private void CheckMax()
+        {
+            if (_max <= 10)
+            {
+                if (_max < 4) _max = 4;
+            }
+            else
+            {
+                int diff = _max % _step;
+                if (diff > 1)
+                {
+                    _max = (_max - diff) + _step;
+                }
+            }
+        }
+    }
+
+    public class LineChart : MaskableGraphic
+    {
+        private const int MAX_GRADUATION = 10;
+
+        [SerializeField]
+        private int pointWidth = 15;
+        [SerializeField]
+        private float lineSize = 1f;
+        [SerializeField]
+        private float pointSize = 1.5f;
+        [SerializeField]
+        private int graduationCount = 4;
+        [SerializeField]
+        private int graduationStep = 10;
+        [SerializeField]
+        private int graduationWidth = 50;
+
+        private float arrowLen = 10;
+        private float arrowSize = 6;
+
+        [SerializeField]
+        private Color backgroundColor;
+        [SerializeField]
+        private Font font;
+        
+        [SerializeField]
+        private List<LineData> lineList = new List<LineData>();
+
+        private Button btnAll;
+        private bool isShowAll = true;
+        private List<Text> graduationList = new List<Text>();
+        private Dictionary<string, LineData> lineMap = new Dictionary<string, LineData>();
+        private float lastMaxData = 0;
+        private float lastChartHig = 0;
+        private float lastGraduationWid = 0;
+
+        private float chartWid { get { return rectTransform.sizeDelta.x; } }
+        private float chartHig { get { return rectTransform.sizeDelta.y; } }
+
+        protected override void Awake()
+        {
+            base.Awake();
+            InitGraduation();
+            InitLineButton();
+            InitHideAndShowButton();
+            for (int i = 0; i < lineList.Count; i++)
+            {
+                LineData line = lineList[i];
+                line.dataList.Clear();
+                if (line.button)
+                {
+                    Color bcolor = line.visible ? line.lineColor : Color.grey;
+                    line.button.GetComponent<Image>().color = bcolor;
+                    line.button.GetComponentInChildren<Text>().text = line.name;
+                    line.button.onClick.AddListener(delegate ()
+                    {
+                        OnClickButton(line.key);
+                    });
+                }
+                AddLineToLineMap(line);
+            }
+        }
+
+        private void InitGraduation()
+        {
+            float graduationHig = chartHig / graduationCount;
+            for (int i = 0; i < MAX_GRADUATION; i++)
+            {
+                if (i >= graduationCount + 1)
+                {
+                    if (transform.Find("graduation" + i))
+                    {
+                        transform.Find("graduation" + i).gameObject.SetActive(false);
+                    }
+                }
+                else
+                {
+                    Text txt = ChartUtils.AddTextObject("graduation" + i, transform, font, 
+                        TextAnchor.MiddleRight, Vector2.zero,Vector2.zero, new Vector2(1,0.5f), 
+                        new Vector2(50, 20));
+                    txt.transform.localPosition = new Vector3(-8, i * graduationHig, 0);
+                    txt.text = (i * 100).ToString();
+                    graduationList.Add(txt);
+                }
+            }
+        }
+
+        private void InitLineButton()
+        {
+            for (int i = 0; i < lineList.Count; i++)
+            {
+                if (lineList[i].button) continue;
+                Button btn = ChartUtils.AddButtonObject("button" + i, transform, font, Vector2.zero,
+                    Vector2.zero, Vector2.zero, new Vector2(50, 20));
+                btn.transform.localPosition = new Vector3(i * 50, chartHig + 30, 0);
+                lineList[i].button = btn;
+            }
+        }
+
+        private void InitHideAndShowButton()
+        {
+            if (lineList.Count <= 0) return;
+            btnAll = ChartUtils.AddButtonObject("buttonall", transform, font, Vector2.zero,
+                    Vector2.zero, Vector2.zero, new Vector2(graduationWidth, 20));
+            btnAll.transform.localPosition = new Vector3(-graduationWidth, chartHig + 30, 0);
+            btnAll.GetComponentInChildren<Text>().text = isShowAll ? "HIDE" : "SHOW";
+            btnAll.GetComponent<Image>().color = backgroundColor;
+            btnAll.onClick.AddListener(delegate ()
+            {
+                isShowAll = !isShowAll;
+                btnAll.GetComponentInChildren<Text>().text = isShowAll ? "HIDE" : "SHOW";
+                foreach(var line in lineList)
+                {
+                    line.visible = isShowAll;
+                }
+            });
+        }
+
+        private void Update()
+        {
+            CheckLineSizeChange();
+        }
+
+        void OnClickButton(string key)
+        {
+            LineData line = lineMap[key];
+            line.visible = !line.visible;
+            if (line.visible)
+            {
+                line.step = graduationStep;
+                line.UpdateMinMax();
+            }
+            CheckMaxDataChange();
+            UpdateMesh();
+        }
+
+        private void AddLineToLineMap(LineData line)
+        {
+            if (lineMap.ContainsKey(line.key))
+            {
+                Debug.LogError("LineChart:line key is duplicated:" + line.key);
+            }
+            else
+            {
+                lineMap[line.key] = line;
+            }
+        }
+
+        private float GetAllLineMax()
+        {
+            float max = 4;
+            foreach (var line in lineList)
+            {
+                if (line.visible && line.max > max)
+                {
+                    max = line.max;
+                }
+            }
+            return max;
+        }
+
+        public int GetMaxPointCount()
+        {
+            int max = (int)(chartWid / pointWidth);
+            return max;
+        }
+
+        public void AddLine(string key, string name, Color lineColor, Color pointColor)
+        {
+            LineData line = new LineData();
+            line.key = key;
+            line.name = name;
+            line.lineColor = lineColor;
+            line.pointColor = pointColor;
+            lineList.Add(line);
+            AddLineToLineMap(line);
+        }
+
+        public void AddPoint(string key, float point)
+        {
+            if (!lineMap.ContainsKey(key))
+            {
+                Debug.LogError("LineChart:not contain line key:" + key);
+                return;
+            }
+            LineData line = lineMap[key];
+            line.AddData(point, GetMaxPointCount());
+            UpdateMesh();
+            CheckMaxDataChange();
+        }
+
+        public void ResetDataStart()
+        {
+            foreach (var line in lineList)
+            {
+                line.ClearData();
+            }
+        }
+
+        public void ResetData(string key, float data)
+        {
+            if (!lineMap.ContainsKey(key))
+            {
+                Debug.LogError("LineChart:not contain line key:" + key);
+                return;
+            }
+            LineData line = lineMap[key];
+            line.AddData(data, GetMaxPointCount());
+        }
+
+        public void ResetDataEnd()
+        {
+            foreach (var line in lineList)
+            {
+                line.UpdateMinMax();
+            }
+            UpdateMesh();
+            CheckMaxDataChange();
+        }
+
+        private void UpdateMesh()
+        {
+            int tempWid = (int)chartWid;
+            rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, tempWid - 1);
+            rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, tempWid);
+        }
+
+        private void CheckLineSizeChange()
+        {
+            if (lastChartHig != chartHig)
+            {
+                lastChartHig = chartHig;
+                //update graduation pos
+                for (int i = 0; i < graduationList.Count; i++)
+                {
+                    Vector3 pos = graduationList[i].rectTransform.localPosition;
+                    float posY = lastChartHig * i / (graduationList.Count - 1);
+                    graduationList[i].rectTransform.localPosition = new Vector3(pos.x, posY, pos.z);
+                }
+                //update line button pos
+                btnAll.transform.localPosition = new Vector3(-graduationWidth, chartHig + 30, 0);
+                for (int i = 0; i < lineList.Count; i++)
+                {
+                    LineData line = lineList[i];
+                    if (line.button)
+                    {
+                        line.button.transform.localPosition = new Vector3(i * 50, chartHig + 30, 0);
+                    }
+                }
+            }
+            if(lastGraduationWid != graduationWidth)
+            {
+                if (graduationWidth < 40) graduationWidth = 40;
+                lastGraduationWid = graduationWidth;
+                Vector2 sizeDelta = new Vector2(graduationWidth, 20);
+                btnAll.GetComponent<RectTransform>().sizeDelta = sizeDelta;
+                btnAll.transform.Find("Text").GetComponent<RectTransform>().sizeDelta = sizeDelta;
+                btnAll.transform.localPosition = new Vector3(-graduationWidth, chartHig + 30, 0);
+            }
+        }
+
+        private void CheckMaxDataChange()
+        {
+            float dataMax = GetAllLineMax();
+            if (lastMaxData != dataMax)
+            {
+                lastMaxData = dataMax;
+                for (int i = 0; i < graduationList.Count; i++)
+                {
+                    graduationList[i].text = ((int)(dataMax * i / graduationList.Count)).ToString();
+                }
+            }
+        }
+
+        protected override void OnPopulateMesh(VertexHelper vh)
+        {
+            vh.Clear();
+            int dataRectWid = (int)(chartWid / pointWidth) * pointWidth;
+            float dataMax = GetAllLineMax();
+            // draw bg
+            Vector3 p1 = new Vector3(-graduationWidth, chartHig + 30);
+            Vector3 p2 = new Vector3(dataRectWid + 50, chartHig + 30);
+            Vector3 p3 = new Vector3(dataRectWid + 50, -20);
+            Vector3 p4 = new Vector3(-graduationWidth, -20);
+            ChartUtils.DrawPolygon(vh, p1, p2, p3, p4, backgroundColor);
+            // draw coordinate
+            Vector3 coordZero = Vector3.zero;
+            ChartUtils.DrawLine(vh, new Vector3(dataRectWid + 5, -5), 
+                new Vector3(dataRectWid + 5, chartHig + 0.5f), 1, Color.grey);
+            // draw graduation
+            for (int i = 0; i < graduationList.Count; i++)
+            {
+                Vector3 sp = new Vector3(-5, chartHig * i / (graduationList.Count - 1));
+                Vector3 ep = new Vector3(dataRectWid + 5, chartHig * i / (graduationList.Count - 1));
+                ChartUtils.DrawLine(vh, sp, ep, 0.5f, Color.grey);
+            }
+
+            // draw line
+            for (int index = 0; index < lineList.Count; index++)
+            {
+                LineData line = lineList[index];
+                if (!line.visible) continue;
+                Vector3 lp = Vector3.zero;
+                Vector3 np = Vector3.zero;
+
+                for (int i = 0; i < line.dataList.Count; i++)
+                {
+                    float data = line.dataList[i] * chartHig / dataMax;
+                    np = new Vector3(i * pointWidth, data);
+                    if (i > 0)
+                    {
+                        ChartUtils.DrawLine(vh, lp, np, lineSize, line.lineColor);
+                    }
+                    lp = np;
+                }
+
+                // draw point
+                for (int i = 0; i < line.dataList.Count; i++)
+                {
+                    UIVertex[] quadverts = new UIVertex[4];
+                    float data = line.dataList[i] * chartHig / dataMax;
+                    Vector3 p = new Vector3(i * pointWidth, data);
+                    ChartUtils.DrawPolygon(vh, p, pointSize, line.pointColor);
+                }
+            }
+
+            //draw x,y axis
+            float xLen = dataRectWid + 25;
+            float yLen = chartHig + 15;
+            float xPos = 0;
+            float yPos = -5;
+            ChartUtils.DrawLine(vh, new Vector3(xPos, yPos - 1.5f), new Vector3(xPos, yLen), 1.5f, Color.white);
+            ChartUtils.DrawLine(vh, new Vector3(xPos, yPos), new Vector3(xLen, yPos), 1.5f, Color.white);
+            //draw arrows
+            ChartUtils.DrawTriangle(vh, new Vector3(xPos - arrowSize, yLen - arrowLen), new Vector3(xPos, yLen + 4), 
+                new Vector3(xPos + arrowSize, yLen - arrowLen), Color.white);
+            ChartUtils.DrawTriangle(vh, new Vector3(xLen - arrowLen, yPos + arrowSize), new Vector3(xLen + 4, yPos),
+                new Vector3(xLen - arrowLen, yPos - arrowSize), Color.white);
+        }
+    }
+}

Scripts/LineChart.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: b4f38bd00b4648c448cabfc167538f7c
+timeCreated: 1536101435
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

demo.unity.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a5b436c986812794a9b741314e4a43bd
+timeCreated: 1536101749
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: