Ejemplo n.º 1
0
        private void DrawCenter(VertexHelper vh, Serie serie, SerieData serieData, float insideRadius, bool last)
        {
            var itemStyle = SerieHelper.GetItemStyle(serie, serieData);

            if (itemStyle.centerColor != Color.clear && last)
            {
                var radius     = insideRadius - itemStyle.centerGap;
                var smoothness = m_Settings.cicleSmoothness;
                ChartDrawer.DrawCricle(vh, serie.runtimeCenterPos, radius, itemStyle.centerColor, smoothness);
            }
        }
Ejemplo n.º 2
0
 private void DrawVesselBackground(VertexHelper vh)
 {
     for (int i = 0; i < m_Vessels.Count; i++)
     {
         var vessel = m_Vessels[i];
         if (vessel.backgroundColor.a != 0)
         {
             var cenPos = vessel.runtimeCenterPos;
             var radius = vessel.runtimeRadius;
             ChartDrawer.DrawCricle(vh, cenPos, vessel.runtimeInnerRadius, vessel.backgroundColor, m_Settings.cicleSmoothness);
         }
     }
 }
Ejemplo n.º 3
0
        protected void DrawSymbol(VertexHelper vh, SerieSymbolType type, float symbolSize,
                                  float tickness, Vector3 pos, Color color)
        {
            switch (type)
            {
            case SerieSymbolType.None:
                break;

            case SerieSymbolType.Circle:
                ChartDrawer.DrawCricle(vh, pos, symbolSize, color, GetSymbolCricleSegment(symbolSize));
                break;

            case SerieSymbolType.EmptyCircle:
                int segment = GetSymbolCricleSegment(symbolSize);
                ChartDrawer.DrawCricle(vh, pos, symbolSize, m_ThemeInfo.backgroundColor, segment);
                ChartDrawer.DrawDoughnut(vh, pos, symbolSize - tickness, symbolSize, 0, 360, color, segment);
                break;

            case SerieSymbolType.Rect:
                ChartDrawer.DrawPolygon(vh, pos, symbolSize, color);
                break;

            case SerieSymbolType.Triangle:
                var x  = symbolSize * Mathf.Cos(30 * Mathf.PI / 180);
                var y  = symbolSize * Mathf.Sin(30 * Mathf.PI / 180);
                var p1 = new Vector2(pos.x - x, pos.y - y);
                var p2 = new Vector2(pos.x, pos.y + symbolSize);
                var p3 = new Vector2(pos.x + x, pos.y - y);
                ChartDrawer.DrawTriangle(vh, p1, p2, p3, color);
                break;

            case SerieSymbolType.Diamond:
                p1 = new Vector2(pos.x - symbolSize, pos.y);
                p2 = new Vector2(pos.x, pos.y + symbolSize);
                p3 = new Vector2(pos.x + symbolSize, pos.y);
                var p4 = new Vector2(pos.x, pos.y - symbolSize);
                ChartDrawer.DrawPolygon(vh, p1, p2, p3, p4, color);
                break;
            }
        }
        void Awake()
        {
            chart = gameObject.GetComponent <LineChart>();
            if (chart == null)
            {
                return;
            }

            chart.customDrawCallback = delegate(VertexHelper vh)
            {
                var dataPoints = chart.series.list[0].dataPoints;
                if (dataPoints.Count > 0)
                {
                    var pos      = dataPoints[3];
                    var zeroPos  = new Vector3(chart.coordinateX, chart.coordinateY);
                    var startPos = new Vector3(pos.x, zeroPos.y);
                    var endPos   = new Vector3(pos.x, zeroPos.y + chart.coordinateHeight);
                    ChartDrawer.DrawLine(vh, startPos, endPos, 1, Color.blue);
                    ChartDrawer.DrawCricle(vh, pos, 5, Color.blue);
                }
            };
        }
Ejemplo n.º 5
0
        private void DrawLabelLine(VertexHelper vh, Serie serie, SerieData serieData, Color color)
        {
            if (serie.label.show &&
                serie.label.position == SerieLabel.Position.Outside &&
                serie.label.line)
            {
                var insideRadius  = serieData.runtimePieInsideRadius;
                var outSideRadius = serieData.runtimePieOutsideRadius;
                var center        = serie.runtimePieCenterPos;
                var currAngle     = serieData.runtimePieHalfAngle;
                if (serie.label.lineColor != Color.clear)
                {
                    color = serie.label.lineColor;
                }
                else if (serie.label.lineType == SerieLabel.LineType.HorizontalLine)
                {
                    color *= color;
                }
                float currSin = Mathf.Sin(currAngle * Mathf.Deg2Rad);
                float currCos = Mathf.Cos(currAngle * Mathf.Deg2Rad);
                var   radius1 = serie.label.lineType == SerieLabel.LineType.HorizontalLine ?
                                serie.runtimePieOutsideRadius : outSideRadius;
                var radius2 = serie.runtimePieOutsideRadius + serie.label.lineLength1;
                var radius3 = insideRadius + (outSideRadius - insideRadius) / 2;
                if (radius1 < serie.runtimePieInsideRadius)
                {
                    radius1 = serie.runtimePieInsideRadius;
                }
                radius1 -= 0.1f;
                var     pos0 = new Vector3(center.x + radius3 * currSin, center.y + radius3 * currCos);
                var     pos1 = new Vector3(center.x + radius1 * currSin, center.y + radius1 * currCos);
                var     pos2 = new Vector3(center.x + radius2 * currSin, center.y + radius2 * currCos);
                float   tx, ty;
                Vector3 pos3, pos4, pos6;
                var     horizontalLineCircleRadius = serie.label.lineWidth * 4f;
                var     lineCircleDiff             = horizontalLineCircleRadius - 0.3f;
                if (currAngle < 90)
                {
                    ty   = serie.label.lineWidth * Mathf.Cos((90 - currAngle) * Mathf.Deg2Rad);
                    tx   = serie.label.lineWidth * Mathf.Sin((90 - currAngle) * Mathf.Deg2Rad);
                    pos3 = new Vector3(pos2.x - tx, pos2.y + ty - serie.label.lineWidth);
                    var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3;
                    r4  += serie.label.lineLength1 - lineCircleDiff;
                    pos6 = pos0 + Vector3.right * lineCircleDiff;
                    pos4 = pos6 + Vector3.right * r4;
                }
                else if (currAngle < 180)
                {
                    ty   = serie.label.lineWidth * Mathf.Sin((180 - currAngle) * Mathf.Deg2Rad);
                    tx   = serie.label.lineWidth * Mathf.Cos((180 - currAngle) * Mathf.Deg2Rad);
                    pos3 = new Vector3(pos2.x - tx, pos2.y - ty + serie.label.lineWidth);
                    var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3;
                    r4  += serie.label.lineLength1 - lineCircleDiff;
                    pos6 = pos0 + Vector3.right * lineCircleDiff;
                    pos4 = pos6 + Vector3.right * r4;
                }
                else if (currAngle < 270)
                {
                    ty = serie.label.lineWidth * Mathf.Sin((180 + currAngle) * Mathf.Deg2Rad);
                    tx = serie.label.lineWidth * Mathf.Cos((180 + currAngle) * Mathf.Deg2Rad);
                    var currSin1 = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad);
                    var currCos1 = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad);
                    pos3 = new Vector3(pos2.x + tx, pos2.y - ty + serie.label.lineWidth);
                    var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos1 * radius3, 2)) - currSin1 * radius3;
                    r4  += serie.label.lineLength1 - lineCircleDiff;
                    pos6 = pos0 + Vector3.left * lineCircleDiff;
                    pos4 = pos6 + Vector3.left * r4;
                }
                else
                {
                    ty   = serie.label.lineWidth * Mathf.Cos((90 + currAngle) * Mathf.Deg2Rad);
                    tx   = serie.label.lineWidth * Mathf.Sin((90 + currAngle) * Mathf.Deg2Rad);
                    pos3 = new Vector3(pos2.x + tx, pos2.y + ty - serie.label.lineWidth);
                    var currSin1 = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad);
                    var currCos1 = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad);
                    var r4       = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos1 * radius3, 2)) - currSin1 * radius3;
                    r4  += serie.label.lineLength1 - lineCircleDiff;
                    pos6 = pos0 + Vector3.left * lineCircleDiff;
                    pos4 = pos6 + Vector3.left * r4;
                }
                var pos5 = new Vector3(currAngle > 180 ? pos3.x - serie.label.lineLength2 : pos3.x + serie.label.lineLength2, pos3.y);
                switch (serie.label.lineType)
                {
                case SerieLabel.LineType.BrokenLine:
                    ChartDrawer.DrawLine(vh, pos1, pos2, serie.label.lineWidth, color);
                    ChartDrawer.DrawLine(vh, pos3, pos5, serie.label.lineWidth, color);
                    break;

                case SerieLabel.LineType.Curves:
                    ChartDrawer.DrawCurves(vh, pos1, pos5, pos1, pos2, serie.label.lineWidth, color, m_Settings.lineSmoothness);
                    break;

                case SerieLabel.LineType.HorizontalLine:
                    ChartDrawer.DrawCricle(vh, pos0, horizontalLineCircleRadius, color);
                    ChartDrawer.DrawLine(vh, pos6, pos4, serie.label.lineWidth, color);
                    break;
                }
            }
        }
Ejemplo n.º 6
0
        protected void DrawSymbol(VertexHelper vh, SerieSymbolType type, float symbolSize,
                                  float tickness, Vector3 pos, Color color, Color toColor, float gap, float[] cornerRadius)
        {
            var backgroundColor = m_ThemeInfo.backgroundColor;
            var smoothness      = m_Settings.cicleSmoothness;

            switch (type)
            {
            case SerieSymbolType.None:
                break;

            case SerieSymbolType.Circle:
                if (gap > 0)
                {
                    ChartDrawer.DrawDoughnut(vh, pos, symbolSize, symbolSize + gap, backgroundColor, color, toColor, smoothness);
                }
                else
                {
                    ChartDrawer.DrawCricle(vh, pos, symbolSize, color, toColor, smoothness);
                }
                break;

            case SerieSymbolType.EmptyCircle:
                if (gap > 0)
                {
                    ChartDrawer.DrawCricle(vh, pos, symbolSize + gap, backgroundColor, smoothness);
                    ChartDrawer.DrawEmptyCricle(vh, pos, symbolSize, tickness, color, toColor, backgroundColor, smoothness);
                }
                else
                {
                    ChartDrawer.DrawEmptyCricle(vh, pos, symbolSize, tickness, color, toColor, backgroundColor, smoothness);
                }
                break;

            case SerieSymbolType.Rect:
                if (gap > 0)
                {
                    ChartDrawer.DrawPolygon(vh, pos, symbolSize + gap, backgroundColor);
                    ChartDrawer.DrawPolygon(vh, pos, symbolSize, color, toColor);
                }
                else
                {
                    //ChartDrawer.DrawPolygon(vh, pos, symbolSize, color, toColor);
                    ChartDrawer.DrawRoundRectangle(vh, pos, symbolSize, symbolSize, color, 0, cornerRadius);
                }
                break;

            case SerieSymbolType.Triangle:
                if (gap > 0)
                {
                    ChartDrawer.DrawTriangle(vh, pos, symbolSize + gap, backgroundColor);
                    ChartDrawer.DrawTriangle(vh, pos, symbolSize, color, toColor);
                }
                else
                {
                    ChartDrawer.DrawTriangle(vh, pos, symbolSize, color, toColor);
                }
                break;

            case SerieSymbolType.Diamond:
                if (gap > 0)
                {
                    ChartDrawer.DrawDiamond(vh, pos, symbolSize + gap, backgroundColor);
                    ChartDrawer.DrawDiamond(vh, pos, symbolSize, color, toColor);
                }
                else
                {
                    ChartDrawer.DrawDiamond(vh, pos, symbolSize, color, toColor);
                }
                break;
            }
        }
Ejemplo n.º 7
0
        private void DrawSerie(VertexHelper vh, Serie serie)
        {
            var vessel = GetVessel(serie.vesselIndex);

            if (vessel == null)
            {
                return;
            }
            var cenPos    = vessel.runtimeCenterPos;
            var radius    = vessel.runtimeInnerRadius;
            var serieData = serie.GetSerieData(0);

            if (serieData == null)
            {
                return;
            }

            var value = serieData.GetData(1);

            if (serie.runtimeCheckValue != value)
            {
                serie.runtimeCheckValue = value;
                m_UpdateLabelText       = true;
            }
            if (serieData.labelPosition != cenPos)
            {
                serieData.labelPosition = cenPos;
                m_UpdateLabelText       = true;
            }
            if (value == 0)
            {
                return;
            }
            var colorIndex = m_LegendRealShowName.IndexOf(serie.name);

            var realHig = (value - serie.min) / (serie.max - serie.min) * radius * 2;

            serie.animation.InitProgress(1, 0, realHig);

            var hig  = serie.animation.IsFinish() ? realHig : serie.animation.GetCurrDetail();
            var a    = Mathf.Abs(radius - hig + (hig > radius ? serie.waveHeight : -serie.waveHeight));
            var diff = Mathf.Sqrt(radius * radius - Mathf.Pow(a, 2));

            var color   = SerieHelper.GetItemColor(serie, serieData, m_ThemeInfo, colorIndex, false);
            var toColor = SerieHelper.GetItemToColor(serie, serieData, m_ThemeInfo, colorIndex, false);

            if (hig >= 2 * radius)
            {
                ChartDrawer.DrawCricle(vh, cenPos, radius, toColor, m_Settings.cicleSmoothness);
            }
            else
            {
                var startY       = cenPos.y - radius + hig;
                var waveStartPos = new Vector3(cenPos.x - diff, startY);
                var waveEndPos   = new Vector3(cenPos.x + diff, startY);
                var startX       = hig > radius ? cenPos.x - radius : waveStartPos.x;
                var endX         = hig > radius ? cenPos.x + radius : waveEndPos.x;

                var step = vessel.smoothness;
                if (step < 0.5f)
                {
                    step = 0.5f;
                }
                var lup   = hig > radius ? new Vector3(cenPos.x - radius, cenPos.y) : waveStartPos;
                var ldp   = lup;
                var nup   = Vector3.zero;
                var ndp   = Vector3.zero;
                var angle = 0f;
                serie.runtimeWaveSpeed += serie.waveSpeed * Time.deltaTime;
                var isStarted = false;
                var isEnded   = false;
                while (startX < endX)
                {
                    startX += step;
                    if (startX > endX)
                    {
                        startX = endX;
                    }
                    if (startX > waveStartPos.x && !isStarted)
                    {
                        startX    = waveStartPos.x;
                        isStarted = true;
                    }
                    if (startX > waveEndPos.x && !isEnded)
                    {
                        startX  = waveEndPos.x;
                        isEnded = true;
                    }
                    var py = Mathf.Sqrt(Mathf.Pow(radius, 2) - Mathf.Pow(Mathf.Abs(cenPos.x - startX), 2));
                    if (startX < waveStartPos.x || startX > waveEndPos.x)
                    {
                        nup = new Vector3(startX, cenPos.y + py);
                    }
                    else
                    {
                        var py2  = serie.waveHeight * Mathf.Sin(1 / serie.waveLength * angle + serie.runtimeWaveSpeed + serie.waveOffset);
                        var nupY = waveStartPos.y + py2;
                        if (nupY > cenPos.y + py)
                        {
                            nupY = cenPos.y + py;
                        }
                        else if (nupY < cenPos.y - py)
                        {
                            nupY = cenPos.y - py;
                        }
                        nup    = new Vector3(startX, nupY);
                        angle += step;
                    }
                    ndp = new Vector3(startX, cenPos.y - py);
                    if (!ChartHelper.IsValueEqualsColor(color, toColor))
                    {
                        var colorMin = cenPos.y - radius;
                        var colorMax = startY + serie.waveHeight;
                        var tcolor1  = Color.Lerp(color, toColor, 1 - (lup.y - colorMin) / (colorMax - colorMin));
                        var tcolor2  = Color.Lerp(color, toColor, 1 - (ldp.y - colorMin) / (colorMax - colorMin));
                        ChartDrawer.DrawPolygon(vh, lup, nup, ndp, ldp, tcolor1, tcolor2);
                    }
                    else
                    {
                        ChartDrawer.DrawPolygon(vh, lup, nup, ndp, ldp, color);
                    }
                    lup = nup;
                    ldp = ndp;
                }
            }

            if (serie.waveSpeed != 0 && Application.isPlaying)
            {
                RefreshChart();
            }
            if (!serie.animation.IsFinish())
            {
                serie.animation.CheckProgress(realHig);
                m_IsPlayingAnimation = true;
                RefreshChart();
            }
        }