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); }