Пример #1
0
        void Triangle(Tesselate_Tests.Vertex Vertex1, Tesselate_Tests.Vertex Vertex2, Tesselate_Tests.Vertex Vertex3,
                      RendererBase renderer)
        {
            PathStorage triangle = new PathStorage();

            triangle.move_to(Vertex1.m_X * m_Scale + m_XOffset, Vertex1.m_Y * m_Scale + m_YOffset);
            triangle.line_to(Vertex2.m_X * m_Scale + m_XOffset, Vertex2.m_Y * m_Scale + m_YOffset);
            triangle.line_to(Vertex3.m_X * m_Scale + m_XOffset, Vertex3.m_Y * m_Scale + m_YOffset);

            renderer.Render(triangle, m_TriangleColor.GetAsRGBA_Bytes());
        }
Пример #2
0
        void Line(Tesselate_Tests.Vertex Vertex1, Tesselate_Tests.Vertex Vertex2, double lineWidth, RendererBase renderer, bool ArrowTip)
        {
            PathStorage line = new PathStorage();

            line.move_to(Vertex1.m_X * m_Scale + m_XOffset, Vertex1.m_Y * m_Scale + m_YOffset);
            line.line_to(Vertex2.m_X * m_Scale + m_XOffset, Vertex2.m_Y * m_Scale + m_YOffset);

            // Drawing as an outline
            conv_stroke wideLine = new conv_stroke(line);

            wideLine.width(lineWidth);

            renderer.Render(wideLine, m_LineColor.GetAsRGBA_Bytes());

            if (ArrowTip)
            {
                Ellipse Dot = new Ellipse(
                    (Vertex2.m_X * m_Scale * 9 + Vertex1.m_X * m_Scale) / 10 + m_XOffset,
                    (Vertex2.m_Y * m_Scale * 9 + Vertex1.m_Y * m_Scale) / 10 + m_YOffset, 3, 3);
                GetRenderer().Render(Dot, m_LineColor.GetAsRGBA_Bytes());
            }
        }
Пример #3
0
        public override void OnDraw()
        {
            GetRenderer().Clear(new RGBA_Doubles(1, 1, 1));

            Tesselator tesselator = new Tesselator();

            tesselator.callBegin   += new Tesselator.CallBeginDelegate(BeginCallBack);
            tesselator.callEnd     += new Tesselator.CallEndDelegate(EndCallBack);
            tesselator.callVertex  += new Tesselator.CallVertexDelegate(VertexCallBack);
            tesselator.callCombine += new Tesselator.CallCombineDelegate(CombineCallBack);

            switch (m_WindingRule.cur_item())
            {
            case 0:
                tesselator.windingRule = Tesselator.WindingRuleType.Odd;
                break;

            case 1:
                tesselator.windingRule = Tesselator.WindingRuleType.NonZero;
                break;

            case 2:
                tesselator.windingRule = Tesselator.WindingRuleType.Positive;
                break;

            case 3:
                tesselator.windingRule = Tesselator.WindingRuleType.Negative;
                break;

            case 4:
                tesselator.windingRule = Tesselator.WindingRuleType.ABS_GEQ_Two;
                break;
            }

            if (m_EdgeFlag.status())
            {
                tesselator.callEdgeFlag += new Tesselator.CallEdgeFlagDelegate(EdgeFlagCallBack);
            }

            if (m_BoundryOnly.status()) // edgesOnly
            {
                tesselator.BoundaryOnly = true;
            }

            m_TesselateTest.ParseStreamForTesselator(tesselator, m_WhichShape.cur_item());

            // now render the outline
            {
                string[] instructionStream            = Tesselate_Tests.m_InsructionStream[m_WhichShape.cur_item()];
                bool     gotFirst                     = false;
                Tesselate_Tests.Vertex firstInContour = new Tesselate_Tests.Vertex(0, 0);
                bool havePrev = false;
                Tesselate_Tests.Vertex   prevVertex = new Tesselate_Tests.Vertex(0, 0);
                PathStorage              line       = new PathStorage();
                conv_stroke              wideLine;
                AGG.VertexSource.Ellipse Dot;

                for (int curInstruction = 0; curInstruction < instructionStream.Length; curInstruction++)
                {
                    switch (instructionStream[curInstruction])
                    {
                    case "BC":
                        break;

                    case "EC":
                        gotFirst = false;
                        havePrev = false;
                        line.remove_all();
                        line.move_to(prevVertex.m_X + 30, prevVertex.m_Y + 100);
                        line.line_to(firstInContour.m_X + 30, firstInContour.m_Y + 100);

                        // Drawing as an outline
                        wideLine = new conv_stroke(line);
                        wideLine.width(1);

                        GetRenderer().Render(wideLine, new RGBA_Bytes(0, 0, 0));

                        Dot = new Ellipse(
                            (firstInContour.m_X * 9 + prevVertex.m_X) / 10 + 30,
                            (firstInContour.m_Y * 9 + prevVertex.m_Y) / 10 + 100, 3, 3);
                        GetRenderer().Render(Dot, new RGBA_Bytes(0, 0, 0));
                        break;

                    case "V":
                        double x = Convert.ToDouble(instructionStream[curInstruction + 1]);
                        double y = Convert.ToDouble(instructionStream[curInstruction + 2]);
                        curInstruction += 2;
                        if (!gotFirst)
                        {
                            gotFirst       = true;
                            firstInContour = new Tesselate_Tests.Vertex(x, y);
                        }
                        if (!havePrev)
                        {
                            prevVertex = new Tesselate_Tests.Vertex(x, y);
                            havePrev   = true;
                        }
                        else
                        {
                            line.remove_all();
                            line.move_to(prevVertex.m_X + 30, prevVertex.m_Y + 100);
                            line.line_to(x + 30, y + 100);

                            // Drawing as an outline
                            wideLine = new conv_stroke(line);
                            wideLine.width(1);

                            GetRenderer().Render(wideLine, new RGBA_Bytes(0, 0, 0));

                            line.remove_all();
                            Dot = new Ellipse(
                                (x * 9 + prevVertex.m_X) / 10 + 30,
                                (y * 9 + prevVertex.m_Y) / 10 + 100, 3, 3);
                            GetRenderer().Render(Dot, new RGBA_Bytes(0, 0, 0));

                            prevVertex = new Tesselate_Tests.Vertex(x, y);
                        }
                        break;
                    }
                }
            }

            base.OnDraw();
        }
Пример #4
0
        public void VertexCallBack(int index)
        {
            switch (m_TriangleListType)
            {
            case Tesselator.TriangleListType.Triangles:
                m_VertexIndexList.Add(index);
                m_LineWidthList.Add(m_LineWidth);
                if (m_VertexIndexList.Count == 3)
                {
                    Triangle(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                             m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                             m_TesselateTest.m_VertexList[m_VertexIndexList[2]],
                             GetRenderer());

                    Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                         m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                         m_LineWidthList[0], GetRenderer(), false);

                    Line(m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                         m_TesselateTest.m_VertexList[m_VertexIndexList[2]],
                         m_LineWidthList[1], GetRenderer(), false);

                    Line(m_TesselateTest.m_VertexList[m_VertexIndexList[2]],
                         m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                         m_LineWidthList[2], GetRenderer(), false);

                    m_VertexIndexList.Clear();
                    m_LineWidthList.Clear();
                }
                break;

            case Tesselator.TriangleListType.TriangleFan:
                if (m_VertexIndexList.Count > 1)
                {
                    Triangle(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                             m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                             m_TesselateTest.m_VertexList[index],
                             GetRenderer());

                    Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                         m_TesselateTest.m_VertexList[index],
                         .5, GetRenderer(), false);

                    Line(m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                         m_TesselateTest.m_VertexList[index],
                         .5, GetRenderer(), false);

                    AGG.VertexSource.Ellipse Dot = new Ellipse(
                        m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_X * m_Scale + m_XOffset,
                        m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_Y * m_Scale + m_YOffset, 5, 5);
                    GetRenderer().Render(Dot, m_TriangleColor.GetAsRGBA_Bytes());

                    Tesselate_Tests.Vertex polyCenter = new Tesselate_Tests.Vertex(
                        (m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_X
                         + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_X
                         + m_TesselateTest.m_VertexList[index].m_X) / 3,
                        (m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_Y
                         + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_Y
                         + m_TesselateTest.m_VertexList[index].m_Y) / 3);

                    Tesselate_Tests.Vertex newEdgeCenter = new Tesselate_Tests.Vertex(
                        (m_TesselateTest.m_VertexList[index].m_X
                         + m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_X) / 2,
                        (m_TesselateTest.m_VertexList[index].m_Y
                         + m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_Y) / 2);

                    if (m_LastTriangleCenter.m_X == -.9823471232)
                    {
                        Line(polyCenter, newEdgeCenter, .5, GetRenderer(), true);
                    }
                    else
                    {
                        Line(m_LastEdgeCenter, newEdgeCenter, .5, GetRenderer(), true);
                    }

                    m_LastEdgeCenter     = newEdgeCenter;
                    m_LastTriangleCenter = polyCenter;

                    m_VertexIndexList[1] = index;
                }
                else
                {
                    if (m_VertexIndexList.Count == 1)
                    {
                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                             m_TesselateTest.m_VertexList[index],
                             .5, GetRenderer(), false);

                        m_LastTriangleCenter.m_X = -.9823471232;
                    }
                    m_VertexIndexList.Add(index);
                }
                break;

            case Tesselator.TriangleListType.TriangleStrip:
                if (m_VertexIndexList.Count > 1)
                {
                    Triangle(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                             m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                             m_TesselateTest.m_VertexList[index],
                             GetRenderer());

                    Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                         m_TesselateTest.m_VertexList[index],
                         .5, GetRenderer(), false);

                    Line(m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                         m_TesselateTest.m_VertexList[index],
                         .5, GetRenderer(), false);

                    Tesselate_Tests.Vertex polyCenter = new Tesselate_Tests.Vertex(
                        (m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_X
                         + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_X
                         + m_TesselateTest.m_VertexList[index].m_X) / 3,
                        (m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_Y
                         + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_Y
                         + m_TesselateTest.m_VertexList[index].m_Y) / 3);

                    Tesselate_Tests.Vertex newEdgeCenter = new Tesselate_Tests.Vertex(
                        (m_TesselateTest.m_VertexList[index].m_X
                         + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_X) / 2,
                        (m_TesselateTest.m_VertexList[index].m_Y
                         + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_Y) / 2);

                    if (m_LastTriangleCenter.m_X == -.9823471232)
                    {
                        Line(polyCenter, newEdgeCenter, .5, GetRenderer(), true);
                    }
                    else
                    {
                        Line(m_LastEdgeCenter, newEdgeCenter, .5, GetRenderer(), true);
                    }

                    m_LastEdgeCenter     = newEdgeCenter;
                    m_LastTriangleCenter = polyCenter;

                    m_VertexIndexList[0] = m_VertexIndexList[1];
                    m_VertexIndexList[1] = index;
                }
                else
                {
                    if (m_VertexIndexList.Count == 1)
                    {
                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                             m_TesselateTest.m_VertexList[index],
                             .5, GetRenderer(), false);
                        m_LastTriangleCenter.m_X = -.9823471232;
                    }
                    m_VertexIndexList.Add(index);
                }
                break;

            case Tesselator.TriangleListType.LineLoop:
                if (m_VertexIndexList.Count > 0)
                {
                    Line(m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                         m_TesselateTest.m_VertexList[index],
                         .5, GetRenderer(), true);

                    m_VertexIndexList[1] = index;
                }
                else
                {
                    m_VertexIndexList.Add(index);
                    m_VertexIndexList.Add(index);

                    AGG.VertexSource.Ellipse Dot = new Ellipse(
                        m_TesselateTest.m_VertexList[index].m_X * m_Scale + m_XOffset,
                        m_TesselateTest.m_VertexList[index].m_Y * m_Scale + m_YOffset, 5, 5);
                    GetRenderer().Render(Dot, m_LineColor.GetAsRGBA_Bytes());
                }
                break;
            }
        }
Пример #5
0
        public override void OnDraw()
        {
            GetRenderer().Clear(new RGBA_Doubles(1, 1, 1));

            Tesselator tesselator = new Tesselator();
            tesselator.callBegin += new Tesselator.CallBeginDelegate(BeginCallBack);
            tesselator.callEnd += new Tesselator.CallEndDelegate(EndCallBack);
            tesselator.callVertex += new Tesselator.CallVertexDelegate(VertexCallBack);
            tesselator.callCombine += new Tesselator.CallCombineDelegate(CombineCallBack);

            switch (m_WindingRule.cur_item())
            {
                case 0:
                    tesselator.windingRule = Tesselator.WindingRuleType.Odd;
                    break;

                case 1:
                    tesselator.windingRule = Tesselator.WindingRuleType.NonZero;
                    break;

                case 2:
                    tesselator.windingRule = Tesselator.WindingRuleType.Positive;
                    break;

                case 3:
                    tesselator.windingRule = Tesselator.WindingRuleType.Negative;
                    break;

                case 4:
                    tesselator.windingRule = Tesselator.WindingRuleType.ABS_GEQ_Two;
                    break;

            }

            if (m_EdgeFlag.status())
            {
                tesselator.callEdgeFlag += new Tesselator.CallEdgeFlagDelegate(EdgeFlagCallBack);
            }

            if (m_BoundryOnly.status()) // edgesOnly
            {
                tesselator.BoundaryOnly = true;
            }

            m_TesselateTest.ParseStreamForTesselator(tesselator, m_WhichShape.cur_item());

            // now render the outline
            {
                string[] instructionStream = Tesselate_Tests.m_InsructionStream[m_WhichShape.cur_item()];
                bool gotFirst = false;
                Tesselate_Tests.Vertex firstInContour = new Tesselate_Tests.Vertex(0, 0);
                bool havePrev = false;
                Tesselate_Tests.Vertex prevVertex = new Tesselate_Tests.Vertex(0,0);
                PathStorage line = new PathStorage();
                conv_stroke wideLine;
                AGG.VertexSource.Ellipse Dot;

                for (int curInstruction = 0; curInstruction < instructionStream.Length; curInstruction++)
                {
                    switch (instructionStream[curInstruction])
                    {
                        case "BC":
                            break;
                        
                        case "EC":
                            gotFirst = false;
                            havePrev = false;
                            line.remove_all();
                            line.move_to(prevVertex.m_X + 30, prevVertex.m_Y + 100);
                            line.line_to(firstInContour.m_X + 30, firstInContour.m_Y + 100);

                            // Drawing as an outline
                            wideLine = new conv_stroke(line);
                            wideLine.width(1);

                            GetRenderer().Render(wideLine, new RGBA_Bytes(0, 0, 0));

                            Dot = new Ellipse(
                                (firstInContour.m_X * 9 + prevVertex.m_X)/10 + 30,
                                (firstInContour.m_Y * 9 + prevVertex.m_Y)/10 +100, 3, 3);
                            GetRenderer().Render(Dot, new RGBA_Bytes(0, 0, 0));
                            break;
                        
                        case "V":
                            double x = Convert.ToDouble(instructionStream[curInstruction + 1]);
                            double y = Convert.ToDouble(instructionStream[curInstruction + 2]);
                            curInstruction += 2;
                            if (!gotFirst)
                            {
                                gotFirst = true;
                                firstInContour = new Tesselate_Tests.Vertex(x, y);
                            }
                            if (!havePrev)
                            {
                                prevVertex = new Tesselate_Tests.Vertex(x, y);
                                havePrev = true;
                            }
                            else
                            {
                                line.remove_all();
                                line.move_to(prevVertex.m_X + 30, prevVertex.m_Y + 100);
                                line.line_to(x + 30, y + 100);

                                // Drawing as an outline
                                wideLine = new conv_stroke(line);
                                wideLine.width(1);

                                GetRenderer().Render(wideLine, new RGBA_Bytes(0, 0, 0));

                                line.remove_all();
                                Dot = new Ellipse(
                                    (x * 9 + prevVertex.m_X) / 10 + 30,
                                    (y * 9 + prevVertex.m_Y) / 10 + 100, 3, 3);
                                GetRenderer().Render(Dot, new RGBA_Bytes(0, 0, 0));

                                prevVertex = new Tesselate_Tests.Vertex(x, y);
                            }
                            break;
                    }
                }
            }

            base.OnDraw();
        }
Пример #6
0
        public void VertexCallBack(int index)
        {
            switch(m_TriangleListType)
            {
                case Tesselator.TriangleListType.Triangles:
                    m_VertexIndexList.Add(index);
                    m_LineWidthList.Add(m_LineWidth);
                    if (m_VertexIndexList.Count == 3)
                    {
                        Triangle(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                            m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                            m_TesselateTest.m_VertexList[m_VertexIndexList[2]],
                            GetRenderer());

                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                            m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                            m_LineWidthList[0], GetRenderer(), false);

                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                            m_TesselateTest.m_VertexList[m_VertexIndexList[2]],
                            m_LineWidthList[1], GetRenderer(), false);

                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[2]],
                            m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                            m_LineWidthList[2], GetRenderer(), false);

                        m_VertexIndexList.Clear();
                        m_LineWidthList.Clear();
                    }
                    break;

                case Tesselator.TriangleListType.TriangleFan:
                    if (m_VertexIndexList.Count > 1)
                    {
                        Triangle(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                            m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                            m_TesselateTest.m_VertexList[index],
                            GetRenderer());

                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                            m_TesselateTest.m_VertexList[index],
                            .5, GetRenderer(), false);

                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                            m_TesselateTest.m_VertexList[index],
                            .5, GetRenderer(), false);

                        AGG.VertexSource.Ellipse Dot = new Ellipse(
                            m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_X * m_Scale + m_XOffset,
                            m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_Y * m_Scale + m_YOffset, 5, 5);
                        GetRenderer().Render(Dot, m_TriangleColor.GetAsRGBA_Bytes());

                        Tesselate_Tests.Vertex polyCenter = new Tesselate_Tests.Vertex(
                            (m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_X
                            + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_X
                            + m_TesselateTest.m_VertexList[index].m_X) / 3,
                            (m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_Y
                            + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_Y
                            + m_TesselateTest.m_VertexList[index].m_Y) / 3);

                        Tesselate_Tests.Vertex newEdgeCenter = new Tesselate_Tests.Vertex(
                            (m_TesselateTest.m_VertexList[index].m_X
                            + m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_X) / 2,
                            (m_TesselateTest.m_VertexList[index].m_Y
                            + m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_Y) / 2);

                        if (m_LastTriangleCenter.m_X == -.9823471232)
                        {
                            Line(polyCenter, newEdgeCenter, .5, GetRenderer(), true);
                        }
                        else
                        {
                            Line(m_LastEdgeCenter, newEdgeCenter, .5, GetRenderer(), true);
                        }

                        m_LastEdgeCenter = newEdgeCenter;
                        m_LastTriangleCenter = polyCenter;

                        m_VertexIndexList[1] = index;
                    }
                    else
                    {
                        if (m_VertexIndexList.Count == 1)
                        {
                            Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                                m_TesselateTest.m_VertexList[index],
                                .5, GetRenderer(), false);

                            m_LastTriangleCenter.m_X = -.9823471232;
                        }
                        m_VertexIndexList.Add(index);
                    }
                    break;

                case Tesselator.TriangleListType.TriangleStrip:
                    if (m_VertexIndexList.Count > 1)
                    {
                        Triangle(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                            m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                            m_TesselateTest.m_VertexList[index],
                            GetRenderer());

                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                            m_TesselateTest.m_VertexList[index],
                            .5, GetRenderer(), false);

                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                            m_TesselateTest.m_VertexList[index],
                            .5, GetRenderer(), false);

                        Tesselate_Tests.Vertex polyCenter = new Tesselate_Tests.Vertex(
                            (m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_X 
                            + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_X
                            + m_TesselateTest.m_VertexList[index].m_X) / 3,
                            (m_TesselateTest.m_VertexList[m_VertexIndexList[0]].m_Y
                            + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_Y
                            + m_TesselateTest.m_VertexList[index].m_Y) / 3);

                        Tesselate_Tests.Vertex newEdgeCenter = new Tesselate_Tests.Vertex(
                            (m_TesselateTest.m_VertexList[index].m_X
                            + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_X) / 2,
                            (m_TesselateTest.m_VertexList[index].m_Y
                            + m_TesselateTest.m_VertexList[m_VertexIndexList[1]].m_Y) / 2);

                        if(m_LastTriangleCenter.m_X == -.9823471232)
                        {
                            Line(polyCenter, newEdgeCenter, .5, GetRenderer(), true);
                        }
                        else
                        {
                            Line(m_LastEdgeCenter, newEdgeCenter, .5, GetRenderer(), true);
                        }

                        m_LastEdgeCenter = newEdgeCenter;
                        m_LastTriangleCenter = polyCenter;

                        m_VertexIndexList[0] = m_VertexIndexList[1];
                        m_VertexIndexList[1] = index;
                    }
                    else
                    {
                        if (m_VertexIndexList.Count == 1)
                        {
                            Line(m_TesselateTest.m_VertexList[m_VertexIndexList[0]],
                                m_TesselateTest.m_VertexList[index],
                                .5, GetRenderer(), false);
                            m_LastTriangleCenter.m_X = -.9823471232;
                        }
                        m_VertexIndexList.Add(index);
                    }
                    break;

                case Tesselator.TriangleListType.LineLoop:
                    if (m_VertexIndexList.Count > 0)
                    {
                        Line(m_TesselateTest.m_VertexList[m_VertexIndexList[1]],
                            m_TesselateTest.m_VertexList[index],
                            .5, GetRenderer(), true);

                        m_VertexIndexList[1] = index;
                    }
                    else
                    {
                        m_VertexIndexList.Add(index);
                        m_VertexIndexList.Add(index);

                        AGG.VertexSource.Ellipse Dot = new Ellipse(
                            m_TesselateTest.m_VertexList[index].m_X * m_Scale + m_XOffset,
                            m_TesselateTest.m_VertexList[index].m_Y * m_Scale + m_YOffset, 5, 5);
                        GetRenderer().Render(Dot, m_LineColor.GetAsRGBA_Bytes());
                    }
                    break;

            }
        }