csg 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd64c54271e04c5a8558bf143fea9a294fe50232
-  data.tar.gz: 034f2b630435697ee0dfa0dd3dec15e9bf72dd13
+  metadata.gz: cab611b90101912c713c832df26091680edf4d3d
+  data.tar.gz: 52de356c4a37b4032ae815bef964731eb8872c07
 SHA512:
-  metadata.gz: 933e067a95518c104a03b56828d095b564837ad6b76b0454160c6327865ff6730fd870d02bfabf0c9da58d9a22456646a5dd26ba3e604cd7a86990ecd7c14fc5
-  data.tar.gz: 26b431c5484349f9d89f21fbedcc8ca43be066366e33d4608ac9875c9775e618011b828a05bd8faa5553f9d51faf368d0e6a6b0f62b511a9570319947cf125a0
+  metadata.gz: 11b9ffd8267d6cfa66c30f02ac8dc62db7debdc1aac0ebe91401d317b682cde589ac075ae5b5fc2e635904d6b36bfe2a677b0876597035b8d4eae22cf641a556
+  data.tar.gz: 56e441bbe90cc44e96d551dcd1224149f276164389ab4ec277cfa32998d8416901cfd8c6c384a28deb5d6d3e100f9a821462663e6bb644b73b96462158e90365

data/lib/csg.rb

@@ -9,20 +9,26 @@ module CSG
     end
     ffi_lib ['csg'] + candidates
 
-    class STLObject < FFI::ManagedStruct
-      layout :header, [:uint8, 80],
-             :facet_count, :uint32,
-             :stl_facet, :pointer
+    class Mesh < FFI::ManagedStruct
+      # WARNING: You should probably never call `:destroy`, because it's a managed
+      #          struct, and should get destroyed by Ruby using this very method
+      #          inside of `Mesh.release`
+      layout :type, [:uint8, 4],
+             :init,        callback([:pointer, :pointer], :int),
+             :destroy,     callback([:pointer], :void),
+             :poly_count,  callback([:pointer], :int),
+             :to_polygons, callback([:pointer], :pointer),
+             :to_bsp,      callback([:pointer], :pointer),
+             :write,       callback([:pointer, :string, :string], :int)
 
       def self.release(ptr)
-        CSG::Native.stl_free ptr
-      end
-
-      def write_file(path)
-        CSG::Native.stl_write_file self, path
+        CSG::Native.destroy_mesh ptr
       end
     end
 
+    attach_function :destroy_mesh, [:pointer], :void
+    attach_function :mesh_read_file, [:string], Mesh
+
     class BSPNode < FFI::ManagedStruct
       layout :polygons, :pointer,
              :divider, :pointer,
@@ -34,50 +40,71 @@ module CSG
       end
     end
 
-    attach_function :stl_read_file, [:string, :bool], :pointer
-    attach_function :stl_write_file, [:pointer, :string], :int
-
-    attach_function :stl_free, [:pointer], :void
     attach_function :free_bsp_tree, [:pointer], :void
-
-    attach_function :stl_to_bsp, [:pointer], :pointer
-    attach_function :bsp_to_stl, [:pointer], :pointer
+    attach_function :mesh_to_bsp, [Mesh], BSPNode
 
     attach_function :bsp_union, [:pointer, :pointer], :pointer
     attach_function :bsp_subtract, [:pointer, :pointer], :pointer
     attach_function :bsp_intersect, [:pointer, :pointer], :pointer
+
+    attach_function :bsp_to_mesh, [:pointer, :int], :pointer
   end
+end
 
+module CSG
   class Solid
-    attr_reader :tree
+    attr_reader :mesh
 
     def initialize(opts)
       if opts[:file]
         load_from_file opts[:file]
-      elsif opts[:tree]
-        @tree = opts[:tree]
+      elsif opts[:mesh]
+        @mesh = opts[:mesh]
       end
-      raise ArgumentError.new "Failed to load tree with: #{opts.inspect}" unless @tree
+      raise ArgumentError.new "Failed to load mesh with: #{opts.inspect}" unless @mesh
     end
 
     def load_from_file(path)
       File.stat(path) # Stat before load to raise a sane "Does not exist" error
-      stl = CSG::Native::STLObject.new CSG::Native.stl_read_file(path, false)
-      @tree = CSG::Native::BSPNode.new CSG::Native.stl_to_bsp(stl)
+      mesh_ptr = CSG::Native::mesh_read_file path
+      if not mesh_ptr.null?
+          @mesh = CSG::Native::Mesh.new mesh_ptr
+      else
+        raise Exception.new("Failed to produce Mesh from #{path}")
+      end
     end
 
-    def to_stl
-      ptr = CSG::Native.bsp_to_stl tree
-      CSG::Native::STLObject.new(ptr)
+    def write(path)
+      rc = mesh[:write].call(mesh, path, "STL")
+      raise Exception.new("Failed to write to '#{path}") if rc != 0
     end
 
-    # Build the CSG methods with ManagedStruct wrappers
     [:intersect, :subtract, :union].each do |name|
       define_method name do |solid|
-        ptr = CSG::Native.send "bsp_#{name}", tree, solid.tree
-        tree = CSG::Native::BSPNode.new(ptr)
-        CSG::Solid.new :tree => tree
+        # 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 Exception.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?
+        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?
+
+        # 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?
+        CSG::Solid.new :mesh => CSG::Native::Mesh.new(result_mesh_ptr)
       end
     end
+
   end
 end

data/src/bsp.c

@@ -2,6 +2,8 @@
 
 #include "bsp.h"
 #include "dbg.h"
+#include "export.h"
+#include "bsp_mesh.h"
 
 bsp_node_t *alloc_bsp_node(void) {
 	bsp_node_t *node = NULL;
@@ -627,3 +629,49 @@ error:
 	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,
+};

data/src/bsp_mesh.h

@@ -0,0 +1,12 @@
+
+#ifndef __BSP_MESH_H
+#define __BSP_MESH_H
+
+extern mesh_t bsp_mesh_t_Proto;
+
+typedef struct s_bsp_mesh_t {
+	mesh_t proto;
+	bsp_node_t *bsp;
+} bsp_mesh_t;
+
+#endif

data/src/commands.c

@@ -2,8 +2,9 @@
 #include "dbg.h"
 
 #include "commands.h"
-#include "stl.h"
+#include "mesh.h"
 #include "bsp.h"
+#include "bsp_mesh.h"
 #include "export.h"
 
 typedef bsp_node_t* (*bsp_binary_op)(bsp_node_t *, bsp_node_t *);
@@ -12,39 +13,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 +62,23 @@ error:
 #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, "STL") == 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;                                                                        \
 }
 

data/src/export.c

@@ -1,4 +1,5 @@
 #include "export.h"
+#include "bsp_mesh.h"
 
 stl_object *stl_from_polys(klist_t(poly) *polygons) {
 	stl_object *stl = stl_alloc(NULL, polygons->size);
@@ -65,3 +66,48 @@ error:
 	}
 	return NULL;
 }
+
+bsp_node_t *mesh_to_bsp(mesh_t *mesh) {
+	return mesh->to_bsp(mesh);
+}
+
+mesh_t* bsp_to_mesh(bsp_node_t* bsp, int copy) {
+	bsp_node_t* input = (copy == 0) ? bsp : clone_bsp_tree(bsp);
+
+	return NEW(bsp_mesh_t, "BSP", input);
+}
+
+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;
+}

data/src/export.h

@@ -5,6 +5,7 @@
 #include "stl.h"
 #include "poly.h"
 #include "bsp.h"
+#include "mesh.h"
 
 #ifndef __EXPORT_H
 #define __EXPORT_H
@@ -12,5 +13,8 @@
 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);
+mesh_t* bsp_to_mesh(bsp_node_t *tree, int copy);
+klist_t(poly)* polys_to_tris(klist_t(poly)* dst, klist_t(poly)* src);
 
 #endif

data/src/mesh.c

@@ -0,0 +1,113 @@
+#include "dbg.h"
+
+#include "stl.h"
+#include "export.h"
+#include "mesh.h"
+#include "reader.h"
+#include "bsp.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;
+}
+
+void destroy_mesh(void *self) {
+	mesh_t *mesh = (mesh_t*)self;
+	if(mesh->destroy != NULL) {
+		mesh->destroy(mesh);
+	}
+	else {
+		free_mesh(mesh);
+	}
+}
+
+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, char type[4]) {
+	int rc = -1;
+	mesh_t *mesh = (mesh_t*)self;
+	stl_object *stl = NULL;
+	klist_t(poly) *polys = NULL;
+	klist_t(poly) *triangles = NULL;
+
+	// This is the only format we speak right now
+	if(strncmp(type, "STL", 3) != 0) goto error;
+
+	check((polys = mesh->to_polygons(mesh)) != 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;
+}
+
+bsp_node_t* _default_to_bsp(void *self) {
+	mesh_t *mesh = (mesh_t*)self;
+	bsp_node_t *bsp = NULL;
+	klist_t(poly)* polys = NULL;
+
+	check((polys = mesh->to_polygons(mesh)) != NULL,
+		  "Failed to convert mesh %p to poly list", mesh);
+
+	check((bsp = bsp_build(NULL, polys, 1)) != NULL,
+		  "Failed to build BSP tree from %zd polygons of %p", polys->size, self);
+
+	kl_destroy(poly, polys);
+	return bsp;
+error:
+	if(polys != NULL) kl_destroy(poly, polys);
+	if(bsp != NULL) free_bsp_tree(bsp);
+	return NULL;
+}
+
+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;
+	if(proto.to_bsp == NULL) proto.to_bsp = _default_to_bsp;
+
+	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);
+}

data/src/mesh.h

@@ -0,0 +1,34 @@
+#include <stdlib.h>
+
+#include "poly.h"
+#include "bsp.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);
+	bsp_node_t* (*to_bsp)(void *self);
+
+	int (*write)(void *self, char *path, char type[4]);
+} mesh_t;
+
+int mesh_init(void *self, void *data);
+void free_mesh(void *self);
+void destroy_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

data/src/reader.c

@@ -0,0 +1,49 @@
+#include "stl.h"
+#include "reader.h"
+
+// API
+mesh_t* reader_load(char *path) {
+	mesh_t *mesh = NULL;
+
+	// Walk the readers list and return the first thing that passes
+	// the test and loads a mesh_t != NULL
+	const reader_t *r = NULL;
+	for(r = readers; r->name != NULL; r++) {
+		if(r->test(path) == 1) {
+			if((mesh = r->load(path))) {
+				break;
+			}
+		}
+	}
+
+	return mesh;
+}
+
+// Wrappers
+int _stl_predicate(char *path) {
+	// TODO: Valdiate the STL file instead of blindly trying a read.
+	//       Ideally, try to read a line, and pass if binary, if it's text
+	//       pass only if it begins with /^solid/i
+	return 1;
+}
+
+mesh_t* _stl_reader(char *path) {
+	stl_object *stl = NULL;
+	mesh_t *mesh = NULL;
+
+	check((stl = stl_read_file(path, 1)) != NULL,
+		  "Failed to read '%s' as STL", path);
+	check((mesh = NEW(stl_mesh_t, "STL", stl)) != NULL,
+		  "Failed to create mesh from STL(%p)", stl);
+
+	return mesh;
+error:
+	return NULL;
+}
+
+// List of readers that should be tried in order
+// {NULL, NULL, NULL} terminated.
+const reader_t readers[] = {
+	{"STL", _stl_predicate, _stl_reader},
+	{NULL, NULL, NULL}
+};

data/src/reader.h

@@ -0,0 +1,22 @@
+#include "mesh.h"
+
+#ifndef __READER_H
+#define __READER_H
+
+// API
+mesh_t* reader_load(char *path);
+
+// Types
+typedef int     (reader_predicate_t)(char *path);
+typedef mesh_t* (reader_loader_t)(char *path);
+
+typedef struct s_reader_t {
+	char *name;
+	reader_predicate_t *test;
+	reader_loader_t    *load;
+} reader_t;
+
+// Exported list of readers
+extern const reader_t readers[];
+
+#endif

data/src/stl.c

@@ -330,3 +330,56 @@ error:
 		if(fd != -1) close(fd);
 		return NULL;
 }
+
+// Mesh type prototype methods
+int stl_mesh_init(void *self, void *data) {
+	stl_mesh_t *mesh = (stl_mesh_t*)self;
+	if(data == NULL) {
+		check_mem(mesh->stl = stl_alloc(NULL, 0));
+	}
+	else {
+		mesh->stl = (stl_object*)data;
+	}
+	return 0;
+error:
+	return -1;
+}
+
+void stl_mesh_destroy(void *self) {
+	stl_mesh_t *mesh = (stl_mesh_t*)self;
+	stl_free(mesh->stl);
+	free(self);
+}
+
+int stl_mesh_poly_count(void *self) {
+	stl_mesh_t *mesh = (stl_mesh_t*)self;
+	return mesh->stl->facet_count;
+}
+
+klist_t(poly)* stl_mesh_to_polygons(void *self) {
+	stl_mesh_t *mesh = (stl_mesh_t*)self;
+	int count = mesh->_(poly_count)(mesh);
+	klist_t(poly)* polys = count > 0 ? kl_init(poly) : NULL;
+
+	for(int i = 0; i < count; i++) {
+		poly_t *poly = poly_make_triangle(mesh->stl->facets[i].vertices[0],
+										  mesh->stl->facets[i].vertices[1],
+										  mesh->stl->facets[i].vertices[2]);
+		check_mem(poly);
+		*kl_pushp(poly, polys) = poly;
+	}
+
+
+	return polys;
+error:
+	if(polys != NULL) kl_destroy(poly, polys);
+	return NULL;
+}
+
+// Mesh type definitions
+mesh_t stl_mesh_t_Proto = {
+	.init = stl_mesh_init,
+	.destroy = stl_mesh_destroy,
+	.poly_count = stl_mesh_poly_count,
+	.to_polygons = stl_mesh_to_polygons
+};

data/src/stl.h

@@ -4,12 +4,11 @@
 
 #include "klist.h"
 #include "vector.h"
+#include "mesh.h"
 
 #ifndef __STL_H
 #define __STL_H
 
-
-
 // File format structs
 typedef struct s_stl_facet {
 		float3 normal;
@@ -57,4 +56,12 @@ KLIST_INIT(stl_object, stl_object*, mp_stl_free)
 #define mp_std_free(x) free(kl_val(x))
 KLIST_INIT(stl_facet, stl_facet*, mp_std_free)
 
+// mesh_t type and prototype
+extern mesh_t stl_mesh_t_Proto;
+
+typedef struct s_stl_mesh_t {
+	mesh_t proto;
+	stl_object *stl;
+} stl_mesh_t;
+
 #endif

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csg
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Yaroslav Shirokov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-24 00:00:00.000000000 Z
+date: 2013-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -40,20 +40,26 @@ files:
 - src/commands.c
 - src/dbg.c
 - src/export.c
+- src/mesh.c
 - src/poly.c
+- src/reader.c
 - src/stl.c
 - src/vector.c
 - src/bsp.h
+- src/bsp_mesh.h
 - src/commands.h
 - src/dbg.h
 - src/export.h
 - src/klist.h
+- src/mesh.h
 - src/poly.h
+- src/reader.h
 - src/stl.h
 - src/vector.h
 - ext/Rakefile
 homepage: https://github.com/sshirokov/csgtool/
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []