public void FillGfxPath(Drawing.Brush brush, InternalGraphicsPath igpth)
        {
            switch (brush.BrushKind)
            {
            case Drawing.BrushKind.Solid:
            {
                var solidBrush = brush as PixelFarm.Drawing.SolidBrush;
                FillGfxPath(solidBrush.Color, igpth);
            }
            break;

            case Drawing.BrushKind.LinearGradient:
            case Drawing.BrushKind.Texture:
            {
                int m = igpth.FigCount;
                for (int b = 0; b < m; ++b)
                {
                    Figure fig = igpth.GetFig(b);
                    GL.ClearStencil(0);         //set value for clearing stencil buffer
                    //actual clear here
                    GL.Clear(ClearBufferMask.StencilBufferBit);
                    //-------------------
                    //disable rendering to color buffer
                    GL.ColorMask(false, false, false, false);
                    //start using stencil
                    GL.Enable(EnableCap.StencilTest);
                    //place a 1 where rendered
                    GL.StencilFunc(StencilFunction.Always, 1, 1);
                    //replace where rendered
                    GL.StencilOp(StencilOp.Replace, StencilOp.Replace, StencilOp.Replace);
                    //render  to stencill buffer
                    //-----------------

                    float[] tessArea = fig.GetAreaTess(this.tessTool);
                    //-------------------------------------
                    if (tessArea != null)
                    {
                        this.basicFillShader.FillTriangles(tessArea, fig.TessAreaVertexCount, PixelFarm.Drawing.Color.Black);
                    }
                    //--------------------------------------
                    //render color
                    //--------------------------------------
                    //reenable color buffer
                    GL.ColorMask(true, true, true, true);
                    //where a 1 was not rendered
                    GL.StencilFunc(StencilFunction.Equal, 1, 1);
                    //freeze stencill buffer
                    GL.StencilOp(StencilOp.Keep, StencilOp.Keep, StencilOp.Keep);
                    //------------------------------------------
                    //we already have valid ps from stencil step
                    //------------------------------------------

                    //-------------------------------------------------------------------------------------
                    //1.  we draw only alpha chanel of this black color to destination color
                    //so we use  BlendFuncSeparate  as follow ...
                    //-------------------------------------------------------------------------------------
                    //1.  we draw only alpha channel of this black color to destination color
                    //so we use  BlendFuncSeparate  as follow ...
                    GL.ColorMask(false, false, false, true);
                    //GL.BlendFuncSeparate(
                    //     BlendingFactorSrc.DstColor, BlendingFactorDest.DstColor, //the same
                    //     BlendingFactorSrc.One, BlendingFactorDest.Zero);

                    //use alpha chanel from source***
                    GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.Zero);
                    float[] smoothBorder = fig.GetSmoothBorders(smoothBorderBuilder);
                    invertAlphaFragmentShader.DrawTriangleStrips(smoothBorder, fig.BorderTriangleStripCount);
                    //at this point alpha component is fill in to destination
                    //-------------------------------------------------------------------------------------
                    //2. then fill again!,
                    //we use alpha information from dest,
                    //so we set blend func to ... GL.BlendFunc(BlendingFactorSrc.DstAlpha, BlendingFactorDest.OneMinusDstAlpha)
                    GL.ColorMask(true, true, true, true);
                    GL.BlendFunc(BlendingFactorSrc.DstAlpha, BlendingFactorDest.OneMinusDstAlpha);
                    {
                        //draw box*** of gradient color
                        switch (brush.BrushKind)
                        {
                        case Drawing.BrushKind.LinearGradient:
                        {
                            var     linearGradientBrush = brush as PixelFarm.Drawing.LinearGradientBrush;
                            var     colors = linearGradientBrush.GetColors();
                            var     points = linearGradientBrush.GetStopPoints();
                            float[] v2f, color4f;
                            GLGradientColorProvider.CalculateLinearGradientVxs2(
                                points[0].X, points[0].Y,
                                points[1].X, points[1].Y,
                                colors[0],
                                colors[1], out v2f, out color4f);
                            rectFillShader.Render(v2f, color4f);
                        }
                        break;

                        case Drawing.BrushKind.Texture:
                        {
                            //draw texture image ***
                            PixelFarm.Drawing.TextureBrush tbrush = (PixelFarm.Drawing.TextureBrush)brush;
                            GLBitmap bmpTexture = PixelFarm.Drawing.Image.GetCacheInnerImage(tbrush.TextureImage) as GLBitmap;
                            //TODO: review here
                            //where text start?
                            this.DrawImage(bmpTexture, 0, 300);
                        }
                        break;
                        }
                    }
                    //restore back
                    //3. switch to normal blending mode
                    GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
                    GL.Disable(EnableCap.StencilTest);
                }
            }
            break;
            }
        }
        public void FillGfxPath(Drawing.Color color, InternalGraphicsPath igpth)
        {
            switch (SmoothMode)
            {
            case SmoothMode.No:
            {
                int subPathCount = igpth.FigCount;

                for (int i = 0; i < subPathCount; ++i)
                {
                    Figure f = igpth.GetFig(i);
                    if (f.SupportVertexBuffer)
                    {
                        basicFillShader.FillTriangles(
                            f.GetAreaTessAsVBO(tessTool),
                            f.TessAreaVertexCount,
                            color);
                    }
                    else
                    {
                        float[] tessArea = f.GetAreaTess(this.tessTool);
                        if (tessArea != null)
                        {
                            this.basicFillShader.FillTriangles(tessArea, f.TessAreaVertexCount, color);
                        }
                    }
                }
            }
            break;

            case SmoothMode.Smooth:
            {
                int           subPathCount = igpth.FigCount;
                float         saved_Width  = StrokeWidth;
                Drawing.Color saved_Color  = StrokeColor;
                //temp set stroke width to 2 amd stroke color
                //to the same as bg color (for smooth border).
                //and it will be set back later.
                //
                StrokeColor = color;
                StrokeWidth = 1.5f;         //TODO: review this ***
                //
                float[] tessArea;
                for (int i = 0; i < subPathCount; ++i)
                {
                    //draw each sub-path
                    Figure f = igpth.GetFig(i);
                    if (f.SupportVertexBuffer)
                    {
                        //TODO: review here again
                        //draw area
                        basicFillShader.FillTriangles(
                            f.GetAreaTessAsVBO(tessTool),
                            f.TessAreaVertexCount,
                            color);
                        //draw smooth border
                        smoothLineShader.DrawTriangleStrips(
                            f.GetSmoothBorders(smoothBorderBuilder),
                            f.BorderTriangleStripCount);
                    }
                    else
                    {
                        if ((tessArea = f.GetAreaTess(this.tessTool)) != null)
                        {
                            //draw area
                            basicFillShader.FillTriangles(tessArea, f.TessAreaVertexCount, color);
                            //draw smooth border
                            smoothLineShader.DrawTriangleStrips(
                                f.GetSmoothBorders(smoothBorderBuilder),
                                f.BorderTriangleStripCount);
                        }
                    }
                }
                //restore stroke width and color
                StrokeWidth = saved_Width;         //restore back
                StrokeColor = saved_Color;
            }
            break;
            }
        }
 internal InternalGraphicsPath(Figure fig)
 {
     this.figures         = null;
     this._mutltiPartTess = null;
     _figure = fig;
 }
 internal InternalGraphicsPath(MultiPartTessResult _mutltiPartTess)
 {
     this._figure         = null;
     this.figures         = null;
     this._mutltiPartTess = _mutltiPartTess;
 }
 internal InternalGraphicsPath(List <Figure> figures)
 {
     _figure         = null;
     _mutltiPartTess = null;
     this.figures    = figures;
 }