csg 0.0.0

data/src/bsp.h

@@ -0,0 +1,40 @@
+#include "klist.h"
+#include "poly.h"
+
+#ifndef __BSP_H
+#define __BSP_H
+
+typedef struct s_bsp_node {
+	klist_t(poly) *polygons;
+	poly_t *divider;
+
+	struct s_bsp_node *front;
+	struct s_bsp_node *back;
+} bsp_node_t;
+
+bsp_node_t *alloc_bsp_node(void);
+bsp_node_t *clone_bsp_tree(bsp_node_t *tree);
+
+void free_bsp_node(bsp_node_t *node);
+void free_bsp_tree(bsp_node_t *tree);
+
+int bsp_subdivide(poly_t *divider, poly_t *poly,
+				  poly_t **coplanar_front, int *n_cp_front,
+				  poly_t **coplanar_back,  int *n_cp_back,
+				  poly_t **front,          int *n_front,
+				  poly_t **back,           int *n_back);
+
+bsp_node_t *bsp_build(bsp_node_t *node, klist_t(poly) *polygons, int copy);
+bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys);
+klist_t(poly) *bsp_to_polygons(bsp_node_t *tree,  int make_triangles, klist_t(poly) *dst);
+
+bsp_node_t *bsp_invert(bsp_node_t *tree);
+bsp_node_t *bsp_clip(bsp_node_t *us, bsp_node_t *them);
+klist_t(poly) *bsp_clip_polygons(bsp_node_t *node, klist_t(poly) *polygons, klist_t(poly) *dst);
+
+// CSG Operations
+bsp_node_t *bsp_union(bsp_node_t *a, bsp_node_t *b);
+bsp_node_t *bsp_subtract(bsp_node_t *a, bsp_node_t *b);
+bsp_node_t *bsp_intersect(bsp_node_t *a, bsp_node_t *b);
+
+#endif

data/src/dbg.c

@@ -0,0 +1,48 @@
+/**
+ *
+ * Copyright (c) 2010, Zed A. Shaw and Mongrel2 Project Contributors.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ * 
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ * 
+ *     * Neither the name of the Mongrel2 Project, Zed A. Shaw, nor the names
+ *       of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written
+ *       permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "dbg.h"
+
+FILE *LOG_FILE = NULL;
+
+void dbg_set_log(FILE *log_file)
+{
+	LOG_FILE = log_file;
+}
+
+
+FILE *dbg_get_log()
+{
+	return LOG_FILE != NULL ? LOG_FILE : stderr;
+}

data/src/dbg.h

@@ -0,0 +1,76 @@
+/**
+ *
+ * Copyright (c) 2010, Zed A. Shaw and Mongrel2 Project Contributors.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *
+ *     * Neither the name of the Mongrel2 Project, Zed A. Shaw, nor the names
+ *       of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written
+ *       permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __dbg_h__
+#define __dbg_h__
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+void dbg_set_log(FILE *log_file);
+FILE *dbg_get_log();
+
+#ifdef NDEBUG
+#define debug(M, ...)
+#else
+#define debug(M, ...) fprintf(dbg_get_log(), "DEBUG %s:%d: " M "\n", __FILE__, __LINE__, ##__VA_ARGS__)
+#endif
+
+
+// do not try to be smart and make this go away on NDEBUG, the _debug
+// here means that it just doesn't print a message, it still does the
+// check.  MKAY?
+#define check_debug(A, M, ...) if(!(A)) { debug(M, ##__VA_ARGS__); errno=0; goto error; }
+
+#define clean_errno() (errno == 0 ? "None" : strerror(errno))
+
+#ifdef NO_LINENOS
+// versions that don't feature line numbers
+#define log_err(M, ...) fprintf(dbg_get_log(), "[ERROR] (errno: %s) " M "\n", clean_errno(), ##__VA_ARGS__)
+#define log_warn(M, ...) fprintf(dbg_get_log(), "[WARN] (errno: %s) " M "\n", clean_errno(), ##__VA_ARGS__)
+#define log_info(M, ...) fprintf(dbg_get_log(), "[INFO] " M "\n", ##__VA_ARGS__)
+#else
+#define log_err(M, ...) fprintf(dbg_get_log(), "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, clean_errno(), ##__VA_ARGS__)
+#define log_warn(M, ...) fprintf(dbg_get_log(), "[WARN] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, clean_errno(), ##__VA_ARGS__)
+#define log_info(M, ...) fprintf(dbg_get_log(), "[INFO] (%s:%d) " M "\n", __FILE__, __LINE__, ##__VA_ARGS__)
+#endif
+
+#define check(A, M, ...) if(!(A)) { log_err(M, ##__VA_ARGS__); errno=0; goto error; }
+
+#define sentinel(M, ...)  { log_err(M, ##__VA_ARGS__); errno=0; goto error; }
+
+#define check_mem(A) check((A), "Out of memory.")
+
+#endif

data/src/export.c

@@ -0,0 +1,68 @@
+#include "export.h"
+
+stl_object *stl_from_polys(klist_t(poly) *polygons) {
+	stl_object *stl = stl_alloc(NULL, polygons->size);
+	check_mem(stl);
+
+	kliter_t(poly) *iter = kl_begin(polygons);
+	stl_facet *facet = stl->facets;
+	poly_t *poly = NULL;
+	for(; iter != kl_end(polygons); iter = kl_next(iter), facet++) {
+		poly = kl_val(iter);
+		check(poly_vertex_count(poly) == 3, "Polygon is not a triangle.");
+		memcpy(facet->normal, poly->normal, sizeof(float3));
+		memcpy(facet->vertices, poly->vertices, sizeof(facet->vertices));
+	}
+
+	return stl;
+error:
+	if(stl) stl_free(stl);
+	return NULL;
+}
+
+stl_object *bsp_to_stl(bsp_node_t *tree) {
+	stl_object *stl = NULL;
+	klist_t(poly) *polys = NULL;
+
+	polys = bsp_to_polygons(tree, 1, NULL);
+	check(polys != NULL, "Failed to generate polygons from bsp_node_t(%p)", tree);
+	check(polys->size > 0, "No polygons returned from tree(%p)", tree);
+
+	stl = stl_from_polys(polys);
+	check(stl != NULL, "Failed to build stl from %zd polygons", polys->size);
+	strcpy(stl->header, "[csgtool BSP output]");
+
+	kl_destroy(poly, polys);
+	return stl;
+error:
+	if(polys) kl_destroy(poly, polys);
+	if(stl) stl_free(stl);
+	return NULL;
+}
+
+bsp_node_t *stl_to_bsp(stl_object *stl) {
+	bsp_node_t *tree = NULL;
+	klist_t(poly) *polys = kl_init(poly);
+	poly_t *poly = NULL;
+
+	for(int i = 0; i < stl->facet_count; i++) {
+		poly = poly_make_triangle(stl->facets[i].vertices[0],
+								  stl->facets[i].vertices[1],
+								  stl->facets[i].vertices[2]);
+		check_mem(polys);
+		*kl_pushp(poly, polys) = poly;
+	}
+	check(polys->size == stl->facet_count, "Wrong number of faces generated.");
+
+	tree = bsp_build(NULL, polys, 1);
+	check_mem(tree);
+
+	kl_destroy(poly, polys);
+	return tree;
+error:
+	if(polys != NULL) kl_destroy(poly, polys);
+	if(tree != NULL) {
+		free_bsp_tree(tree);
+	}
+	return NULL;
+}

data/src/export.h

@@ -0,0 +1,16 @@
+#include <string.h>
+
+#include "dbg.h"
+
+#include "stl.h"
+#include "poly.h"
+#include "bsp.h"
+
+#ifndef __EXPORT_H
+#define __EXPORT_H
+
+stl_object *stl_from_polys(klist_t(poly) *polygons);
+stl_object *bsp_to_stl(bsp_node_t *tree);
+bsp_node_t *stl_to_bsp(stl_object *stl);
+
+#endif

data/src/klist.h

@@ -0,0 +1,121 @@
+/* The MIT License
+
+   Copyright (c) 2008-2009, by Attractive Chaos <attractor@live.co.uk>
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+#ifndef _AC_KLIST_H
+#define _AC_KLIST_H
+
+#include <stdlib.h>
+
+#define KMEMPOOL_INIT(name, kmptype_t, kmpfree_f)						\
+	typedef struct {													\
+		size_t cnt, n, max;												\
+		kmptype_t **buf;												\
+	} kmp_##name##_t;													\
+	static inline kmp_##name##_t *kmp_init_##name() {					\
+		return calloc(1, sizeof(kmp_##name##_t));						\
+	}																	\
+	static inline void kmp_destroy_##name(kmp_##name##_t *mp) {			\
+		size_t k;														\
+		for (k = 0; k < mp->n; ++k) {									\
+			kmpfree_f(mp->buf[k]); free(mp->buf[k]);					\
+		}																\
+		free(mp->buf); free(mp);										\
+	}																	\
+	static inline kmptype_t *kmp_alloc_##name(kmp_##name##_t *mp) {		\
+		++mp->cnt;														\
+		if (mp->n == 0) return calloc(1, sizeof(kmptype_t));			\
+		return mp->buf[--mp->n];										\
+	}																	\
+	static inline void kmp_free_##name(kmp_##name##_t *mp, kmptype_t *p) { \
+		--mp->cnt;														\
+		if (mp->n == mp->max) {											\
+			mp->max = mp->max? mp->max<<1 : 16;							\
+			mp->buf = realloc(mp->buf, sizeof(void*) * mp->max);		\
+		}																\
+		mp->buf[mp->n++] = p;											\
+	}
+
+#define kmempool_t(name) kmp_##name##_t
+#define kmp_init(name) kmp_init_##name()
+#define kmp_destroy(name, mp) kmp_destroy_##name(mp)
+#define kmp_alloc(name, mp) kmp_alloc_##name(mp)
+#define kmp_free(name, mp, p) kmp_free_##name(mp, p)
+
+#define KLIST_INIT(name, kltype_t, kmpfree_t)							\
+	struct __kl1_##name {												\
+		kltype_t data;													\
+		struct __kl1_##name *next;										\
+	};																	\
+	typedef struct __kl1_##name kl1_##name;								\
+	KMEMPOOL_INIT(name, kl1_##name, kmpfree_t)							\
+	typedef struct {													\
+		kl1_##name *head, *tail;										\
+		kmp_##name##_t *mp;												\
+		size_t size;													\
+	} kl_##name##_t;													\
+	static inline kl_##name##_t *kl_init_##name() {						\
+		kl_##name##_t *kl = calloc(1, sizeof(kl_##name##_t));			\
+		kl->mp = kmp_init(name);										\
+		kl->head = kl->tail = kmp_alloc(name, kl->mp);					\
+		kl->head->next = 0;												\
+		return kl;														\
+	}																	\
+	static inline void kl_destroy_##name(kl_##name##_t *kl) {			\
+		kl1_##name *p;													\
+		for (p = kl->head; p != kl->tail; p = p->next)					\
+			kmp_free(name, kl->mp, p);									\
+		kmp_free(name, kl->mp, p);										\
+		kmp_destroy(name, kl->mp);										\
+		free(kl);														\
+	}																	\
+	static inline kltype_t *kl_pushp_##name(kl_##name##_t *kl) {		\
+		kl1_##name *q, *p = kmp_alloc(name, kl->mp);					\
+		q = kl->tail; p->next = 0; kl->tail->next = p; kl->tail = p;	\
+		++kl->size;														\
+		return &q->data;												\
+	}																	\
+	static inline int kl_shift_##name(kl_##name##_t *kl, kltype_t *d) { \
+		kl1_##name *p;													\
+		if (kl->head->next == 0) return -1;								\
+		--kl->size;														\
+		p = kl->head; kl->head = kl->head->next;						\
+		if (d) *d = p->data;											\
+		kmp_free(name, kl->mp, p);										\
+		return 0;														\
+	}
+
+#define kliter_t(name) kl1_##name
+#define klist_t(name) kl_##name##_t
+#define kl_val(iter) ((iter)->data)
+#define kl_next(iter) ((iter)->next)
+#define kl_begin(kl) ((kl)->head)
+#define kl_end(kl) ((kl)->tail)
+
+#define kl_init(name) kl_init_##name()
+#define kl_destroy(name, kl) kl_destroy_##name(kl)
+#define kl_pushp(name, kl) kl_pushp_##name(kl)
+#define kl_shift(name, kl, d) kl_shift_##name(kl, d)
+
+#endif

data/src/poly.c

@@ -0,0 +1,206 @@
+#include <assert.h>
+
+#include "poly.h"
+
+poly_t *alloc_poly(void) {
+	poly_t *poly = malloc(sizeof(poly_t));
+	check_mem(poly);
+	poly_init(poly);
+	return poly;
+error:
+	return NULL;
+}
+
+void free_poly(poly_t *p, int free_self) {
+	if(p == NULL) return;
+	if(free_self) free(p);
+}
+
+poly_t *poly_init(poly_t *poly) {
+	poly->vertex_count = 0;
+	return poly;
+}
+
+poly_t *clone_poly(poly_t *poly) {
+	poly_t *copy = NULL;
+	check_mem(copy = alloc_poly());
+	memcpy(copy, poly, sizeof(poly_t));
+	return copy;
+error:
+	return NULL;
+}
+
+int poly_update(poly_t *poly) {
+	if(poly_vertex_count(poly) < 3) return -1;
+
+	float3 *a = &poly->vertices[0];
+	float3 *b = &poly->vertices[1];
+	float3 *c = &poly->vertices[2];
+
+	float3 b_a;
+	float3 c_a;
+	f3_sub(&b_a, *b, *a);
+	f3_sub(&c_a, *c, *a);
+
+	f3_cross(&poly->normal, b_a, c_a);
+	f3_normalize(&poly->normal);
+
+	poly->w = f3_dot(poly->normal, *a);
+	return 0;
+}
+
+int poly_vertex_count(poly_t *poly) {
+	return poly->vertex_count;
+}
+
+// Add a vertex to the end of the polygon vertex list
+int poly_push_vertex(poly_t *poly, float3 v) {
+	// TODO: Don't assert, grow
+	assert(poly->vertex_count < POLY_MAX_VERTS);
+
+	// Dat assignment copy
+	poly->vertices[poly->vertex_count][0] = v[0];
+	poly->vertices[poly->vertex_count][1] = v[1];
+	poly->vertices[poly->vertex_count][2] = v[2];
+
+	// Update the poly if we can
+	if(++poly->vertex_count > 2) {
+		check(poly_update(poly) == 0, "Failed to update polygon during poly_push_vertex(%p)", poly);
+	}
+
+	return 0;
+error:
+	return -1;
+}
+
+int poly_classify_vertex(poly_t *poly, float3 v) {
+	float side = f3_dot(poly->normal, v) - poly->w;
+	if(side < -EPSILON) return BACK;
+	if(side > EPSILON) return FRONT;
+	return COPLANAR;
+}
+
+int poly_classify_poly(poly_t *this, poly_t *other) {
+	int front, back;
+	int count = poly_vertex_count(other);
+
+	front = 0;
+	back = 0;
+
+	for(int i = 0; i < count; i++) {
+		switch(poly_classify_vertex(this, other->vertices[i])) {
+		case FRONT:
+			front += 1;
+			break;
+		case BACK:
+			back += 1;
+			break;
+		}
+	}
+	if(front > 0 && back == 0)  return FRONT;
+	if(back > 0 && front == 0)  return BACK;
+	if(front == 0 && back == 0) return COPLANAR;
+	return SPANNING;
+}
+
+int poly_split(poly_t *divider, poly_t *poly, poly_t **front, poly_t **back) {
+	// Create polygons if we were not passed allocated ones
+	if(*front == NULL) {
+		*front = alloc_poly();
+	}
+	if(*back == NULL) {
+		*back = alloc_poly();
+	}
+
+	// Current and next vertex
+	float3 v_cur = FLOAT3_INIT;
+	float3 v_next = FLOAT3_INIT;
+	// Classifications of the above
+	int c_cur, c_next;
+	// Loop indexes
+	int i, j;
+	int count = poly_vertex_count(poly);
+	for(i = 0; i < count; i++) {
+		j = (i + 1) % count;
+		for(int k = 0; k < 3; k++) {
+			v_cur[k]  = poly->vertices[i][k];
+			v_next[k] = poly->vertices[j][k];
+		}
+
+		// Classify the first and next vertex
+		c_cur  = poly_classify_vertex(divider, v_cur);
+		c_next = poly_classify_vertex(divider, v_next);
+
+		if(c_cur != BACK)  {
+			poly_push_vertex(*front, v_cur);
+		}
+		if(c_cur != FRONT) {
+			poly_push_vertex(*back, v_cur);
+		}
+
+		// Interpolate a midpoint if we found a spanning edge
+		if((c_cur | c_next) == SPANNING) {
+			float3 diff = FLOAT3_INIT;
+			f3_sub(&diff, v_next, v_cur);
+
+			float t = divider->w;
+			t = t - f3_dot(divider->normal, v_cur);
+			t = t / f3_dot(divider->normal, diff);
+
+			float3 mid_f = {v_cur[0], v_cur[1], v_cur[2]};
+			f3_interpolate(&mid_f, v_cur, v_next, t);
+
+			check(poly_push_vertex(*front, mid_f) == 0,
+				  "Failed to push midpoint to front poly(%p)", front);
+			check(poly_push_vertex(*back, mid_f) == 0,
+				  "Failed to push midpoint to back poly(%p):", back);
+		}
+	}
+
+	return 0;
+error:
+	return -1;
+}
+
+poly_t *poly_make_triangle(float3 a, float3 b, float3 c) {
+	poly_t *p = NULL;
+	check_mem(p = alloc_poly());
+
+	check(poly_push_vertex(p, a) == 0,
+		  "Failed to add vertex a to poly(%p): (%f, %f, %f)", p, FLOAT3_FORMAT(a));
+	check(poly_push_vertex(p, b) == 0,
+		  "Failed to add vertex b to poly(%p): (%f, %f, %f)", p, FLOAT3_FORMAT(b));
+	check(poly_push_vertex(p, c) == 0,
+		  "Failed to add vertex c to poly(%p): (%f, %f, %f)", p, FLOAT3_FORMAT(c));
+
+	return p;
+error:
+	if(p) free_poly(p, 1);
+	return NULL;
+}
+
+poly_t *poly_invert(poly_t *poly) {
+	f3_scale(&poly->normal, -1.0);
+	poly->w *= -1.0;
+
+	// We walk the list from the back to the midway point
+	// and flip the opposite ends to reverse the poly list.
+	int last = poly_vertex_count(poly) - 1;
+	int first = 0;
+	float3 temp = FLOAT3_INIT;
+	for(; first < last; first++, last--) {
+		temp[0] = poly->vertices[last][0];
+		temp[1] = poly->vertices[last][1];
+		temp[2] = poly->vertices[last][2];
+
+		poly->vertices[last][0] = poly->vertices[first][0];
+		poly->vertices[last][1] = poly->vertices[first][1];
+		poly->vertices[last][2] = poly->vertices[first][2];
+
+		poly->vertices[first][0] = temp[0];
+		poly->vertices[first][1] = temp[1];
+		poly->vertices[first][2] = temp[2];
+	}
+
+	return poly;
+}