//-------------------------------------------------------------------------------
public void FillGfxPath(Drawing.Color color, InternalGraphicsPath igpth)
{
switch (SmoothMode)
{
case CanvasSmoothMode.No:
{
List <Figure> figures = igpth.figures;
int subPathCount = figures.Count;
for (int i = 0; i < subPathCount; ++i)
{
Figure f = figures[i];
float[] tessArea = f.GetAreaTess(ref this.tessTool);
if (tessArea != null)
{
this.basicFillShader.FillTriangles(tessArea, f.TessAreaTriangleCount, color);
}
}
}
break;
case CanvasSmoothMode.Smooth:
{
List <Figure> figures = igpth.figures;
int subPathCount = figures.Count;
float prevWidth = StrokeWidth;
StrokeColor = color;
StrokeWidth = 0.5f;
for (int i = 0; i < subPathCount; ++i)
{
Figure f = figures[i];
float[] tessArea = f.GetAreaTess(ref this.tessTool);
if (tessArea != null)
{
basicFillShader.FillTriangles(tessArea, f.TessAreaTriangleCount, color);
smoothLineShader.DrawTriangleStrips(f.GetSmoothBorders(), f.BorderTriangleStripCount);
}
}
StrokeWidth = prevWidth;
}
break;
}
}
public void DrawGfxPath(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);
float[] coordXYs = f.coordXYs;
unsafe
{
fixed(float *head = &coordXYs[0])
{
basicFillShader.DrawLineLoopWithVertexBuffer(head, coordXYs.Length / 2, StrokeColor);
}
}
}
}
break;
case SmoothMode.Smooth:
{
StrokeColor = color;
StrokeWidth = 1f;
int subPathCount = igpth.FigCount;
for (int i = 0; i < subPathCount; ++i)
{
Figure f = igpth.GetFig(i);
smoothLineShader.DrawTriangleStrips(f.GetSmoothBorders(smoothBorderBuilder), f.BorderTriangleStripCount);
}
//restore back
}
break;
}
}
public void DrawGfxPath(Drawing.Color color, InternalGraphicsPath igpth)
{
switch (SmoothMode)
{
case CanvasSmoothMode.No:
{
List <Figure> figures = igpth.figures;
int subPathCount = figures.Count;
for (int i = 0; i < subPathCount; ++i)
{
Figure f = figures[i];
float[] coordXYs = f.coordXYs;
unsafe
{
fixed(float *head = &coordXYs[0])
{
basicFillShader.DrawLineLoopWithVertexBuffer(head, coordXYs.Length / 2, StrokeColor);
}
}
}
}
break;
case CanvasSmoothMode.Smooth:
{
StrokeColor = color;
StrokeWidth = 1f;
List <Figure> figures = igpth.figures;
int subPathCount = figures.Count;
for (int i = 0; i < subPathCount; ++i)
{
Figure f = figures[i];
smoothLineShader.DrawTriangleStrips(f.GetSmoothBorders(), f.BorderTriangleStripCount);
}
}
break;
}
}
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:
{
List <Figure> figures = igpth.figures;
int m = figures.Count;
for (int b = 0; b < m; ++b)
{
Figure fig = figures[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(ref this.tessTool);
//-------------------------------------
if (tessArea != null)
{
this.basicFillShader.FillTriangles(tessArea, fig.TessAreaTriangleCount, 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();
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;
}
}
//
//----------------------------------------------------
//
internal float[] GetSmoothBorders(SmoothBorderBuilder smoothBorderBuilder)
{
return((_figure != null) ?
_figure.GetSmoothBorders(smoothBorderBuilder) :
_figures.GetSmoothBorders(smoothBorderBuilder));
}
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;
}
}