optimized + allow Int points units with -D fastPoly2tri

hxd/poly2tri/AdvancingFront.hx

@@ -12,7 +12,7 @@ class AdvancingFront
 		this.tail = tail;
 	}
 
-	public function locateNode(x:Float):Node
+	public function locateNode(x:Constants.Unit):Node
 	{
 		var node:Node = this.search_node;
 
@@ -44,10 +44,10 @@ class AdvancingFront
 
 	public function locatePoint(point:Point):Node
 	{
-		var px:Float = point.x;
+		var px = point.x;
 		//var node:* = this.FindSearchNode(px);
 		var node:Node = this.search_node;
-		var nx:Float = node.point.x;
+		var nx = node.point.x;
 
 		if (px == nx)
 		{

hxd/poly2tri/Constants.hx

@@ -1,12 +1,22 @@
 package hxd.poly2tri;
 
+#if fastPoly2tri
+typedef Unit = Int;
+#else
+typedef Unit = Float;
+#end
+
 class Constants {
 	/*
 	 * Inital triangle factor, seed triangle will extend 30% of
 	 * PointSet width to both left and right.
 	 */
 	static public var kAlpha:Float   = 0.3;
+	#if fastPoly2tri
+	static public var EPSILON = 0;
+	#else
 	static public var EPSILON:Float  = 1e-12;
+	#end
 	static public var PI_2:Float     = Math.PI / 2;
 	static public var PI_3div4:Float = 3 * Math.PI / 4;
 }

hxd/poly2tri/Node.hx

@@ -33,10 +33,10 @@ class Node
 		 * Where x = ax*bx + ay*by
 		 *       y = ax*by - ay*bx
 		 */
-		var ax:Float = this.next.point.x - this.point.x;
-		var ay:Float = this.next.point.y - this.point.y;
-		var bx:Float = this.prev.point.x - this.point.x;
-		var by:Float = this.prev.point.y - this.point.y;
+		var ax = this.next.point.x - this.point.x;
+		var ay = this.next.point.y - this.point.y;
+		var bx = this.prev.point.x - this.point.x;
+		var by = this.prev.point.y - this.point.y;
 		return Math.atan2(
 			ax * by - ay * bx,
 			ax * bx + ay * by

hxd/poly2tri/Orientation.hx

@@ -8,11 +8,15 @@ class Orientation
 
 	public static function orient2d(pa:Point, pb:Point, pc:Point):Int
 	{
-		var detleft:Float  = (pa.x - pc.x) * (pb.y - pc.y);
-		var detright:Float = (pa.y - pc.y) * (pb.x - pc.x);
-		var val:Float = detleft - detright;
+		var detleft  = (pa.x - pc.x) * (pb.y - pc.y);
+		var detright = (pa.y - pc.y) * (pb.x - pc.x);
+		var val = detleft - detright;
 
+		#if fastPoly2tri
+		if( val == 0 ) return COLLINEAR;
+		#else
 		if ((val > -Constants.EPSILON) && (val < Constants.EPSILON)) return Orientation.COLLINEAR;
+		#end
 		if (val > 0) return Orientation.CCW;
 		return Orientation.CW;
 	}

hxd/poly2tri/Point.hx

@@ -4,8 +4,13 @@ class Point
 {
 	public var id:Int;
 
+	#if fastPoly2tri
+	public var x:Int;
+	public var y:Int;
+	#else
 	public var x:Float;
 	public var y:Float;
+	#end
 
 	/// The edges this point constitutes an upper ending point
 	#if haxe3
@@ -33,9 +38,13 @@ class Point
 
 
 
-	public function equals(that:Point):Bool
+	public inline function equals(that:Point):Bool
 	{
+		#if fastPoly2Tri
+		return this == that;
+		#else
 		return (this.x == that.x) && (this.y == that.y);
+		#end
 	}
 
 	public static function sortPoints(points:Array<Point>)
@@ -45,7 +54,7 @@ class Point
 
 	public static function cmpPoints(l:Point,r:Point)
 	{
-		var ret:Float = l.y - r.y;
+		var ret = l.y - r.y;
 		if (ret == 0) ret = l.x - r.x;
 		if (ret <  0) return -1;
 		if (ret >  0) return 1;

hxd/poly2tri/Sweep.hx

@@ -342,9 +342,9 @@ class Sweep
 	}
 
 
-	public function isShallow(node:Node):Bool
+	public inline function isShallow(node:Node):Bool
 	{
-		var height:Float = ( (this.context.basin.left_highest)
+		var height = ( (this.context.basin.left_highest)
 			? this.context.basin.left_node.point.y - node.point.y
 			: this.context.basin.right_node.point.y - node.point.y
 		);

hxd/poly2tri/SweepContext.hx

@@ -94,6 +94,11 @@ class SweepContext
 
 		var dx = Constants.kAlpha * (xmax - xmin);
 		var dy = Constants.kAlpha * (ymax - ymin);
+		
+		#if fastPoly2tri
+		var dx = Math.ceil(dx);
+		var dy = Math.ceil(dy);
+		#end
 
 		this.head = new Point(xmax + dx, ymin - dy);
 		this.tail = new Point(xmin - dy, ymin - dy);

hxd/poly2tri/Triangle.hx

@@ -147,45 +147,45 @@ class Triangle
 	inline static private var CW_OFFSET = 1;
 	inline static private var CCW_OFFSET = -1;
 
-	public function pointCW (p:Point):Point
+	public inline function pointCW (p:Point):Point
 	{
 		return this.points[getPointIndexOffset(p, CCW_OFFSET)];
 	}
 
-	public function pointCCW(p:Point):Point
+	public inline function pointCCW(p:Point):Point
 	{
 		return this.points[getPointIndexOffset(p, CW_OFFSET)];
 	}
 
-	public function neighborCW(p:Point):Triangle
+	public inline function neighborCW(p:Point):Triangle
 	{
 	 	return this.neighbors[getPointIndexOffset(p, CW_OFFSET)];
 	}
 	
-	public function neighborCCW(p:Point):Triangle
+	public inline function neighborCCW(p:Point):Triangle
 	{
 		return this.neighbors[getPointIndexOffset(p, CCW_OFFSET)];
 	}
 
-	public function getConstrainedEdgeCW(p:Point):Bool              { return this.constrained_edge[getPointIndexOffset(p, CW_OFFSET)]; }
-	public function setConstrainedEdgeCW(p:Point, ce:Bool):Bool  { return this.constrained_edge[getPointIndexOffset(p, CW_OFFSET)] = ce; }
+	public inline function getConstrainedEdgeCW(p:Point):Bool              { return this.constrained_edge[getPointIndexOffset(p, CW_OFFSET)]; }
+	public inline function setConstrainedEdgeCW(p:Point, ce:Bool):Bool  { return this.constrained_edge[getPointIndexOffset(p, CW_OFFSET)] = ce; }
 
-	public function getConstrainedEdgeCCW(p:Point):Bool             { return this.constrained_edge[getPointIndexOffset(p, CCW_OFFSET)]; }
-	public function setConstrainedEdgeCCW(p:Point, ce:Bool):Bool { return this.constrained_edge[getPointIndexOffset(p, CCW_OFFSET)] = ce; }
+	public inline function getConstrainedEdgeCCW(p:Point):Bool             { return this.constrained_edge[getPointIndexOffset(p, CCW_OFFSET)]; }
+	public inline function setConstrainedEdgeCCW(p:Point, ce:Bool):Bool { return this.constrained_edge[getPointIndexOffset(p, CCW_OFFSET)] = ce; }
 
-	public function getDelaunayEdgeCW(p:Point):Bool                 { return this.delaunay_edge[getPointIndexOffset(p, CW_OFFSET)]; }
-	public function setDelaunayEdgeCW(p:Point, e:Bool):Bool      { return this.delaunay_edge[getPointIndexOffset(p, CW_OFFSET)] = e; }
+	public inline function getDelaunayEdgeCW(p:Point):Bool                 { return this.delaunay_edge[getPointIndexOffset(p, CW_OFFSET)]; }
+	public inline function setDelaunayEdgeCW(p:Point, e:Bool):Bool      { return this.delaunay_edge[getPointIndexOffset(p, CW_OFFSET)] = e; }
 	
-	public function getDelaunayEdgeCCW(p:Point):Bool                { return this.delaunay_edge[getPointIndexOffset(p, CCW_OFFSET)]; }
-	public function setDelaunayEdgeCCW(p:Point, e:Bool):Bool     { return this.delaunay_edge[getPointIndexOffset(p, CCW_OFFSET)] = e; }
+	public inline function getDelaunayEdgeCCW(p:Point):Bool                { return this.delaunay_edge[getPointIndexOffset(p, CCW_OFFSET)]; }
+	public inline function setDelaunayEdgeCCW(p:Point, e:Bool):Bool     { return this.delaunay_edge[getPointIndexOffset(p, CCW_OFFSET)] = e; }
 
 
 	/**
 	 * The neighbor across to given point.
 	 */
-	public function neighborAcross(p:Point):Triangle { return this.neighbors[getPointIndexOffset(p, 0)]; }
+	public inline function neighborAcross(p:Point):Triangle { return this.neighbors[getPointIndexOffset(p, 0)]; }
 
-	public function oppositePoint(t:Triangle, p:Point):Point
+	public inline function oppositePoint(t:Triangle, p:Point):Point
 	{
 		return this.pointCW(t.pointCW(p));
 	}
@@ -227,14 +227,9 @@ class Triangle
 	 *
 	 * @param	p
 	 */
-	public function index(p:Point):Int
+	public inline function index(p:Point):Int
 	{
-		try {
-			return this.getPointIndexOffset(p, 0);
-		} catch (msg:String) {
-			trace(msg);
-		}
-		return -1;
+		return this.getPointIndexOffset(p, 0);
 	}
 
 
@@ -259,17 +254,7 @@ class Triangle
 	}
 
 
-	/**
-	 * Mark an edge of this triangle as constrained.<br>
-	 * This method takes either 1 parameter (an edge index or an Edge instance) or
-	 * 2 parameters (two Point instances defining the edge of the triangle).
-	 */
-	public function markConstrainedEdgeByIndex(index:Int)
-	{
-		this.constrained_edge[index] = true;
-	}
-
-	public function markConstrainedEdgeByEdge(edge:Edge)
+	public inline function markConstrainedEdgeByEdge(edge:Edge)
 	{
 		this.markConstrainedEdgeByPoints(edge.p, edge.q);
 	}
@@ -307,7 +292,13 @@ class Triangle
 		var index:Int = this.edgeIndex(ep, eq);
 		if (index == -1) return false;
 		
-		this.markConstrainedEdgeByIndex(index);
+		/**
+		 * Mark an edge of this triangle as constrained.<br>
+		 * This method takes either 1 parameter (an edge index or an Edge instance) or
+		 * 2 parameters (two Point instances defining the edge of the triangle).
+		 */
+		this.constrained_edge[index] = true;
+		
 		var that:Triangle = this.neighbors[index];
 		if (that != null) that.markConstrainedEdgeByPoints(ep, eq);
 		return true;

hxd/poly2tri/Utils.hx

@@ -28,58 +28,58 @@ class Utils
 	 */
 	static public function insideIncircle(pa:Point, pb:Point, pc:Point, pd:Point):Bool
 	{
-		var adx:Float    = pa.x - pd.x;
-		var ady:Float    = pa.y - pd.y;
-		var bdx:Float    = pb.x - pd.x;
-		var bdy:Float    = pb.y - pd.y;
+		var adx    = pa.x - pd.x;
+		var ady    = pa.y - pd.y;
+		var bdx    = pb.x - pd.x;
+		var bdy    = pb.y - pd.y;
 
-		var adxbdy:Float = adx * bdy;
-		var bdxady:Float = bdx * ady;
-		var oabd:Float   = adxbdy - bdxady;
+		var adxbdy = adx * bdy;
+		var bdxady = bdx * ady;
+		var oabd   = adxbdy - bdxady;
 
 		if (oabd <= 0) return false;
 
-		var cdx:Float    = pc.x - pd.x;
-		var cdy:Float    = pc.y - pd.y;
+		var cdx = pc.x - pd.x;
+		var cdy = pc.y - pd.y;
 
-		var cdxady:Float = cdx * ady;
-		var adxcdy:Float = adx * cdy;
-		var ocad:Float   = cdxady - adxcdy;
+		var cdxady = cdx * ady;
+		var adxcdy = adx * cdy;
+		var ocad = cdxady - adxcdy;
 
 		if (ocad <= 0) return false;
 
-		var bdxcdy:Float = bdx * cdy;
-		var cdxbdy:Float = cdx * bdy;
+		var bdxcdy = bdx * cdy;
+		var cdxbdy = cdx * bdy;
 
-		var alift:Float  = adx * adx + ady * ady;
-		var blift:Float  = bdx * bdx + bdy * bdy;
-		var clift:Float  = cdx * cdx + cdy * cdy;
+		var alift = adx * adx + ady * ady;
+		var blift = bdx * bdx + bdy * bdy;
+		var clift = cdx * cdx + cdy * cdy;
 
-		var det:Float = alift * (bdxcdy - cdxbdy) + blift * ocad + clift * oabd;
+		var det = alift * (bdxcdy - cdxbdy) + blift * ocad + clift * oabd;
 		return det > 0;
 	}
 
 	static public function inScanArea(pa:Point, pb:Point, pc:Point, pd:Point):Bool
 	{
-		var pdx:Float = pd.x;
-		var pdy:Float = pd.y;
-		var adx:Float = pa.x - pdx;
-		var ady:Float = pa.y - pdy;
-		var bdx:Float = pb.x - pdx;
-		var bdy:Float = pb.y - pdy;
+		var pdx = pd.x;
+		var pdy = pd.y;
+		var adx = pa.x - pdx;
+		var ady = pa.y - pdy;
+		var bdx = pb.x - pdx;
+		var bdy = pb.y - pdy;
 
-		var adxbdy:Float = adx * bdy;
-		var bdxady:Float = bdx * ady;
-		var oabd:Float = adxbdy - bdxady;
+		var adxbdy= adx * bdy;
+		var bdxady = bdx * ady;
+		var oabd = adxbdy - bdxady;
 
 		if (oabd <= Constants.EPSILON) return false;
 
-		var cdx:Float = pc.x - pdx;
-		var cdy:Float = pc.y - pdy;
+		var cdx = pc.x - pdx;
+		var cdy = pc.y - pdy;
 
-		var cdxady:Float = cdx * ady;
-		var adxcdy:Float = adx * cdy;
-		var ocad:Float = cdxady - adxcdy;
+		var cdxady = cdx * ady;
+		var adxcdy = adx * cdy;
+		var ocad = cdxady - adxcdy;
 
 		if (ocad <= Constants.EPSILON) return false;