dont include start of last node

Author: Maxxen

src/sgl/sgl.cpp

@@ -1265,6 +1265,58 @@ namespace sgl {
 
 namespace {
 
+
+static bool feq(double x, double y) {
+	return !((x < y) | (x > y));
+}
+
+static bool eq_zero(double x) {
+	return feq(x, 0);
+}
+
+static bool collinear(
+	double x1, double y1, // point 1
+	double x2, double y2, // point 2
+	double x3, double y3  // point 3
+) {
+	bool x1x2 = feq(x1, x2);
+	bool x1x3 = feq(x1, x3);
+	bool x2x3 = feq(x2, x3);
+	bool y1y2 = feq(y1, y2);
+	bool y1y3 = feq(y1, y3);
+	bool y2y3 = feq(y2, y3);
+	if (x1x2) {
+		return x1x3;
+	}
+	if (y1y2) {
+		return y1y3;
+	}
+	if ((x1x2 & y1y2) | (x1x3 & y1y3) | (x2x3 & y2y3)) {
+		return true;
+	}
+	double cx1 = x3 - x1;
+	double cy1 = y3 - y1;
+	double cx2 = x2 - x1;
+	double cy2 = y2 - y1;
+	double s1 = cx1 * cy2;
+	double s2 = cy1 * cx2;
+	// Check if precision was lost.
+	double s3 = (s1 / cy2) - cx1;
+	double s4 = (s2 / cx2) - cy1;
+	if (s3 < 0) {
+		s1 = nexttoward(s1, -INFINITY);
+	} else if (s3 > 0) {
+		s1 = nexttoward(s1, +INFINITY);
+	}
+	if (s4 < 0) {
+		s2 = nexttoward(s2, -INFINITY);
+	} else if (s4 > 0) {
+		s2 = nexttoward(s2, +INFINITY);
+	}
+	return eq_zero(s1 - s2);
+}
+
+
 // TODO: Make robust
 // Returns the orientation of the triplet (p, q, r)
 // 0 if collinear, >0 if clockwise, <0 if counter-clockwise
@@ -1280,6 +1332,93 @@ enum class raycast_result {
 	CROSS,
 	BOUNDARY
 };
+static bool pteq(const vertex_xy &a, const vertex_xy &b) {
+	return feq(a.x, b.x) && feq(a.y, b.y);
+}
+
+static raycast_result raycast_robust(const vertex_xy &prev, const vertex_xy &next, const vertex_xy &vert) {
+	extent_xy r;
+	r.min.x = std::min(prev.x, next.x);
+	r.min.y = std::min(prev.y, next.y);
+	r.max.x = std::max(prev.x, next.x);
+	r.max.y = std::max(prev.y, next.y);
+
+	if (vert.y < r.min.y || vert.y > r.max.y) {
+		return raycast_result::NONE;
+	}
+	if (vert.x < r.min.x) {
+		if (vert.y != r.min.y && vert.y != r.max.y) {
+			return raycast_result::CROSS;
+		}
+	} else if (vert.x > r.max.x) {
+		if (r.min.y != r.max.y && r.min.x != r.max.x) {
+			return raycast_result::NONE;
+		}
+	}
+	vertex_xy p = vert;
+	vertex_xy a = prev;
+	vertex_xy b = next;
+
+	if (a.y < b.y) {
+		vertex_xy t = a;
+		a = b;
+		b = t;
+	}
+	if (pteq(vert, a) || pteq(vert, b)) {
+		return raycast_result::BOUNDARY;
+	}
+	if (a.y == b.y) {
+		if (a.x == b.x) {
+			return raycast_result::NONE;
+		}
+		if (p.y == b.y) {
+			if (!(p.x < r.min.x || p.x > r.max.x)) {
+				return raycast_result::BOUNDARY;
+			}
+		}
+	}
+	if (a.x == b.x && vert.x == b.x) {
+		if (vert.y >= a.y && vert.y <= b.y) {
+			return raycast_result::BOUNDARY;
+		}
+	}
+	if (collinear(a.x, a.y, b.x, b.y, p.x, p.y)) {
+		if (p.x < r.min.x) {
+			if (r.min.y == r.max.y) {
+				return raycast_result::NONE;
+			}
+		} else if (p.x > r.max.x) {
+			return raycast_result::NONE;
+		}
+		return raycast_result::BOUNDARY;
+	}
+	if (p.y == a.y || p.y == b.y) {
+		p.y = nexttoward(p.y, INFINITY);
+	}
+	if (p.y < a.y || p.y > b.y) {
+		return raycast_result::NONE;
+	}
+	if (a.x > b.x) {
+		if (p.x >= a.x) {
+			return raycast_result::NONE;
+		}
+		if (p.x <= b.x) {
+			return raycast_result::CROSS;
+		}
+	} else {
+		if (p.x >= b.x) {
+			return raycast_result::NONE;
+		}
+		if (p.x <= a.x) {
+			return raycast_result::CROSS;
+		}
+	}
+	if ((p.y-a.y)/(p.x-a.x) >= (b.y-a.y)/(b.x-a.x)) {
+		return raycast_result::CROSS;
+	}
+	return raycast_result::NONE;
+}
+
 
 // TODO: Make robust
 raycast_result raycast_fast(const vertex_xy &prev, const vertex_xy &next, const vertex_xy &vert) {
@@ -2410,7 +2549,7 @@ point_in_polygon_result prepared_geometry::contains(const vertex_xy &vert) const
 			}
 
 			// The end of this node is either the end of the current node, or the end of the level
-			const auto node_end = (stack[depth - 1] + 1) * NODE_SIZE;
+			const auto node_end = ((stack[depth - 1] + 1) * NODE_SIZE) - 1;
 			const auto levl_end = index.level_array[depth].entry_count - 1;
 
 			const auto end = math::min(node_end, levl_end);