Ejemplo n.º 1
0
        public void DrawSymbol(VertexHelper vh, SerieSymbolType type, float symbolSize,
                               float tickness, Vector3 pos, Color color, Color toColor, float gap, float[] cornerRadius)
        {
            var backgroundColor = ThemeHelper.GetBackgroundColor(m_ThemeInfo, m_Background);
            var smoothness      = m_Settings.cicleSmoothness;

            ChartDrawer.DrawSymbol(vh, type, symbolSize, tickness, pos, color, toColor, gap,
                                   cornerRadius, backgroundColor, smoothness);
        }
Ejemplo n.º 2
0
 public void Reset()
 {
     m_Show                 = false;
     m_Type                 = SerieSymbolType.EmptyCircle;
     m_SizeType             = SerieSymbolSizeType.Custom;
     m_Size                 = 0f;
     m_SelectedSize         = 0f;
     m_DataIndex            = 1;
     m_DataScale            = 1;
     m_SelectedDataScale    = 1.5f;
     m_SizeCallback         = null;
     m_SelectedSizeCallback = null;
     m_StartIndex           = 0;
     m_Interval             = 0;
     m_ForceShowLast        = false;
     m_Gap = 0;
 }
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:
                ChartHelper.DrawCricle(vh, pos, symbolSize, color, GetSymbolCricleSegment(symbolSize));
                break;

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

            case SerieSymbolType.Rect:
                ChartHelper.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);
                ChartHelper.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);
                ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color);
                break;
            }
        }
Ejemplo n.º 4
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, m_Settings.cicleSmoothness);
                break;

            case SerieSymbolType.EmptyCircle:
                ChartDrawer.DrawEmptyCricle(vh, pos, symbolSize, tickness, color, m_ThemeInfo.backgroundColor, m_Settings.cicleSmoothness);
                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;
            }
        }
 public void Reset()
 {
     m_Show                 = false;
     m_Type                 = SerieSymbolType.EmptyCircle;
     m_SizeType             = SerieSymbolSizeType.Custom;
     m_Size                 = 0f;
     m_SelectedSize         = 0f;
     m_DataIndex            = 1;
     m_DataScale            = 1;
     m_SelectedDataScale    = 1.5f;
     m_SizeCallback         = null;
     m_SelectedSizeCallback = null;
     m_StartIndex           = 0;
     m_Interval             = 0;
     m_ForceShowLast        = false;
     m_Gap       = 0;
     m_Width     = 0f;
     m_Height    = 0f;
     m_Repeat    = false;
     m_Offset    = Vector2.zero;
     m_Image     = null;
     m_ImageType = Image.Type.Simple;
 }
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;
            }
        }
        public static void DrawSymbol(VertexHelper vh, SerieSymbolType type, float symbolSize,
                                      float tickness, Vector3 pos, Color32 color, Color32 toColor, float gap, float[] cornerRadius,
                                      Color32 backgroundColor, float smoothness, Vector3 startPos)
        {
            switch (type)
            {
            case SerieSymbolType.None:
                break;

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

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

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

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

            case SerieSymbolType.Diamond:
                if (gap > 0)
                {
                    UGL.DrawDiamond(vh, pos, symbolSize + gap, backgroundColor);
                    UGL.DrawDiamond(vh, pos, symbolSize, color, toColor);
                }
                else
                {
                    UGL.DrawDiamond(vh, pos, symbolSize, color, toColor);
                }
                break;

            case SerieSymbolType.Arrow:
                var arrowWidth  = symbolSize * 2;
                var arrowHeight = arrowWidth * 1.5f;
                var arrowOffset = 0;
                var arrowDent   = arrowWidth / 3.3f;
                UGL.DrawArrow(vh, startPos, pos, arrowWidth, arrowHeight,
                              arrowOffset, arrowDent, color);
                break;
            }
        }
 public void DrawSymbol(VertexHelper vh, SerieSymbolType type, float symbolSize,
                        float tickness, Vector3 pos, Color32 color, Color32 toColor, float gap, float[] cornerRadius)
 {
     DrawSymbol(vh, type, symbolSize, tickness, pos, color, toColor, gap, cornerRadius, Vector3.zero);
 }
Ejemplo n.º 9
0
        public static void DrawSymbol(VertexHelper vh, SerieSymbolType type, float symbolSize,
                                      float tickness, Vector3 pos, Color32 color, Color32 toColor, float gap, float[] cornerRadius,
                                      Color32 backgroundColor, float smoothness)
        {
            switch (type)
            {
            case SerieSymbolType.None:
                break;

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

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

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

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

            case SerieSymbolType.Diamond:
                if (gap > 0)
                {
                    UGL.DrawDiamond(vh, pos, symbolSize + gap, backgroundColor);
                    UGL.DrawDiamond(vh, pos, symbolSize, color, toColor);
                }
                else
                {
                    UGL.DrawDiamond(vh, pos, symbolSize, color, toColor);
                }
                break;
            }
        }