lots of hacks, but it is starting to work

hiddenwire.c

@@ -49,12 +49,9 @@ struct _tri_t
 };
 
 
-// line segment has to track its source so that it knows which to not
-// compare against in its occlusion checks.
 typedef struct _seg_t seg_t;
 struct _seg_t {
 	v3_t p[2];
-	v3_t src[2];
 	seg_t * next;
 };
 
@@ -242,15 +239,16 @@ static float poly_min[2], poly_max[2];
 static inline int
 v2_eq(
 	const float p0[],
-	const float p1[]
+	const float p1[],
+	const float eps
 )
 {
 	const float dx = p0[0] - p1[0];
 	const float dy = p0[1] - p1[1];
 
 	// are the points within epsilon of each other?
-	if (-EPS < dx && dx < EPS
+	if (-eps < dx && dx < eps
-	&&  -EPS < dy && dy < EPS)
+	&&  -eps < dy && dy < eps)
 		return 1;
 
 	// nope, not equal
@@ -299,7 +297,7 @@ get_line_intersection(
 
 	if (s > EPS && s < 1-EPS && t > EPS && t < 1-EPS)
 	{
-		if(0) fprintf(stderr, "collision: %f,%f->%f,%f %f,%f->%f,%f == %f,%f\n",
+		if(1) fprintf(stderr, "collision: %f,%f->%f,%f %f,%f->%f,%f == %f,%f\n",
 			p0_x, p0_y,
 			p1_x, p1_y,
 			p2_x, p2_y,
@@ -320,30 +318,96 @@ get_line_intersection(
 }
 
 
-int
+/** Compute the points of intersection for two segments in 2d, and z points.
-intersect(
+ *
-	const v3_t * const p00,
+ * This is a specialized ray intersection algorithm for the
-	const v3_t * const p01,
+ * hidden wire-frame removal code that computes the intersection
-	const v3_t * const p10,
+ * points for two rays (in 2D, "orthographic") and then computes
-	const v3_t * const p11,
+ * the Z depth for the intersections along each of the segments.
-	float *px,
+ *
-	float *py
+ * Returns -1 for non-intersecting, otherwise a ratio of how far
+ * along the intersection is on the l0.
+ */
+float
+hidden_intersect(
+	const v3_t * const p0,
+	const v3_t * const p1,
+	const v3_t * const p2,
+	const v3_t * const p3,
+	v3_t * const l0_int,
+	v3_t * const l1_int
 )
 {
-	// special case; if this is the same line, it does not intersect
+	const float p0_x = p0->p[0];
-	if (v2_eq(p00->p, p10->p) && v2_eq(p01->p, p11->p))
+	const float p0_y = p0->p[1];
-		return 0;
+	const float p0_z = p0->p[2];
-	if (v2_eq(p01->p, p10->p) && v2_eq(p00->p, p11->p))
+	const float p1_x = p1->p[0];
-		return 0;
+	const float p1_y = p1->p[1]; 
+	const float p1_z = p1->p[2];
+	const float p2_x = p2->p[0];
+	const float p2_y = p2->p[1];
+	const float p2_z = p2->p[2];
+	const float p3_x = p3->p[0];
+	const float p3_y = p3->p[1];
+	const float p3_z = p3->p[2];
 
-	return get_line_intersection(
+	const float s1_x = p1_x - p0_x;
-		p00->p[0], p00->p[1],
+	const float s1_y = p1_y - p0_y;
-		p01->p[0], p01->p[1],
+	const float s2_x = p3_x - p2_x;
-		p10->p[0], p10->p[1],
+	const float s2_y = p3_y - p2_y;
-		p11->p[0], p11->p[1],
+
-		px,
+	// compute r x s
-		py
+	const float d = -s2_x * s1_y + s1_x * s2_y;
+
+	// if they are close to parallel, then we do not need to check
+	// for intersection (we define that as "non-intersecting")
+	if (-EPS < d && d < EPS)
+		return -1;
+
+	// Compute how far along each line they would interesect
+	const float r0 = ( s2_x * (p0_y - p2_y) - s2_y * (p0_x - p2_x)) / d;
+	const float r1 = (-s1_y * (p0_x - p2_x) + s1_x * (p0_y - p2_y)) / d;
+
+	// if they are not within the ratio (0,1), then the intersecton occurs
+	// outside of the segments and is not of concern
+	if (r0 < 0 || r0 > 1)
+		return -1;
+	if (r1 < 0 || r1 > 1)
+		return -1;
+
+	// Collision detected with the segments
+if(0) fprintf(stderr, "collision: %.0f,%.0f,%.0f->%.0f,%.0f,%.0f %.0f,%.0f,%.0f->%.0f,%.0f,%.0f == %.3f,%.3f\n",
+		p0_x, p0_y, p0_z,
+		p1_x, p1_y, p1_z,
+		p2_x, p2_y, p2_z,
+		p3_x, p3_y, p2_z,
+		r0,
+		r1
 	);
+
+	const float ix = p0_x + (r0 * s1_x);
+	const float iy = p0_y + (r0 * s1_y);
+
+	// compute the z intercept for each on the two different coordinates
+	if(l0_int)
+	{
+		*l0_int = (v3_t){{
+			ix,
+			iy,
+			p0_z + r0 * (p1_z - p0_z)
+		}};
+	}
+
+	if(l1_int)
+	{
+		*l1_int = (v3_t){{
+			ix,
+			iy,
+			p2_z + r1 * (p3_z - p2_z)
+		}};
+	}
+
+	return r0;
 }
 
 
@@ -924,14 +988,79 @@ seg_new(
 		return NULL;
 	s->p[0] = p0;
 	s->p[1] = p1;
-	s->src[0] = p0;
-	s->src[1] = p1;
 	s->next = NULL;
 
 	return s;
 }
 
 
+void
+seg_print(
+	const seg_t * const s
+)
+{
+	fprintf(stderr, "%.0f,%.0f -> %.0f,%.0f\n",
+		s->p[0].p[0],
+		s->p[0].p[1],
+		s->p[1].p[0],
+		s->p[1].p[1]
+	);
+}
+
+void
+tri_print(
+	const tri_t * const t
+)
+{
+	fprintf(stderr, "%.0f,%.0f,%.0f %.0f,%.0f,%.0f %.0f,%.0f,%.0f\n",
+		t->p[0].p[0],
+		t->p[0].p[1],
+		t->p[0].p[2],
+		t->p[1].p[0],
+		t->p[1].p[1],
+		t->p[1].p[2],
+		t->p[2].p[0],
+		t->p[2].p[1],
+		t->p[2].p[2]
+	);
+}
+
+/** Find the Z point of a given xy point along the segment from p0 to p1.
+ *
+ * Returns -1 if there is no known Z point.
+ */
+float
+find_z(
+	const v3_t * const p0,
+	const v3_t * const p1,
+	const float x,
+	const float y
+)
+{
+	const float dx = p1->p[0] - p0->p[0];
+	const float dy = p1->p[1] - p0->p[1];
+	const float dz = p1->p[2] - p0->p[2];
+
+	// find the z value of the intersection point
+	// on the segment. we don't care about the triangle
+	float ratio = 0;
+	if (dx != 0)
+	{
+		ratio = (x - p0->p[0]) / dx;
+	} else
+	if (dy != 0)
+	{
+		ratio = (y - p0->p[1]) / dy;
+	} else {
+		fprintf(stderr, "uh, dx and dy both zero?\n");
+		return -1;
+	}
+
+	return p0->p[2] + dz * ratio;
+}
+
+
+
 /*
 int
 tri_line_intersect(
@@ -967,22 +1096,41 @@ tri_seg_intersect(
 	seg_t ** slist_visible
 )
 {
-	const float p0x = s->p[0].p[0];
-	const float p0y = s->p[0].p[1];
 	const float p0z = s->p[0].p[2];
-	const float p1x = s->p[1].p[0];
-	const float p1y = s->p[1].p[1];
 	const float p1z = s->p[1].p[2];
+	const float seg_max_z = max(p0z, p1z);
 
 	for( const tri_t * t = zlist ; t ; t = t->next )
 	{
 		// if the segment is closer than the triangle,
 		// then we no longer have to check any further into
 		// the zlist (it is sorted by depth).
-		if (p0z < t->min[2] && p1z < t->min[2])
+		if (seg_max_z <= t->min[2])
 			break;
 
+
 #if 0
+		// make sure that we're not comparing to our own triangle
+		// or one that shares an edge with us (which might be in
+		// a different order)
+		if (v2_eq(s->src[0].p, t->p[0].p, 0.1)
+		&&  v2_eq(s->src[1].p, t->p[1].p, 0.1))
+			continue;
+		if (v2_eq(s->src[0].p, t->p[1].p, 0.1)
+		&&  v2_eq(s->src[1].p, t->p[2].p, 0.1))
+			continue;
+		if (v2_eq(s->src[0].p, t->p[2].p, 0.1)
+		&&  v2_eq(s->src[1].p, t->p[0].p, 0.1))
+			continue;
+		if (v2_eq(s->src[0].p, t->p[1].p, 0.1)
+		&&  v2_eq(s->src[1].p, t->p[0].p, 0.1))
+			continue;
+		if (v2_eq(s->src[0].p, t->p[2].p, 0.1)
+		&&  v2_eq(s->src[1].p, t->p[1].p, 0.1))
+			continue;
+		if (v2_eq(s->src[0].p, t->p[0].p, 0.1)
+		&&  v2_eq(s->src[1].p, t->p[2].p, 0.1))
+			continue;
 		// do a quick test of does this segment even comes
 		// close to this triangle
 		if (p0x < t->min[0] && p1x < t->min[0]
@@ -1012,27 +1160,49 @@ tri_seg_intersect(
 
 		// if both are inside we discard this segment
 		if (inside0 && inside1)
+		{
+			//svg_line("#0000FF", s->p[0].p, s->p[1].p, 0);
+			//svg_line("#00FF00", t->p[0].p, t->p[1].p, 0);
+			//svg_line("#00FF00", t->p[1].p, t->p[2].p, 0);
+			//svg_line("#00FF00", t->p[2].p, t->p[0].p, 0);
+fprintf(stderr, "BOTH INSIDE\n");
+tri_print(t);
+seg_print(s);
 			return;
+		}
 
 		// split the segment for each intersection with the
 		// triangle segments and add it to the work queue.
 		int intersections = 0;
-		v3_t ix[3] = {};
+		v3_t is[3] = {}; // 3d point of segment intercept
- 		const float max_z = max(s->p[0].p[2], s->p[1].p[2]);
+		v3_t it[3] = {}; // 3d point of triangle intercept
 
 		for(int j = 0 ; j < 3 ; j++)
 		{
-			ix[j].p[2] = max_z;
+			float ratio = hidden_intersect(
-			int rc = intersect(
 				&s->p[0], &s->p[1],
 				&t->p[j], &t->p[(j+1)%3],
-				&ix[intersections].p[0], &ix[intersections].p[1]
+				&is[intersections],
+				&it[intersections]
 			);
 
-			if (!rc)
+			if (ratio < 0)
 				continue;
 
-			intersections++;
+			// deal with corner cases where the segment
+			// exactly lines up with the triangle edge
+			// we do not treat this as an intersection
+			if (-EPS < ratio && ratio < EPS)
+			{
+				inside0 = 0;
+			} else
+			if (1-EPS < ratio && ratio < 1+EPS)
+			{
+				inside1 = 0;
+			} else {
+				// this is a real intersection
+				intersections++;
+			}
 		}
 
 		// if none of them intersect, we keep looking
@@ -1051,31 +1221,46 @@ fprintf(stderr, "split %d %d inter %d\n", inside0 , inside1, intersections);
 			if (inside0 || inside1)
 			{
 				fprintf(stderr, "uh, inside but two intersections?\n");
-				return;
+				//return;
 			}
 
+			// if the segment intersection is closer than the triangle,
+			// then we do nothing. degenerate cases are not handled
+			if (is[0].p[2] <= it[0].p[2]
+			||  is[1].p[2] <= it[1].p[2])
+			{
+fprintf(stderr, "ignoring collision since z %f < %f || %f < %f\n",
+			is[0].p[2], it[0].p[2],
+			is[1].p[2], it[1].p[2]);
+		
+				continue;
+			}
+
+			// segment is behind the triangle,
 			// we have to create a new segment
 			// and shorten the existing segment
 			// find the two intersections that we have
 			// update the src field
 			
 
-			fprintf(stderr, "two intersections\n");
+			const float d0 = v3_len(&s->p[0], &is[0]);
-			const float d0 = v2_dist(s->p[0].p, ix[0].p);
+			const float d1 = v3_len(&s->p[0], &is[1]);
-			const float d1 = v2_dist(s->p[1].p, ix[0].p);
+			fprintf(stderr, "two intersections %.0f %.0f\n", d0, d1);
 			seg_t * news;
 			if (d0 < d1)
 			{
 				// split from p0 to ix0
-				news = seg_new(s->p[0], ix[0]);
+				news = seg_new(s->p[0], is[0]);
-				news->src[1] = s->p[1];
+				s->p[0] = is[1];
-				s->p[1] = ix[1];
 			} else {
 				// split from p0 to ix1
-				news = seg_new(s->p[0], ix[1]);
+				news = seg_new(s->p[0], is[1]);
-				news->src[1] = s->p[1];
+				s->p[0] = is[0];
-				s->p[1] = ix[0];
 			}
+fprintf(stderr, "old segment:" );
+seg_print(s);
+fprintf(stderr, "new segment:" );
+seg_print(news);
 
 			// recursively start splitting the new segment
 			// starting at our current z-depth
@@ -1087,36 +1272,47 @@ fprintf(stderr, "split %d %d inter %d\n", inside0 , inside1, intersections);
 
 		if (intersections == 1)
 		{
-fprintf(stderr, "split %d %d\n", inside0, inside1);
+			// if there is an intersection, but the segment intercept
+			// is close than the triangle intercept, then no problem.
+			// we do not bother with degenerate cases of intersecting
+			// triangles
+			if (is[0].p[2] <= it[0].p[2])
+				continue;
+
+			// segment is behind the triangle, so it needs to be
+			// cut into pieces
 			if (inside0)
 			{
 				// shorten it on the 0 side
-				s->p[0] = ix[0];
+				s->p[0] = is[0];
+				continue;
 			} else
 			if (inside1)
 			{
 				// shorten it on the 1 side
-				s->p[1] = ix[0];
+				s->p[1] = is[0];
+				continue;
+			} else
+			if (v2_eq(s->p[0].p, is[0].p, 0.1))
+			{
+				// the 0 side is on the triangle, don't bother
+				continue;
+			} else
+			if (v2_eq(s->p[1].p, is[0].p, 0.1))
+			{
+				// the 1 side is on the triangle, don't bother
+				continue;
 			} else {
-				fprintf(stderr, "uh, both outside but one intersection?\n");
+				fprintf(stderr, "uh, both outside but one intersection?  %.3f,%.3f\n",
-				return;
+	is[0].p[0],
+	is[0].p[1]
+);
+seg_print(s);
+tri_print(t);
+				//svg_line("#00FF00", s->p[0].p, s->p[1].p, 0);
+				continue;
 			}
 		}
-			
-
-if(0) fprintf(stderr, "check: %.0f,%.0f -> %.0f,%.0f  %.0f,%.0f %.0f,%.0f %.0f,%.0f\n",
-	s->p[0].p[0],
-	s->p[0].p[1],
-	s->p[1].p[0],
-	s->p[1].p[1],
-	t->p[0].p[0],
-	t->p[0].p[1],
-	t->p[1].p[0],
-	t->p[1].p[1],
-	t->p[2].p[0],
-	t->p[2].p[1]
-);
-		//return;
 	}
 
 	// if we've reached here the segment is visible
@@ -1141,6 +1337,13 @@ int main(
 	char ** argv
 )
 {
+	v3_t p0 = {{ 0, 0, 0 }};
+	v3_t p1 = {{ 100, 100, 100 }};
+	v3_t p2 = {{ 200, -100, 0 }};
+	v3_t p3 = {{ 0, 100, 200 }};
+	v3_t is, it;
+	hidden_intersect(&p0, &p1, &p2, &p3, &is, &it);
+
 	const size_t max_len = 32 << 20;
 	uint8_t * const buf = calloc(max_len, 1);
 
@@ -1178,6 +1381,8 @@ int main(
 	seg_t * slist = NULL;
 	seg_t * slist_visible = NULL;
 
+	int retained = 0;
+
 	// transform the stl by the camera projection and generate
 	// a z-sorted list of triangles
 	for (int i = 0 ; i < num_triangles ; i++)
@@ -1212,6 +1417,10 @@ int main(
 			slist = s;
 		}
 
+		retained++;
+		if( retained > 3)
+			break;
+
 		continue;
 
 reject:
@@ -1220,19 +1429,29 @@ reject:
 	}
 
 	if (debug)
-		fprintf(stderr, "Rejected %d triangles\n", rejected);
+		fprintf(stderr, "Retained %d, rejected %d triangles\n", retained, rejected);
+
+	for( const tri_t * t = zlist ; t ; t = t->next )
+		tri_print(t);
 
 	// we now have a z-sorted list of triangles
 	rejected = 0;
 
-	// work on each segment, intersecting it with all of the triangles
+	if(1)
-	while(slist)
 	{
-		seg_t * s = slist;
+		// work on each segment, intersecting it with all of the triangles
-		slist = s->next;
+		while(slist)
+		{
+			seg_t * s = slist;
+			slist = s->next;
 
-		tri_seg_intersect(zlist, s, &slist_visible);
+			tri_seg_intersect(zlist, s, &slist_visible);
 
+		}
+	} else {
+		// don't do any intersection tests
+		slist_visible = slist;
+		slist = NULL;
 	}
 
 	// display all of the visible segments