public void BeginCallBack(Tesselator <T> .TriangleListType type)
{
if (type != TriangleListType.LineLoop)
{
throw new Exception("This only does boundaries. Why are you getting anything other athn LineLoops?");
}
}
public PolygonTesselator()
{
m_Tesselator = new Tesselate.Tesselator();
m_Tesselator.callBegin += new Tesselator.CallBeginDelegate(BeginCallBack);
m_Tesselator.callEnd += new Tesselator.CallEndDelegate(EndCallBack);
m_Tesselator.callVertex += new Tesselator.CallVertexDelegate(VertexCallBack);
//m_Tesselator.callEdgeFlag += new Tesselator.CallEdgeFlagDelegate(EdgeFlagCallBack);
m_Tesselator.callCombine += new Tesselator.CallCombineDelegate(CombineCallBack);
}
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 RenderToGLWithUVTesselator()
{
callBegin += new Tesselator <T> .CallBeginDelegate(BeginCallBack);
callEnd += new Tesselator <T> .CallEndDelegate(EndCallBack);
callVertex += new Tesselator <T> .CallVertexDelegate(VertexCallBack);
callCombine += new Tesselator <T> .CallCombineDelegate(CombineCallBack);
}
/// <summary>
/// connect to actual Tesselator
/// </summary>
/// <param name="tesselator"></param>
/// <param name="setEdgeFlag"></param>
public void Connect(Tesselator tesselator, bool setEdgeFlag)
{
tesselator.callBegin = OnBegin;
tesselator.callEnd = OnEnd;
tesselator.callVertex = OnVertex;
tesselator.callCombine = OnCombine;
if (setEdgeFlag)
{
tesselator.callEdgeFlag = OnEdgeFlag;
}
}
public RenderToGLTesselator()
{
callBegin += new Tesselator <T> .CallBeginDelegate(BeginCallBack);
callEnd += new Tesselator <T> .CallEndDelegate(EndCallBack);
callVertex += new Tesselator <T> .CallVertexDelegate(VertexCallBack);
//callEdgeFlag += new Tesselator.CallEdgeFlagDelegate(EdgeFlagCallBack);
callCombine += new Tesselator <T> .CallCombineDelegate(CombineCallBack);
}
/// <summary>
/// connect to actual Tesselator
/// </summary>
/// <param name="tesselator"></param>
/// <param name="setEdgeFlag"></param>
public void Connect(Tesselator tesselator, bool setEdgeFlag)
{
tesselator.callBegin = BeginCallBack;
tesselator.callEnd = EndCallBack;
tesselator.callVertex = VertexCallBack;
tesselator.callCombine = CombineCallBack;
if (setEdgeFlag)
{
tesselator.callEdgeFlag = EdgeFlagCallBack;
}
}
public GetEdgesTesselator()
{
callBegin += new Tesselator <T> .CallBeginDelegate(BeginCallBack);
callEnd += new Tesselator <T> .CallEndDelegate(EndCallBack);
callVertex += new Tesselator <T> .CallVertexDelegate(VertexCallBack);
callCombine += new Tesselator <T> .CallCombineDelegate(CombineCallBack);
BoundaryOnly = true;
}
/// <summary>
/// connect to actual Tesselator
/// </summary>
/// <param name="tesselator"></param>
/// <param name="setEdgeFlag"></param>
public void Connect(Tesselator tesselator, bool setEdgeFlag)
{
NeedEdgeFlag = setEdgeFlag;
tesselator.SetListener(this);
//tesselator.callBegin = OnBegin;
//tesselator.callEnd = OnEnd;
//tesselator.callVertex = OnVertex;
//tesselator.callCombine = OnCombine;
//if (setEdgeFlag)
//{
// tesselator.callEdgeFlag = OnEdgeFlag;
//}
}
void Start()
{
Vector2[] points;
var collider = this.GetComponent <PolygonCollider2D> ();
if (collider)
{
points = collider.points;
ShrinkPolygon(-200, ref collider);
tesselator = new Tesselator(collider.points);
collider.points = points;
}
animator = GetComponent <Animator>();
}
public void BeginCallBack(Tesselator <T> .TriangleListType type)
{
switch (type)
{
case Tesselator <T> .TriangleListType.Triangles:
Gl.glBegin(Gl.GL_TRIANGLES);
break;
case Tesselator <T> .TriangleListType.TriangleFan:
Gl.glBegin(Gl.GL_TRIANGLE_FAN);
break;
case Tesselator <T> .TriangleListType.TriangleStrip:
Gl.glBegin(Gl.GL_TRIANGLE_STRIP);
break;
}
}
public void RenderGame()
{
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.ClearColor(0.2f, 0.2f, 0.8f, 1.0f);
Player.Camera.WorldView = Player.WorldToCamera();
Player.Camera.SetSize(Size.X, Size.Y, GameSettings.RENDER_NEAR_MIN, GameSettings.RENDER_FAR, GameSettings.RENDER_FOV);
Player.Camera.UseViewport();
Player.World.Sky.Draw(Player.Camera);
// mesh.Draw(Player.Camera);
foreach (Chunk chunk in Player.World.Chunks.Values)
{
//Tesselator.DrawChunkBBB(Player.Camera, chunk);
Tesselator.DrawChunkBlocks(Player.Camera, chunk);
DebugDraw.DrawChunk(Player.Camera, chunk);
//Tesselator.DrawChunkMesh(Player.Camera, chunk, TestMesh);
//DebugDraw.DrawAABB(Player.Camera, Player.BoundingBox);
}
//cube.Draw(Player.Camera);
DebugText.Clear();
DebugText.WriteLine($"Player pos: {Player.Position}");
DebugText.WriteLine($"Player chunk: {Player.Chunk?.Location?.ToString()}");
//if (Player.Chunk != null)
//{
// DebugDraw.DrawChunkCenterOutline(Player.Camera, Player.Chunk);
//}
//DebugText.SetText(text);
//GL.FrontFace(FrontFaceDirection.Cw);
//obj.Draw(Player.Camera);
//GL.FrontFace(FrontFaceDirection.Ccw);
//DebugText.WriteLine($"Player Position: {Player.Position}");
//DebugText.WriteLine($"Player Look: X: {Player.CameraRotationX}, Y: {Player.CameraRotationY}");
//DebugDraw.DrawAABB(Player.Camera, Player.BoundingBox);
//DebugDraw.DrawXYZ(Player.Camera.Projection, Player.CameraRotationY, Player.CameraRotationX);
Context.SwapBuffers();
}
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();
}
/// <summary>
/// Builds the convex regions for a root node and all its children
/// </summary>
private void BuildConvexRegions( BspNode node )
{
// Find the bounding box for the tree
float[] bounds = new float[ 4 ] { float.MaxValue, float.MaxValue, float.MinValue, float.MinValue };
GetNodeBoundingRectangle( node, bounds );
// Expand bounds a bit
float boundary = 1.0f;
bounds[ 0 ] -= boundary;
bounds[ 1 ] -= boundary;
bounds[ 2 ] += boundary;
bounds[ 3 ] += boundary;
float width = bounds[ 2 ] - bounds[ 0 ];
float height = bounds[ 3 ] - bounds[ 1 ];
Tesselator tess = new Tesselator( );
Tesselator.Polygon boundingPoly = tess.CreateBoundingPolygon( bounds[ 0 ], bounds[ 1 ], width, height );
BuildConvexRegions( node, tess, boundingPoly );
m_Points = tess.Points.ToArray( );
}
/// <summary>
/// Builds the convex region for a node and its children
/// </summary>
private static void BuildConvexRegions( BspNode node, Tesselator tess, Tesselator.Polygon poly )
{
Tesselator.Polygon behindPoly;
Tesselator.Polygon inFrontPoly;
tess.Split( node.Plane, poly, out behindPoly, out inFrontPoly );
if ( node.Behind != null )
{
BuildConvexRegions( node.Behind, tess, behindPoly );
}
if ( node.InFront != null )
{
BuildConvexRegions( node.InFront, tess, inFrontPoly );
}
else
{
node.ConvexRegion = inFrontPoly.Indices;
}
}
public TessTool(Tesselator tess)
{
this.tess = tess;
this.tessListener = new TessListener();
tessListener.Connect(tess, true);
}
public TessTool2(Tesselator tess)
{
_tess = tess;
}
private static void TesselatorCallBegin(Tesselator.Tesselator.TriangleListType type)
{
BeginMode beginMode;
switch (type)
{
case Tesselator.Tesselator.TriangleListType.LineLoop:
beginMode = BeginMode.LineLoop;
break;
case Tesselator.Tesselator.TriangleListType.Triangles:
beginMode = BeginMode.Triangles;
break;
case Tesselator.Tesselator.TriangleListType.TriangleStrip:
beginMode = BeginMode.TriangleStrip;
break;
case Tesselator.Tesselator.TriangleListType.TriangleFan:
beginMode = BeginMode.TriangleFan;
break;
default:
throw new ArgumentOutOfRangeException("type");
}
GL.Begin(beginMode);
}
public TessTool(Tesselator tess)
{
_tess = tess;
_tessListener = new TessListener();
_tessListener.Connect(tess, true);
}
