Merge pull request #49 from sshirokov/mesh-type

Generic Mesh Type

Author: sshirokov

src/bsp.c

@@ -2,6 +2,7 @@
 
 #include "bsp.h"
 #include "dbg.h"
+#include "export.h"
 
 bsp_node_t *alloc_bsp_node(void) {
 	bsp_node_t *node = NULL;
@@ -627,3 +628,49 @@ bsp_node_t *bsp_intersect(bsp_node_t *tree_a, bsp_node_t *tree_b) {
 	if(result != NULL) free_bsp_tree(result);
 	return NULL;
 }
+
+int bsp_count_polygons(bsp_node_t *tree) {
+	if(tree == NULL) return 0;
+
+	return (tree->polygons == NULL) ? 0 : tree->polygons->size +
+		bsp_count_polygons(tree->front) +
+		bsp_count_polygons(tree->back);
+}
+
+// bsp_node_t tree backed mesh methods and mesh prototype
+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());
+	}
+	else {
+		mesh->bsp = (bsp_node_t*)data;
+	}
+	return 0;
+error:
+	return -1;
+}
+
+void bsp_mesh_destroy(void *self) {
+	bsp_mesh_t *mesh = (bsp_mesh_t*)self;
+	free_bsp_tree(mesh->bsp);
+	free(self);
+}
+
+int bsp_mesh_poly_count(void *self) {
+	bsp_mesh_t *mesh = (bsp_mesh_t*)self;
+	return bsp_count_polygons(mesh->bsp);
+}
+
+klist_t(poly)* bsp_mesh_to_polygons(void *self) {
+	bsp_mesh_t *mesh = (bsp_mesh_t*)self;
+	return bsp_to_polygons(mesh->bsp, 0, NULL);
+}
+
+// bsp_mesh_t prototype definition
+mesh_t bsp_mesh_t_Proto = {
+	.init = bsp_mesh_init,
+	.destroy = bsp_mesh_destroy,
+	.poly_count = bsp_mesh_poly_count,
+	.to_polygons = bsp_mesh_to_polygons,
+};

src/bsp.h

@@ -1,5 +1,6 @@
 #include "klist.h"
 #include "poly.h"
+#include "mesh.h"
 
 #ifndef __BSP_H
 #define __BSP_H
@@ -23,6 +24,14 @@ typedef struct s_bsp_node {
 	struct s_bsp_node *back;
 } bsp_node_t;
 
+extern mesh_t bsp_mesh_t_Proto;
+
+typedef struct s_bsp_mesh_t {
+	mesh_t proto;
+	bsp_node_t *bsp;
+} bsp_mesh_t;
+
+
 bsp_node_t *alloc_bsp_node(void);
 bsp_node_t *clone_bsp_tree(bsp_node_t *tree);
 

src/commands.c

@@ -2,7 +2,7 @@
 #include "dbg.h"
 
 #include "commands.h"
-#include "stl.h"
+#include "mesh.h"
 #include "bsp.h"
 #include "export.h"
 
@@ -12,39 +12,39 @@ typedef bsp_node_t* (*bsp_binary_op)(bsp_node_t *, bsp_node_t *);
 // in `path1` and `path1` defined by an operation `op` from` bsp.h
 // Result is freshly allocated, and needs to be freed with `free_bsp_tree()`
 bsp_node_t* bsp_binary_operation(char *path1, char *path2, bsp_binary_op op) {
-	stl_object *file1 = NULL;
+	mesh_t *file1 = NULL;
 	bsp_node_t *bsp1 = NULL;
 
-	stl_object *file2 = NULL;
+	mesh_t *file2 = NULL;
 	bsp_node_t *bsp2 = NULL;
 
 	bsp_node_t *result = NULL;
 
 	// Read 1
-	file1 = stl_read_file(path1, 1);
-	check(file1 != NULL, "Failed to read .stl from '%s'", path1);
-	log_info("Loaded file: %s %d facets", path1, file1->facet_count);
-	bsp1 = stl_to_bsp(file1);
+	file1 = mesh_read_file(path1);
+	check(file1 != NULL, "Failed to read mesh from '%s'", path1);
+	log_info("Loaded file: %s %d facets", path1, file1->poly_count(file1));
+	bsp1 = mesh_to_bsp(file1);
 	check_mem(bsp1);
 
 	// Read 2
-	file2 = stl_read_file(path2, 1);
-	check(file2 != NULL, "Failed to read .stl from '%s'", path2);
-	log_info("Loaded file: %s %d facets", path2, file2->facet_count);
-	bsp2 = stl_to_bsp(file2);
+	file2 = mesh_read_file(path2);
+	check(file2 != NULL, "Failed to read mesh from '%s'", path2);
+	log_info("Loaded file: %s %d facets", path2, file2->poly_count(file2));
+	bsp2 = mesh_to_bsp(file2);
 	check_mem(bsp2);
 
 	// Operate
 	result = op(bsp1, bsp2);
 
-	if(file1 != NULL) stl_free(file1);
-	if(file2 != NULL) stl_free(file2);
+	if(file1 != NULL) file1->destroy(file1);
+	if(file2 != NULL) file2->destroy(file2);
 	if(bsp1 != NULL) free_bsp_tree(bsp1);
 	if(bsp2 != NULL) free_bsp_tree(bsp2);
 	return result;
 error:
-	if(file1 != NULL) stl_free(file1);
-	if(file2 != NULL) stl_free(file2);
+	if(file1 != NULL) file1->destroy(file1);
+	if(file2 != NULL) file2->destroy(file2);
 	if(bsp1 != NULL) free_bsp_tree(bsp1);
 	if(bsp2 != NULL) free_bsp_tree(bsp2);
 	if(result != NULL) free_bsp_tree(result);
@@ -61,23 +61,23 @@ bsp_node_t* bsp_binary_operation(char *path1, char *path2, bsp_binary_op op) {
 #define MAKE_CSG_COMMAND(name)                                                        \
 int cmd_##name(int argc, char **argv) {                                               \
 	bsp_node_t *result = NULL;                                                        \
-	stl_object *out = NULL;                                                           \
+	mesh_t *out = NULL;                                                               \
 	char *out_path = "./out.stl";                                                     \
                                                                                       \
 	check(argc >= 2, "At least two input files required.");                           \
 	if(argc > 2) out_path = argv[2];                                                  \
                                                                                       \
-	result = bsp_binary_operation(argv[0], argv[1], bsp_##name);                   \
-	out = bsp_to_stl(result);                                                         \
+	result = bsp_binary_operation(argv[0], argv[1], bsp_##name);                      \
+	check(result != NULL, "Binary operation" #name "failed.");                        \
+	out = NEW(bsp_mesh_t, "BSP", result);                                             \
     log_info("Writing output to %s", out_path);                                       \
-	check(stl_write_file(out, out_path) == 0, "Failed to write STL to %s", out_path); \
+	check(out->write(out, out_path) == 0, "Failed to write STL to %s", out_path);     \
                                                                                       \
-	if(result != NULL) free_bsp_tree(result);                                         \
-	if(out != NULL) stl_free(out);                                                    \
+	out->destroy(out);                               				                  \
 	return 0;                                                                         \
 error:                                                                                \
-	if(result != NULL) free_bsp_tree(result);                                         \
-	if(out != NULL) stl_free(out);                                                    \
+	if(out != NULL) out->destroy(out);                                                \
+	else if(result != NULL) free_bsp_tree(result);                                    \
 	return -1;                                                                        \
 }
 

src/export.c

@@ -65,3 +65,56 @@ bsp_node_t *stl_to_bsp(stl_object *stl) {
 	}
 	return NULL;
 }
+
+bsp_node_t *mesh_to_bsp(mesh_t *mesh) {
+	bsp_node_t *tree = NULL;
+	klist_t(poly) *polys = NULL;
+
+	check((polys = mesh->to_polygons(mesh)) != NULL,
+		  "Failed to convert mesh %p to polgon list", mesh);
+
+	check((tree = bsp_build(NULL, polys, 1)) != NULL,
+		  "Failed to build BSP tree from %zd polys", polys->size);
+
+	kl_destroy(poly, polys);
+	return tree;
+error:
+	if(tree != NULL) free_bsp_tree(tree);
+	if(polys != NULL) kl_destroy(poly, polys);
+	return NULL;
+}
+
+klist_t(poly)* polys_to_tris(klist_t(poly) *dst, klist_t(poly) *src) {
+	klist_t(poly) *result = dst;
+	if(result == NULL) result = kl_init(poly);
+
+	kliter_t(poly) *iter = NULL;
+	for(iter = kl_begin(src); iter != kl_end(src); iter = kl_next(iter)) {
+		poly_t *poly = kl_val(iter);
+		int vertex_count = poly_vertex_count(poly);
+
+		// Copy triangles, split higher-vertex polygons into triangle fans.
+		if(vertex_count == 3) {
+			poly_t *copy = clone_poly(poly);
+			check_mem(copy);
+			*kl_pushp(poly, result) = copy;
+		}
+		else if(vertex_count > 3) {
+			float3 *v_cur, *v_prev;
+			for(int i = 2; i < vertex_count; i++) {
+				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, result) = tri;
+			}
+		} else {
+			sentinel("polygon(%p) has less than three(%d) vertices.", poly, poly_vertex_count(poly));
+		}
+	}
+
+	return result;
+error:
+	if(result != dst) if(result != NULL) kl_destroy(poly, result);
+	return NULL;
+}

src/export.h

@@ -5,12 +5,15 @@
 #include "stl.h"
 #include "poly.h"
 #include "bsp.h"
+#include "mesh.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);
+bsp_node_t *mesh_to_bsp(mesh_t *mesh);
+klist_t(poly)* polys_to_tris(klist_t(poly)* dst, klist_t(poly)* src);
 
 #endif

src/mesh.c

@@ -0,0 +1,78 @@
+#include "dbg.h"
+
+#include "stl.h"
+#include "export.h"
+#include "mesh.h"
+#include "reader.h"
+
+int mesh_init(void *self, void *unused) {
+	if(self == NULL) return -1;
+	return 0;
+}
+
+char* mesh_describe(void *self) {
+	mesh_t *mesh = (mesh_t*)self;
+	return mesh->type;
+}
+
+void free_mesh(void *self) {
+	if(self != NULL) free(self);
+	return;
+}
+
+int _default_poly_count(void *self) {
+	return 0;
+}
+
+klist_t(poly)* _default_to_polygons(void *self) {
+	return NULL;
+}
+
+int _default_write(void *self, char *path) {
+	int rc = -1;
+	mesh_t *mesh = (mesh_t*)self;
+	stl_object *stl = NULL;
+	klist_t(poly) *polys = mesh->to_polygons(mesh);
+	klist_t(poly) *triangles = NULL;
+	check(polys != NULL, "Failed to get polygons from mesh %p", mesh);
+
+	triangles = polys_to_tris(NULL, polys);
+	check(triangles != NULL, "Failed to convert polygons to trianges.");
+
+	// The default output format is STL
+	stl = stl_from_polys(triangles);
+	check(stl != NULL, "Failed to generate STL object for write.");
+	rc = stl_write_file(stl, path);
+
+	if(stl != NULL) stl_free(stl);
+	if(polys != NULL) kl_destroy(poly, polys);
+	if(triangles != NULL) kl_destroy(poly, triangles);
+	return rc;
+error:
+	if(stl != NULL) stl_free(stl);
+	if(polys != NULL) kl_destroy(poly, polys);
+	if(triangles != NULL) kl_destroy(poly, triangles);
+	return -1;
+}
+
+void *alloc_mesh(size_t size, mesh_t proto, char type[4], void *data) {
+	if(proto.init == NULL) proto.init = mesh_init;
+	if(proto.destroy == NULL) proto.destroy = free_mesh;
+	if(proto.poly_count == NULL) proto.poly_count = _default_poly_count;
+	if(proto.to_polygons == NULL) proto.to_polygons = _default_to_polygons;
+	if(proto.write == NULL) proto.write = _default_write;
+
+	mesh_t *m = calloc(1, size);
+	*m = proto;
+	strncpy(m->type, type, 3);
+
+	check(m->init(m, data) != -1, "Failed to initialize %p(%s, %p)", m, m->type, data);
+	return m;
+error:
+	if(m != NULL) m->destroy(m);
+	return NULL;
+}
+
+mesh_t *mesh_read_file(char *path) {
+	return reader_load(path);
+}

src/mesh.h

@@ -0,0 +1,31 @@
+#include <stdlib.h>
+
+#include "poly.h"
+
+#ifndef __MESH_H
+#define __MESH_H
+
+typedef struct s_mesh_t {
+	char type[4];
+
+	int (*init)(void *self, void *data);
+	void (*destroy)(void *self);
+
+	int (*poly_count)(void *self);
+	klist_t(poly)* (*to_polygons)(void *self);
+
+	int (*write)(void *self, char *path);
+} mesh_t;
+
+int mesh_init(void *self, void *data);
+void free_mesh(void *self);
+
+void *alloc_mesh(size_t size, mesh_t proto, char type[4], void *data);
+
+#define NEW(T, N, D) alloc_mesh(sizeof(T), T##_Proto, N, D)
+#define _(M) proto.M
+
+// Load wrapper to read better
+mesh_t *mesh_read_file(char *path);
+
+#endif