/// <summary>
/// tess and read result as triangle list index array (for GLES draw element)
/// </summary>
/// <param name="tessTool"></param>
/// <param name="vertex2dCoords"></param>
/// <param name="contourEndPoints"></param>
/// <param name="outputCoords"></param>
/// <param name="vertexCount"></param>
/// <returns></returns>
internal static void TessAndAddToMultiPartResult(this TessTool tessTool,
float[] vertex2dCoords,
int[] contourEndPoints,
MultiPartTessResult multipartTessResult,
out int vertexCount)
{
if (!tessTool.TessPolygon(vertex2dCoords, contourEndPoints))
{
vertexCount = 0;
return;
}
//-----------------------------
//results
//1.
List <ushort> indexList = tessTool.TessIndexList;
//2.
List <TessTempVertex> tempVertexList = tessTool.TempVertexList;
//3.
vertexCount = indexList.Count;
//-----------------------------
multipartTessResult.BeginPart();
multipartTessResult.AddTessCoords(vertex2dCoords);
//append with newly create vertex(from tempVertList)
int tempVertListCount = tempVertexList.Count;
for (int i = 0; i < tempVertListCount; ++i)
{
TessTempVertex v = tempVertexList[i];
multipartTessResult.AddTessCoord((float)v.m_X, (float)v.m_Y);
}
multipartTessResult.AddVertexIndexList(indexList);
multipartTessResult.EndPart();
}
public float[] GetAreaTess(ref TessTool tess)
{
if (areaTess == null)
{
List <Vertex> vertextList = tess.TessPolygon(coordXYs);
if (vertextList == null)
{
tessAreaTriangleCount = 0;
return(null);
}
//-----------------------------
//switch how to fill polygon
int j = vertextList.Count;
float[] vtx = new float[j * 2];
int n = 0;
for (int p = 0; p < j; ++p)
{
var v = vertextList[p];
vtx[n] = (float)v.m_X;
vtx[n + 1] = (float)v.m_Y;
n += 2;
}
//triangle list
tessAreaTriangleCount = j;
//-------------------------------------
return(this.areaTess = vtx);
}
return(areaTess);
}
internal GLRenderSurface(int width, int height)
{
//-------------
//y axis points upward (like other OpenGL)
//x axis points to right.
//please NOTE: left lower corner of the canvas is (0,0)
//-------------
this._width = width;
this._height = height;
//setup viewport size,
//we need W:H ratio= 1:1 , square viewport
int max = Math.Max(width, height);
orthoView = MyMat4.ortho(0, max, 0, max, 0, 1); //this make our viewport W:H =1:1
flipVerticalView = MyMat4.scale(1, -1) * MyMat4.translate(new OpenTK.Vector3(0, -height, 0));
orthoAndFlip = orthoView * flipVerticalView;
//-----------------------------------------------------------------------
_shareRes = new ShaderSharedResource();
_shareRes.OrthoView = orthoView;
//-----------------------------------------------------------------------
basicFillShader = new BasicFillShader(_shareRes);
smoothLineShader = new SmoothLineShader(_shareRes);
rectFillShader = new RectFillShader(_shareRes);
gdiImgTextureShader = new GdiImageTextureShader(_shareRes);
gdiImgTextureWithWhiteTransparentShader = new GdiImageTextureWithWhiteTransparentShader(_shareRes);
glyphStencilShader = new GlyphImageStecilShader(_shareRes);
textureSubPixRendering = new ImageTextureWithSubPixelRenderingShader(_shareRes);
blurShader = new BlurShader(_shareRes);
glesTextureShader = new OpenGLESTextureShader(_shareRes);
invertAlphaFragmentShader = new InvertAlphaLineSmoothShader(_shareRes); //used with stencil ***
conv3x3TextureShader = new Conv3x3TextureShader(_shareRes);
msdfShader = new DrawingGL.MultiChannelSdf(_shareRes);
msdfSubPixelRenderingShader = new DrawingGL.MultiChannelSubPixelRenderingSdf(_shareRes);
sdfShader = new DrawingGL.SingleChannelSdf(_shareRes);
//-----------------------------------------------------------------------
//tools
tessTool = new TessTool();
//-----------------------------------------------------------------------
//GL.Enable(EnableCap.CullFace);
//GL.FrontFace(FrontFaceDirection.Cw);
//GL.CullFace(CullFaceMode.Back);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);//original **
//GL.BlendFunc(BlendingFactorSrc.SrcColor, BlendingFactorDest.One);// not apply alpha to src
//GL.BlendFuncSeparate(BlendingFactorSrc.SrcColor, BlendingFactorDest.OneMinusSrcAlpha,
// BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
//GL.BlendFuncSeparate(BlendingFactorSrc.SrcColor, BlendingFactorDest.OneMinusSrcColor, BlendingFactorSrc.SrcAlpha, BlendingFactorDest.Zero);
GL.ClearColor(1, 1, 1, 1);
//-------------------------------------------------------------------------------
GL.Viewport(0, 0, width, height);
}
public float[] GetAreaTess(TessTool tess, TessTriangleTechnique tech)
{
#if DEBUG
if (this.TessTriangleTech == 0)
{
}
#endif
if (TessTriangleTech != tech)
{
//re tess again
this.TessTriangleTech = tech;
//***
if (this.TessTriangleTech == TessTriangleTechnique.DrawArray)
{
return(_areaTess ??
(_areaTess = tess.TessAsTriVertexArray(coordXYs, null, out _tessAreaVertexCount)));
}
else
{
_indexListArray = tess.TessAsTriIndexArray(coordXYs,
null,
out _areaTess,
out _tessAreaVertexCount);
return(_areaTess);
}
}
else
{
//if equal
return(_areaTess);
}
}
public float[] GetAreaTess(TessTool tess)
{
if (areaTess == null)
{
//triangle list
return(areaTess = tess.TessAsTriVertexArray(coordXYs, null, out this._tessAreaVertexCount));
}
return(areaTess);
}
FrameBuffer _currentFrameBuffer;//default = null, system provide frame buffer
internal CanvasGL2d(int canvasW, int canvasH)
{
this.canvasW = canvasW;
this.canvasH = canvasH;
////setup viewport size
int max = Math.Max(canvasW, canvasH);
////square viewport
orthoView = MyMat4.ortho(0, max, 0, max, 0, 1);
flipVerticalView = MyMat4.scale(1, -1) * MyMat4.translate(new OpenTK.Vector3(0, -max, 0));
orthoAndFlip = orthoView * flipVerticalView;
//-----------------------------------------------------------------------
shaderRes = new CanvasToShaderSharedResource();
shaderRes.OrthoView = orthoView;
//-----------------------------------------------------------------------
basicFillShader = new BasicFillShader(shaderRes);
smoothLineShader = new SmoothLineShader(shaderRes);
rectFillShader = new RectFillShader(shaderRes);
gdiImgTextureShader = new GdiImageTextureShader(shaderRes);
gdiImgTextureWithWhiteTransparentShader = new GdiImageTextureWithWhiteTransparentShader(shaderRes);
textureSubPixRendering = new ImageTextureWithSubPixelRenderingShader(shaderRes);
blurShader = new BlurShader(shaderRes);
glesTextureShader = new OpenGLESTextureShader(shaderRes);
invertAlphaFragmentShader = new InvertAlphaLineSmoothShader(shaderRes); //used with stencil ***
// tessListener.Connect(tess,
//Tesselate.Tesselator.WindingRuleType.Odd, true);
conv3x3TextureShader = new Conv3x3TextureShader(shaderRes);
msdfShader = new DrawingGL.MultiChannelSdf(shaderRes);
msdfSubPixelRenderingShader = new DrawingGL.MultiChannelSubPixelRenderingSdf(shaderRes);
sdfShader = new DrawingGL.SingleChannelSdf(shaderRes);
//----
Tesselator tess = new Tesselator();
tess.WindingRule = Tesselator.WindingRuleType.Odd;
tessTool = new TessTool(tess);
//-----------------------------------------------------------------------
//GL.Enable(EnableCap.CullFace);
//GL.FrontFace(FrontFaceDirection.Cw);
//GL.CullFace(CullFaceMode.Back);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);//original **
//GL.BlendFunc(BlendingFactorSrc.SrcColor, BlendingFactorDest.One);// not apply alpha to src
//GL.BlendFuncSeparate(BlendingFactorSrc.SrcColor, BlendingFactorDest.OneMinusSrcAlpha,
// BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
//GL.BlendFuncSeparate(BlendingFactorSrc.SrcColor, BlendingFactorDest.OneMinusSrcColor, BlendingFactorSrc.SrcAlpha, BlendingFactorDest.Zero);
GL.ClearColor(1, 1, 1, 1);
//-------------------------------------------------------------------------------
GL.Viewport(0, 0, canvasW, canvasH);
}
public float[] GetAreaTess(TessTool tess, Tesselate.Tesselator.WindingRuleType windingRuleType, TessTriangleTechnique tessTechnique)
{
#if DEBUG
if (this.TessTriangleTech == 0)
{
}
#endif
if (TessTriangleTech != tessTechnique)
{
//re tess again
this.TessTriangleTech = tessTechnique;
//***
using (Borrow(out ReusableCoordList resuableCoordList))
{
List <float> coordXYs = resuableCoordList._coordXYs;
List <int> contourEndPoints = resuableCoordList._contourEndPoints;
for (int i = 0; i < _figures.Length; ++i)
{
Figure figure = _figures[i];
coordXYs.AddRange(figure.coordXYs);
contourEndPoints.Add(coordXYs.Count - 1);
}
if (this.TessTriangleTech == TessTriangleTechnique.DrawArray)
{
tess.WindingRuleType = windingRuleType;
return(_areaTess = tess.TessAsTriVertexArray(
coordXYs.ToArray(),
contourEndPoints.ToArray(),
out _tessAreaVertexCount));
}
else
{
tess.WindingRuleType = windingRuleType;
_areaTessIndexList = tess.TessAsTriIndexArray(
coordXYs.ToArray(),
contourEndPoints.ToArray(),
out _areaTess,
out _tessAreaVertexCount);
return(_areaTess);
}
}
}
else
{
//if equal
return(_areaTess);
}
}
/// <summary>
/// vertex buffer of the solid area part
/// </summary>
public VertexBufferObject GetAreaTessAsVBO(TessTool tess)
{
if (_vboArea == null)
{
//tess
indexListArray = tess.TessAsTriIndexArray(coordXYs, null,
out tessXYCoords2, out this._tessAreaVertexCount);
_vboArea = new VertexBufferObject();
_vboArea.CreateBuffers(tessXYCoords2, indexListArray, null);
}
return(_vboArea);
}
FrameBuffer _currentFrameBuffer;//default = null, system provide frame buffer
internal CanvasGL2d(int canvasW, int canvasH)
{
this.canvasW = canvasW;
this.canvasH = canvasH;
////setup viewport size
int max = Math.Max(canvasW, canvasH);
////square viewport
orthoView = MyMat4.ortho(0, max, 0, max, 0, 1);
//-----------------------------------------------------------------------
shaderRes = new CanvasToShaderSharedResource();
shaderRes.OrthoView = orthoView;
//-----------------------------------------------------------------------
basicFillShader = new BasicFillShader(shaderRes);
smoothLineShader = new SmoothLineShader(shaderRes);
rectFillShader = new RectFillShader(shaderRes);
gdiImgTextureShader = new GdiImageTextureShader(shaderRes);
gdiImgTextureWithWhiteTransparentShader = new GdiImageTextureWithWhiteTransparentShader(shaderRes);
blurShader = new BlurShader(shaderRes);
glesTextureShader = new OpenGLESTextureShader(shaderRes);
invertAlphaFragmentShader = new InvertAlphaLineSmoothShader(shaderRes); //used with stencil ***
// tessListener.Connect(tess,
//Tesselate.Tesselator.WindingRuleType.Odd, true);
conv3x3TextureShader = new Conv3x3TextureShader(shaderRes);
msdfShader = new DrawingGL.MultiChannelSdf(shaderRes);
msdfSubPixelRenderingShader = new DrawingGL.MultiChannelSubPixelRenderingSdf(shaderRes);
sdfShader = new DrawingGL.SingleChannelSdf(shaderRes);
//----
Tesselator tess = new Tesselator();
tess.WindingRule = Tesselator.WindingRuleType.Odd;
tessTool = new TessTool(tess);
//-----------------------------------------------------------------------
//GL.Enable(EnableCap.CullFace);
//GL.FrontFace(FrontFaceDirection.Cw);
//GL.CullFace(CullFaceMode.Back);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.ClearColor(1, 1, 1, 1);
//-------------------------------------------------------------------------------
GL.Viewport(0, 0, canvasW, canvasH);
}
internal void CreateAreaTessVBOSegment(VBOStream ownerVBOStream,
TessTool tess,
Tesselate.Tesselator.WindingRuleType windingRuleType)
{
//
float[] tessArea = GetAreaTess(tess, windingRuleType);
if (tessArea != null)
{
_tessAreaVboSeg = ownerVBOStream.CreateSegment(tessArea, TessAreaVertexCount, 2);
}
else
{
//??
}
//
}
internal void CreateGraphicsPathForMultiPartRenderVx(
MultiPartPolygon multipartPolygon,
MultiPartTessResult multipartTessResult,
TessTool tessTool,
SmoothBorderBuilder borderBuilder)
{
//a multipart polygon contains a list of expand coord (x,y) set.
List <float[]> expandCoordsList = multipartPolygon.expandCoordsList;
List <int[]> endPointList = multipartPolygon.contourEndPoints;
int listCount = expandCoordsList.Count;
for (int i = 0; i < listCount; ++i)
{
//expand x,y
float[] expandCoords = expandCoordsList[i];
int[] endPoints = endPointList[i];
//area
int localVertexCount;
tessTool.TessAndAddToMultiPartResult(expandCoords,
endPoints,
multipartTessResult,
out localVertexCount);
//borders
//build smooth border
int m = endPoints.Length;
int latest_endPoint = 0;
multipartTessResult.BeginBorderPart();
for (int n = 0; n < m; ++n)
{
int endPoint = endPoints[n]; //'x' , not include 'y'
int len = (endPoint - latest_endPoint) + 1; //so len we add +1 for 'y'
int borderTriangleStripCount;
//expand coords for draw array
float[] smoothBorderXYs = borderBuilder.BuildSmoothBorders(expandCoords, latest_endPoint, len, out borderTriangleStripCount);
latest_endPoint += len + 2;
multipartTessResult.AddSmoothBorders(smoothBorderXYs, borderTriangleStripCount);
}
multipartTessResult.EndBorderPart();
}
}
/// <summary>
/// tess and read result as triangle list index array (for GLES draw element)
/// </summary>
/// <param name="tessTool"></param>
/// <param name="vertex2dCoords"></param>
/// <param name="contourEndPoints"></param>
/// <param name="outputCoords"></param>
/// <param name="vertexCount"></param>
/// <returns></returns>
public static ushort[] TessAsTriIndexArray(this TessTool tessTool,
float[] vertex2dCoords,
int[] contourEndPoints,
out float[] outputCoords,
out int vertexCount)
{
if (!tessTool.TessPolygon(vertex2dCoords, contourEndPoints))
{
vertexCount = 0;
outputCoords = null;
return(null); //* early exit
}
//results
//1.
List <ushort> indexList = tessTool.TessIndexList;
//2.
List <TessTempVertex> tempVertexList = tessTool.TempVertexList;
//3.
vertexCount = indexList.Count;
//-----------------------------
//create a new array and append with original and new tempVertex list
int tempVertListCount = tempVertexList.Count;
outputCoords = new float[vertex2dCoords.Length + tempVertListCount * 2];
//1. copy original array
Array.Copy(vertex2dCoords, outputCoords, vertex2dCoords.Length);
//2. append with newly create vertex (from tempVertList)
int endAt = vertex2dCoords.Length + tempVertListCount;
int p = 0;
int q = vertex2dCoords.Length; //start adding at
for (int i = vertex2dCoords.Length; i < endAt; ++i)
{
TessTempVertex v = tempVertexList[p];
outputCoords[q] = (float)v.m_X;
outputCoords[q + 1] = (float)v.m_Y;
p++;
q += 2;
}
return(indexList.ToArray());
}
/// <summary>
/// tess and read result as triangle list vertex array (for GLES draw-array)
/// </summary>
/// <param name="tessTool"></param>
/// <param name="vertex2dCoords"></param>
/// <param name="contourEndPoints"></param>
/// <param name="vertexCount"></param>
/// <returns></returns>
public static float[] TessAsTriVertexArray(this TessTool tessTool, float[] vertex2dCoords, int[] contourEndPoints, out int vertexCount)
{
if (!tessTool.TessPolygon(vertex2dCoords, contourEndPoints))
{
vertexCount = 0;
return(null);
}
//results
//1.
List <ushort> indexList = tessTool.TessIndexList;
//2.
List <TessTempVertex> tempVertexList = tessTool.TempVertexList;
//3.
vertexCount = indexList.Count;
//-----------------------------
int orgVertexCount = vertex2dCoords.Length / 2;
float[] vtx = new float[vertexCount * 2];//***
int n = 0;
for (int p = 0; p < vertexCount; ++p)
{
ushort index = indexList[p];
if (index >= orgVertexCount)
{
//extra coord (newly created)
TessTempVertex extraVertex = tempVertexList[index - orgVertexCount];
vtx[n] = (float)extraVertex.m_X;
vtx[n + 1] = (float)extraVertex.m_Y;
}
else
{
//original corrd
vtx[n] = (float)vertex2dCoords[index * 2];
vtx[n + 1] = (float)vertex2dCoords[(index * 2) + 1];
}
n += 2;
}
//triangle list
return(vtx);
}
public float[] GetAreaTess(ref TessTool tess)
{
if (areaTess == null)
{
List<Vertex> vertextList = tess.TessPolygon(coordXYs);
//-----------------------------
//switch how to fill polygon
int j = vertextList.Count;
float[] vtx = new float[j * 2];
int n = 0;
for (int p = 0; p < j; ++p)
{
var v = vertextList[p];
vtx[n] = (float)v.m_X;
vtx[n + 1] = (float)v.m_Y;
n += 2;
}
//triangle list
tessAreaTriangleCount = j;
//-------------------------------------
return this.areaTess = vtx;
}
return areaTess;
}
internal float[] GetAreaTess(TessTool tess, Tesselate.Tesselator.WindingRuleType windingRuleType)
{
return((_figure != null) ?
_figure.GetAreaTess(tess, windingRuleType, TessTriangleTechnique.DrawArray) :
_figures.GetAreaTess(tess, windingRuleType, TessTriangleTechnique.DrawArray));
}
internal float[] GetAreaTess(TessTool tess)
{
return((_figure != null) ?
_figure.GetAreaTess(tess, TessTriangleTechnique.DrawArray) :
_figures.GetAreaTess(tess, TessTriangleTechnique.DrawArray));
}