csg 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 032ae67480be4a8091aaceae652d8f7ba608c799
-  data.tar.gz: e9c632170b74ef2bc33a62f4f54f6a39be8176e2
+  metadata.gz: 75fa78d0a7457950ab6f58724d12d6889a1ad040
+  data.tar.gz: e42df82e618300fd3ecbb378b5671e30c241adc0
 SHA512:
-  metadata.gz: 59540582ac22f6e0beb5158c023e2e492ac470ca52e324c807d14869c1d1d8b00dbb8825d2b52ffdcd271aa553b263e918a4004e7af00a500bdfd75aeea32e00
-  data.tar.gz: e53ca53c28394c684e3647660350725a2db98cc4a232f652aa4d785ae8a0d9c3b23e35e0a3b725f69ee4fb53ccf4024b784aa76f5e25e67af35e25b9af5cf443
+  metadata.gz: f38fca9b843039bd79aee405e6b25fb9284f925cb3799ab9b11438800c76960c47a688bf5ed4e6946a52ae8f915712dbae7152103c1df9c582153dd2d7bd42ff
+  data.tar.gz: 8aa32fdda09f7abba5cbac125581ac258cee68761a97eddd659749a6408268846dc377e85a319c2716c71f7ba6e05c97c810e5384dcd0f548d4c27f430560a58

data/Makefile

@@ -10,6 +10,17 @@ CPPFLAGS = $(OPTCPPFLAGS)
 LIBS = -lm $(OPTLIBS)
 CFLAGS = -D_POSIX_C_SOURCE=200112L -g -std=c99 $(INCLUDE) -Wall -Werror $(OPTFLAGS)
 
+# If DEBUG is set, we build a new set of objects and a new target
+ifneq ($(origin DEBUG), undefined)
+OBJS = $(patsubst %.c,%.dbg.o,$(SOURCES))
+TARGET := $(TARGET).dbg
+endif
+
+# If RELEASE is set, we turn on NDEBUG and NO_LINENOS
+ifneq ($(origin RELEASE), undefined)
+CFLAGS += -DNDEBUG -DNO_LINENOS -UDEBUG
+endif
+
 ifeq ($(shell uname),Darwin)
 LIB_TARGET = libcsg.dylib
 else
@@ -20,11 +31,11 @@ endif
 all: $(TARGET) $(LIB_TARGET)
 
 clean:
-	make -C tests clean
+	$(MAKE) -C tests clean
 	rm -rf $(OBJS) $(TARGET) $(TARGET).o $(TARGET).new $(LIB_TARGET)
 
 test:
-	@make -C tests clean test
+	@$(MAKE) -C tests clean test
 
 .PHONY: all clean test libcsg loc
 
@@ -37,6 +48,10 @@ $(LIB_TARGET): $(OBJS)
 
 libcsg: $(LIB_TARGET)
 
+
+%.dbg.o: %.c
+	$(CC) -fPIC $(CFLAGS) -DDEBUG -o $@ -c $^
+
 %.o: %.c
 	$(CC) -fPIC $(CFLAGS) -o $@ -c $^
 

data/lib/csg.rb

@@ -1,6 +1,8 @@
 require 'ffi'
 
 module CSG
+  class Error < StandardError; end
+
   module Native
     extend FFI::Library
 
@@ -70,7 +72,7 @@ module CSG
       if not mesh_ptr.null?
           @mesh = CSG::Native::Mesh.new mesh_ptr
       else
-        raise Exception.new("Failed to produce Mesh from #{path}")
+        raise CSG::Error.new("Failed to produce Mesh from #{path}")
       end
     end
 
@@ -83,25 +85,25 @@ module CSG
       define_method name do |solid|
         # I'm so paranoid because ruby will gladly FFI through a
         # *NULL and explode if you ask, and that's much worse.
-        raise Exception.new("The calling mesh is a NULL pointer") if mesh.null?
-        raise Exception.new("The parameter mesh is a NULL pointer") if solid.mesh.null?
+        raise CSG::Error.new("The calling mesh is a NULL pointer") if mesh.null?
+        raise CSG::Error.new("The parameter mesh is a NULL pointer") if solid.mesh.null?
 
-        raise Exception.new("My BSP tree is NULL.") if (my_bsp_ptr = mesh[:to_bsp].call mesh).null?
+        raise CSG::Error.new("My BSP tree is NULL.") if (my_bsp_ptr = mesh[:to_bsp].call mesh).null?
         # Assign ASAP in case the exception triggers an unwind, and I want the GC to know about this
         my_bsp = CSG::Native::BSPNode.new(my_bsp_ptr)
 
-        raise Exception.new("My BSP tree is NULL.") if (their_bsp_ptr = solid.mesh[:to_bsp].call solid.mesh).null?
+        raise CSG::Error.new("My BSP tree is NULL.") if (their_bsp_ptr = solid.mesh[:to_bsp].call solid.mesh).null?
         their_bsp = CSG::Native::BSPNode.new(their_bsp_ptr)
 
         result_ptr = CSG::Native.send "bsp_#{name}", my_bsp, their_bsp
-        raise Exception.new("Result of #{name} is NULL") if result_ptr.null?
+        raise CSG::Error.new("Result of #{name} is NULL") if result_ptr.null?
 
         # We will not wrap the result in a CSG::Native::BSPNode because
         # to avoid garbage collection, and we'll manage this pointer
         # inside of the CSG::Native::Mesh object we get with
         # bsp_to_mesh(.., 0) - which will not clone the input parameter
         result_mesh_ptr = CSG::Native.bsp_to_mesh result_ptr, 0
-        raise Exception.new("Failed to wrap BSPNode(#{result_mesh_ptr} pointer as a Mesh, got NULL") if result_mesh_ptr.null?
+        raise CSG::Error.new("Failed to wrap BSPNode(#{result_mesh_ptr} pointer as a Mesh, got NULL") if result_mesh_ptr.null?
         CSG::Solid.new :mesh => CSG::Native::Mesh.new(result_mesh_ptr)
       end
     end

data/src/bsp.c

@@ -2,33 +2,29 @@
 
 #include "bsp.h"
 #include "dbg.h"
+#include "util.h"
 #include "export.h"
 #include "bsp_mesh.h"
 
 bsp_node_t *alloc_bsp_node(void) {
 	bsp_node_t *node = NULL;
-	check_mem(node = calloc(1, sizeof(bsp_node_t)));
+	assert_mem(node = calloc(1, sizeof(bsp_node_t)));
 	node->polygons = kl_init(poly);
 	return node;
-error:
-	return NULL;
 }
 
 bsp_node_t *clone_bsp_tree(bsp_node_t *tree) {
 	bsp_node_t *copy = alloc_bsp_node();
-	check_mem(copy);
 
 	kliter_t(poly) *iter = kl_begin(tree->polygons);
 	for(; iter != kl_end(tree->polygons); iter = kl_next(iter)) {
 		poly_t *poly_copy = clone_poly(kl_val(iter));
-		check_mem(poly_copy);
 		*kl_pushp(poly, copy->polygons) = poly_copy;
 	}
 
 	free_poly(copy->divider, 1);
 	if(tree->divider) {
 		copy->divider = clone_poly(tree->divider);
-		check_mem(copy->divider);
 	}
 	else {
 		copy->divider = NULL;
@@ -36,17 +32,12 @@ bsp_node_t *clone_bsp_tree(bsp_node_t *tree) {
 
 	if(tree->front != NULL) {
 		copy->front = clone_bsp_tree(tree->front);
-		check_mem(copy->front);
 	}
 	if(tree->back != NULL) {
 		copy->back = clone_bsp_tree(tree->back);
-		check_mem(copy->back);
 	}
 
 	return copy;
-error:
-	if(copy != NULL) free_bsp_tree(copy);
-	return NULL;
 }
 
 void free_bsp_node(bsp_node_t *node) {
@@ -98,11 +89,21 @@ int bsp_subdivide(poly_t *divider, poly_t *poly,
 		poly_t *b = NULL;
 		check(poly_split(divider, poly, &f, &b) == 0,
 			  "Failed to split polygon(%p) with divider(%p)", poly, divider);
-		front[*n_front] = f;
-		*n_front += 1;
 
-		back[*n_back] = b;
-		*n_back += 1;
+		// TODO: This is where shit can get weird.
+		//       When we create polygons we have the option of rejecting them
+		//       by freeing and setting them to NULL, preventing them from
+		//       being added to the result lists
+
+		// Append to the front and back lists and counts
+		if(f != NULL) {
+			front[*n_front] = f;
+			*n_front += 1;
+		}
+		if(b != NULL) {
+			back[*n_back] = b;
+			*n_back += 1;
+		}
 
 		// Do we care about telling the caller about polygons
 		// who's pointers are not in any of the "real" lists?
@@ -113,10 +114,14 @@ int bsp_subdivide(poly_t *divider, poly_t *poly,
 
 		// How about polygons that we just made?
 		if(created != NULL) {
-			created[*n_created] = f;
-			*n_created += 1;
-			created[*n_created] = b;
-			*n_created += 1;
+			if(f != NULL) {
+				created[*n_created] = f;
+				*n_created += 1;
+			}
+			if(b != NULL) {
+				created[*n_created] = b;
+				*n_created += 1;
+			}
 		}
 		break;
 	}
@@ -129,7 +134,7 @@ error:
 
 bsp_node_t *bsp_build(bsp_node_t *node, klist_t(poly) *polygons, int copy) {
 	poly_t **polys = NULL;
-	check_mem(polys = malloc(sizeof(poly_t*) * polygons->size));
+	assert_mem(polys = malloc(sizeof(poly_t*) * polygons->size));
 
 	kliter_t(poly) *iter = NULL;
 	int i = 0;
@@ -178,7 +183,6 @@ bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys,
 		// Allocate a node if we weren't given one. It's the nice
 		// thing to do for people.
 		node = alloc_bsp_node();
-		check_mem(node);
 	}
 
 	if(n_polys == 0) return node;
@@ -193,14 +197,13 @@ bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys,
 		poly_i += 1;
 
 		node->divider = clone_poly(polygons[0]);
-		check_mem(node->divider);
 	}
 
 
-	check_mem(coplanar = malloc(sizeof(poly_t*) * n_polys));
-	check_mem(front_p = malloc(sizeof(poly_t*) * n_polys));
-	check_mem(back_p = malloc(sizeof(poly_t*) * n_polys));
-	check_mem(unused = malloc(sizeof(poly_t*) * n_polys));
+	assert_mem(coplanar = malloc(sizeof(poly_t*) * n_polys));
+	assert_mem(front_p = malloc(sizeof(poly_t*) * n_polys));
+	assert_mem(back_p = malloc(sizeof(poly_t*) * n_polys));
+	assert_mem(unused = malloc(sizeof(poly_t*) * n_polys));
 	for(; poly_i < n_polys; poly_i++) {
 		poly = polygons[poly_i];
 		rc = bsp_subdivide(node->divider, poly,
@@ -236,13 +239,11 @@ bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys,
 
 	if((n_front > 0)) {
 		if(node->front == NULL) node->front = alloc_bsp_node();
-		check_mem(node->front);
 		check(bsp_build_array(node->front, front_p, n_front, free_unused) != NULL,
 			  "Failed to build front tree of bsp_node_array(%p)", node);
 	}
 	if((n_back > 0)) {
 		if(node->back == NULL) node->back = alloc_bsp_node();
-		check_mem(node->back);
 		check(bsp_build_array(node->back, back_p, n_back, free_unused) != NULL,
 			  "Failed to build back tree of bsp_node(%p)", node);
 	}
@@ -267,7 +268,6 @@ int bsp_copy_node_polygons(bsp_node_t *node, int make_triangles, klist_t(poly) *
 		int vertex_count = poly_vertex_count(poly);
 		if(!make_triangles || vertex_count == 3) {
 			poly_t *copy = clone_poly(poly);
-			check_mem(copy);
 			*kl_pushp(poly, dst) = copy;
 		}
 		else if(vertex_count > 3){
@@ -278,7 +278,6 @@ int bsp_copy_node_polygons(bsp_node_t *node, int make_triangles, klist_t(poly) *
 				v_cur = &poly->vertices[i];
 				v_prev = &poly->vertices[i - 1];
 				poly_t *tri = poly_make_triangle(poly->vertices[0], *v_prev, *v_cur);
-				check_mem(tri);
 				*kl_pushp(poly, dst) = tri;
 			}
 		}
@@ -369,7 +368,7 @@ klist_t(poly) *bsp_clip_polygon_array(bsp_node_t *node, poly_t **polygons, size_
 
 	if(node->divider != NULL) {
 		if((n_polys * 4) > STATIC_POLY_BUFFER_SIZE) {
-			check_mem(poly_buffer = malloc((sizeof(poly_t*) * n_polys) * 4));
+			assert_mem(poly_buffer = malloc((sizeof(poly_t*) * n_polys) * 4));
 		}
 		front_array = poly_buffer;
 		back_array = poly_buffer + n_polys;
@@ -394,7 +393,6 @@ klist_t(poly) *bsp_clip_polygon_array(bsp_node_t *node, poly_t **polygons, size_
 		else {
 			for(i = 0; i < n_front; i++) {
 				copy = clone_poly(front_array[i]);
-				check_mem(copy);
 				*kl_pushp(poly, result) = copy;
 			}
 		}
@@ -418,8 +416,7 @@ klist_t(poly) *bsp_clip_polygon_array(bsp_node_t *node, poly_t **polygons, size_
 	else {
 		// If we don't have a divider we just copy out the polygons
 		for(i = 0; i < n_polys; i++) {
-			check_mem(p = clone_poly(polygons[i]));
-			*kl_pushp(poly, result) = p;
+			*kl_pushp(poly, result) = clone_poly(polygons[i]);
 		}
 	}
 
@@ -433,7 +430,6 @@ error:
 klist_t(poly) *bsp_clip_polygons(bsp_node_t *node, klist_t(poly) *polygons, klist_t(poly) *dst) {
 	klist_t(poly) *result = dst != NULL ? dst : kl_init(poly);
 	kliter_t(poly) *iter = NULL;
-	poly_t *p = NULL;
 	int rc = -1;
 
 	poly_t *static_poly_buffer[STATIC_POLY_BUFFER_SIZE];
@@ -450,7 +446,7 @@ klist_t(poly) *bsp_clip_polygons(bsp_node_t *node, klist_t(poly) *polygons, klis
 
 	if(node->divider != NULL) {
 		if((polygons->size * 4) > STATIC_POLY_BUFFER_SIZE) {
-			check_mem(poly_buffer = malloc(sizeof(poly_t*) * polygons->size * 4));
+			assert_mem(poly_buffer = malloc(sizeof(poly_t*) * polygons->size * 4));
 		}
 		front_array = poly_buffer;
 		back_array = poly_buffer + polygons->size;
@@ -465,7 +461,6 @@ klist_t(poly) *bsp_clip_polygons(bsp_node_t *node, klist_t(poly) *polygons, klis
 		}
 
 		int i;
-		poly_t *copy = NULL;
 		// Recur to the front tree, or copy my current front nodes to result.
 		if(node->front) {
 			result = bsp_clip_polygon_array(node->front, front_array, n_front, result);
@@ -473,9 +468,7 @@ klist_t(poly) *bsp_clip_polygons(bsp_node_t *node, klist_t(poly) *polygons, klis
 		}
 		else {
 			for(i = 0; i < n_front; i++) {
-				copy = clone_poly(front_array[i]);
-				check_mem(copy);
-				*kl_pushp(poly, result) = copy;
+				*kl_pushp(poly, result) = clone_poly(front_array[i]);
 			}
 		}
 
@@ -498,8 +491,7 @@ klist_t(poly) *bsp_clip_polygons(bsp_node_t *node, klist_t(poly) *polygons, klis
 	else {
 		// If we don't have a divider we just copy out the polygons
 		for(iter = kl_begin(polygons); iter != kl_end(polygons); iter = kl_next(iter)) {
-			check_mem(p = clone_poly(kl_val(iter)));
-			*kl_pushp(poly, result) = p;
+			*kl_pushp(poly, result) = clone_poly(kl_val(iter));
 		}
 	}
 
@@ -527,8 +519,8 @@ bsp_node_t *bsp_subtract(bsp_node_t *tree_a, bsp_node_t *tree_b) {
 	bsp_node_t *result = NULL;
 	klist_t(poly) *b_polys = NULL;
 
-	check_mem(a = clone_bsp_tree(tree_a));
-	check_mem(b = clone_bsp_tree(tree_b));
+	a = clone_bsp_tree(tree_a);
+	b = clone_bsp_tree(tree_b);
 
 	check(bsp_invert(a)  != NULL, "Failed to invert A");
 	check(bsp_clip(a, b) != NULL, "Failed to clip(A, B)");
@@ -544,7 +536,6 @@ bsp_node_t *bsp_subtract(bsp_node_t *tree_a, bsp_node_t *tree_b) {
 	// TODO: Build a more balanced trees from the polys of
 	//       a instead of cloning a tree with potential gaps.
 	result = clone_bsp_tree(a);
-	check_mem(result);
 
 	if(b_polys != NULL) kl_destroy(poly, b_polys);
 	if(a != NULL) free_bsp_tree(a);
@@ -564,8 +555,8 @@ bsp_node_t *bsp_union(bsp_node_t *tree_a, bsp_node_t *tree_b) {
 	bsp_node_t *result = NULL;
 	klist_t(poly) *b_polys = NULL;
 
-	check_mem(a = clone_bsp_tree(tree_a));
-	check_mem(b = clone_bsp_tree(tree_b));
+	a = clone_bsp_tree(tree_a);
+	b = clone_bsp_tree(tree_b);
 
 	check(bsp_clip(a, b) != NULL, "Failed to clip(A, B)");
 	check(bsp_clip(b, a) != NULL, "Failed clip(B, A)");
@@ -579,7 +570,6 @@ bsp_node_t *bsp_union(bsp_node_t *tree_a, bsp_node_t *tree_b) {
 	// TODO: Build a more balanced trees from the polys of
 	//       a instead of cloning a tree with potential gaps.
 	result = clone_bsp_tree(a);
-	check_mem(result);
 
 	if(b_polys != NULL) kl_destroy(poly, b_polys);
 	if(a != NULL) free_bsp_tree(a);
@@ -599,8 +589,8 @@ bsp_node_t *bsp_intersect(bsp_node_t *tree_a, bsp_node_t *tree_b) {
 	bsp_node_t *result = NULL;
 	klist_t(poly) *b_polys = NULL;
 
-	check_mem(a = clone_bsp_tree(tree_a));
-	check_mem(b = clone_bsp_tree(tree_b));
+	a = clone_bsp_tree(tree_a);
+	b = clone_bsp_tree(tree_b);
 
 	check(bsp_invert(a)  != NULL, "Failed to invert A");
 	check(bsp_clip(b, a) != NULL, "Failed clip(B, A)");
@@ -616,7 +606,6 @@ bsp_node_t *bsp_intersect(bsp_node_t *tree_a, bsp_node_t *tree_b) {
 	// TODO: Build a more balanced trees from the polys of
 	//       a instead of cloning a tree with potential gaps.
 	result = clone_bsp_tree(a);
-	check_mem(result);
 
 	if(b_polys != NULL) kl_destroy(poly, b_polys);
 	if(a != NULL) free_bsp_tree(a);
@@ -642,14 +631,12 @@ int bsp_count_polygons(bsp_node_t *tree) {
 int bsp_mesh_init(void *self, void *data) {
 	bsp_mesh_t *mesh = (bsp_mesh_t*)self;
 	if(data == NULL) {
-		check_mem(mesh->bsp = alloc_bsp_node());
+		mesh->bsp = alloc_bsp_node();
 	}
 	else {
 		mesh->bsp = (bsp_node_t*)data;
 	}
 	return 0;
-error:
-	return -1;
 }
 
 void bsp_mesh_destroy(void *self) {

data/src/cmd_audit.c

@@ -0,0 +1,72 @@
+#include "cmd_audit.h"
+
+#include "stl_mesh.h"
+
+// The finalizer for `cmd_audit`. Cleans up the structures
+// used, and then returns the value passed.
+// Because I fuckign hate spelling this shit out twice, like I
+// do literally everywhere else in this codebase.
+#define __FINISH_CMD_AUDIT(ret) do {				\
+		if(in != NULL) free_mesh(in);				\
+		if(polys != NULL) kl_destroy(poly, polys);	\
+	} while(false);									\
+	return (ret)
+
+// `audit` command entry point.
+// Takes one mesh as the last arg then walks it looking for
+// abnormalities.
+int cmd_audit(int argc, char *argv[]) {
+	char *name = argv[argc - 1];
+	mesh_t *in = NULL;
+	klist_t(poly)* polys = NULL;
+
+	check(argc >= 1, "Too few args");
+	check(in = mesh_read_file(name), "Failed to read [%s]", name);
+	check(in->poly_count(in) > 0, "Mesh does not contain any polygons.");
+
+	// If we load an STL, we need to patch mesh->to_polygons(..) to
+	// a version that bypasses the `poly_push_vertex` checks, otherwise
+	// invalid polygons simply won't be created, and a shitload of warning
+	// spam will appear.
+	const char *stl_type = "STL";
+	if(strncmp(in->type, stl_type, strlen(stl_type)) == 0) {
+		log_info("Patching mesh to produce unsafe polygons.");
+		in->to_polygons = stl_mesh_to_polygons_unsafe;
+	}
+
+
+	log_info("Converting mesh to polygon list for walk.");
+	check(polys = in->to_polygons(in), "Failed to get polygons from mesh.");
+
+	// We should get the same number of polygons as we had in the original structure
+	// after conversion.
+	check(in->poly_count(in) == polys->size,
+		  "Polygon counts differ after polygon list conversion. Mesh(%d) vs List(%zd)", in->poly_count(in), polys->size);
+
+	log_info("Loaded [%d] polys from '%s', beginning walk", in->poly_count(in), name);
+	kliter_t(poly) *iter = kl_begin(polys);
+	poly_t *poly = NULL;
+	size_t count = 0;
+	size_t bad_count = 0;
+	for(; iter != kl_end(polys); iter = kl_next(iter), count++) {
+		poly = kl_val(iter);
+		if(poly == NULL) {
+			log_warn("Failed to get polygon %zd from mesh, it is NULL", count);
+			bad_count++;
+			continue;
+		}
+
+		// If a squard edge length is zero, it's zero.
+		if(poly_min_edge_length2(poly) == 0.0) {
+			bad_count++;
+			log_warn("Poly %zd has an edge of length2 = %f", count, poly_min_edge_length2(poly));
+			poly_print(poly, stderr);
+		}
+	}
+
+	log_info("Checked %zd polygons. %zd had problems.", count, bad_count);
+
+	__FINISH_CMD_AUDIT(bad_count);
+error:
+	__FINISH_CMD_AUDIT(-1);
+}