tiny_obj 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 442019e9c76f9eff6a2d3f2b60956bc720ba31cc282b7b7e00ed516ec4ca1a1b
-  data.tar.gz: 13ada62da0a9d2083be44ae85ef206b3ccebf2bbbca694067716ff281f48ca41
+  metadata.gz: 5cb4b288a4c32292401439d4431e618b20db9feb501536521dfc73df992c9297
+  data.tar.gz: 83dc33eeb7db6cd9c80da7cbfe2bac6fcd89a714e802f50e827046a1ec74830b
 SHA512:
-  metadata.gz: 9e7128a7034acfe42341e3ba6b29af0cc39bdac2da20ef28f826273f8423d4a998e60b1c5fc50923e788bab831a8bce4e771dd6ab71dc6c393e25e607350191b
-  data.tar.gz: e171e4ad79b7c0bf604904d8108c8e6bf9f0cce80562a43dae8db55b3e75114cfd2e5ac75adaca6ecd76842a8d8554a1b36551e7836bc6da70889e00b0977232
+  metadata.gz: 9433112c3fa3db15ac7d8aa80cfda608d6959f979dc6b957e9e44a7c0c4045794ad1e94eb55b9371070907691df3c42678693d95993243b9d97ade144baf9bd2
+  data.tar.gz: fb56c01fbfb2ffa382b2b2ddba6d36a87e65e468787bc253ddfda15a69be6f8aa787bb14c01416dbcb5f6f342a20494a85c8811c36b1373b7ac3270e82cae498

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tiny_obj (0.1.0)
+    tiny_obj (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/ext/tiny_obj/init_tinyobj.c

@@ -1,10 +1,18 @@
-#include "ruby.h"
+#include "rb_tinyobj.h"
 
 VALUE rb_mTinyOBJ;
-
-VALUE rb_tinyobj_load(int argc, VALUE *argv, VALUE self);
+VALUE rb_cOBJ;
 
 void Init_tiny_obj(void) {
   rb_mTinyOBJ = rb_define_module("TinyOBJ");
+  rb_cOBJ = rb_define_class_under(rb_mTinyOBJ, "OBJ", rb_cObject);
+  rb_define_method(rb_cOBJ, "to_hash",               rb_obj_to_hash,                0);
+  rb_define_method(rb_cOBJ, "num_indices",           rb_obj_num_indices,           -1);
+  rb_define_method(rb_cOBJ, "num_distinct_vertices", rb_obj_num_distinct_vertices, -1);
+  rb_define_method(rb_cOBJ, "fill_buffers",          rb_obj_fill_buffers,          -1);
+  rb_define_method(rb_cOBJ, "vertices",              rb_obj_vertices,              -1);
+  rb_define_method(rb_cOBJ, "normals",               rb_obj_normals,               -1);
+  rb_define_method(rb_cOBJ, "texcoords",             rb_obj_texcoords,             -1);
+  rb_define_method(rb_cOBJ, "colors",                rb_obj_colors,                -1);
   rb_define_singleton_method(rb_mTinyOBJ, "load", rb_tinyobj_load, -1);
 }

data/ext/tiny_obj/rb_tinyobj.h

@@ -2,6 +2,22 @@
 #define RB_TINYOBJ_H 1
 
 #include "ruby.h"
+
+#ifdef __cplusplus
 #include "tiny_obj_loader.h"
+extern "C" {
+#endif
+  VALUE rb_tinyobj_load(int argc, VALUE *argv, VALUE self);
+  VALUE rb_obj_to_hash(VALUE self);
+  VALUE rb_obj_num_distinct_vertices(int argc, VALUE *argv, VALUE self);
+  VALUE rb_obj_num_indices(int argc, VALUE *argv, VALUE self);
+  VALUE rb_obj_fill_buffers(int argc, VALUE *argv, VALUE self);
+  VALUE rb_obj_vertices(int argc, VALUE *argv, VALUE self);
+  VALUE rb_obj_normals(int argc, VALUE *argv, VALUE self);
+  VALUE rb_obj_texcoords(int argc, VALUE *argv, VALUE self);
+  VALUE rb_obj_colors(int argc, VALUE *argv, VALUE self);
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* RB_TINYOBJ_H */

data/ext/tiny_obj/tinyobj.cpp

@@ -2,9 +2,54 @@
 #define TINYOBJLOADER_USE_DOUBLE
 #include "rb_tinyobj.h"
 #include <stdlib.h>
+#include <unordered_map>
+#include <stdint.h>
+
+// taken from Fiddle
+#if SIZEOF_VOIDP == SIZEOF_LONG
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
+#else
+# define NUM2PTR(x)   ((void*)(NUM2ULL(x)))
+#endif
 
 #define NIL_OR_STR(cstr) (strlen(cstr) > 0 ? Qnil : rb_str_new2(cstr))
 
+extern VALUE rb_cOBJ;
+
+typedef struct {
+  bool result;
+  std::string *warnings;
+  std::vector<tinyobj::shape_t> *shapes;
+  std::vector<tinyobj::material_t> *materials;
+  tinyobj::attrib_t *attrib;
+} obj_t;
+
+void obj_free(void* data) {
+  obj_t *obj = (obj_t *) data;
+  delete obj->warnings;
+  delete obj->shapes;
+  delete obj->materials;
+  delete obj->attrib;
+  free(data);
+}
+
+size_t obj_size(const void* data) {
+  return sizeof(obj_t);
+}
+
+static const rb_data_type_t obj_type = {
+  .wrap_struct_name = "OBJ3D",
+  .function = {
+    .dmark = NULL,
+    .dfree = obj_free,
+    .dsize = obj_size,
+    .reserved = { 0, 0 }
+  },
+  .parent = NULL,
+  .data = NULL,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 VALUE build_rb_texopt(tinyobj::texture_option_t *opt) {
   VALUE rt = rb_hash_new();
   if (opt->colorspace.size() > 0)
@@ -45,6 +90,18 @@ VALUE build_rb_texopt(tinyobj::texture_option_t *opt) {
   return rt;
 }
 
+inline void hash_combine(std::size_t& seed, int count, const float *vals) {
+  std::hash<float> hasher;
+  for (int i = 0; i < count; i++)
+    seed ^= hasher(vals[i]) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+}
+
+inline void hash_combine(std::size_t& seed, int count, const long *vals) {
+  std::hash<long> hasher;
+  for (int i = 0; i < count; i++)
+    seed ^= hasher(vals[i]) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+}
+
 extern "C" {
   VALUE rb_tinyobj_load(int argc, VALUE *argv, VALUE self) {
     VALUE fn, dir;
@@ -53,23 +110,327 @@ extern "C" {
       dir = rb_funcall(rb_cFile, rb_intern("dirname"), 1, fn);
     }
 
-    VALUE ret = rb_hash_new();
-
-    tinyobj::attrib_t attrib;
-    std::vector<tinyobj::shape_t> shapes;
-    std::vector<tinyobj::material_t> materials;
-    std::string warn, err;
-    bool result = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, StringValuePtr(fn), StringValuePtr(dir));
+    obj_t *obj = (obj_t *) malloc(sizeof(obj_t));
+    memset(obj, 0, sizeof(obj_t));
+    obj->warnings  = new std::string();
+    obj->shapes    = new std::vector<tinyobj::shape_t>();
+    obj->materials = new std::vector<tinyobj::material_t>();
+    obj->attrib    = new tinyobj::attrib_t();
+    std::string err;
 
-    if (!err.empty())
+    obj->result = tinyobj::LoadObj(obj->attrib, obj->shapes, obj->materials, obj->warnings, &err, StringValuePtr(fn), StringValuePtr(dir));
+    if (!err.empty()) {
+      obj_free(obj);
       rb_raise(rb_eRuntimeError, "error loading OBJ: %s", err.c_str());
+    }
+
+    return TypedData_Wrap_Struct(rb_cOBJ, &obj_type, obj);
+  }
+
+  static inline void *VAL2PTR(VALUE val) {
+    if (val == Qundef || NIL_P(val)) return NULL;
+    if (rb_respond_to(val, rb_intern("to_ptr"))) {
+      val = rb_funcall(val, rb_intern("to_ptr"), 0);
+    }
+    if (NIL_P(val)) return NULL;
+    return NUM2PTR(rb_funcall(val, rb_intern("to_i"), 0));
+  }
+
+  /* call-seq: fill_buffers(positions: nil, normals: nil, texcoords: nil, colors: nil, indices: nil,
+   *                        vertex_stride:, index_stride:, index_type:)
+   *
+   * Fills one or more buffers with data. This is much faster than doing it in
+   * Ruby because it avoids populating Ruby arrays with Ruby numeric types.
+   * Instead everything happens at a low level, giving essentially native
+   * performance for filling vertices, normals, texcoords, etc., which would
+   * otherwise be an expensive operation in Ruby.
+   *
+   * * `positions`, `normals`, `texcoords`, `colors` and `indices` are all
+   *   pointers to the memory location into which to store the data. Any of
+   *   these which is `nil` is simply omitted (data is not filled). If it
+   *   `responds_to?(:to_ptr)` then that method is called first, and the data
+   *   will be placed into whatever memory the result of the method refers to.
+   *   If it does not, then the object itself represents the buffer. In both
+   *   cases, the buffer must return a memory location from #to_i. Basically,
+   *   the data buffer is meant to be an instance of Fiddle::Pointer, but can
+   *   be any object which satisfies these constraints.
+   *
+   *   Note that each object can point to different offsets into the same
+   *   buffer. You don't need to use a separate allocation of memory for each
+   *   argument.
+   *
+   *   **IMPORTANT:** If the buffer's `to_i` method does not return an
+   *   appropriate memory offset, the program will have undefined behavior
+   *   and will typically result in a crash.
+   *
+   * * `vertex_stride` represents how many bytes to 'skip over' from one
+   *   vertex position, color, normal or texcoord to the next. This can be used
+   *   to populate a single buffer with interleaved vertex data.
+   *
+   * * `index_stride` is the same as `vertex_stride`, but for vertex indices.
+   *   It is separated from `vertex_stride` because index data is often not
+   *   interleaved with vertex data, and often lives in its own separate
+   *   buffer. Nothing prevents you from interleaving it with the vertex data,
+   *   of course, by specifying the same value as you did for `vertex_stride`.
+   *
+   * * `index_type` represents the primitive data type of a single index. It
+   *   can be one of:
+   *
+   *   * `:uint8`  - each index is an 8-bit unsigned integer
+   *   * `:uint16` - each index is a 16-bit unsigned integer
+   *   * `:uint32` - each index is a 32-bit unsigned integer
+   *   * `:uint64` - each index is a 64-bit unsigned integer
+   *
+   * Example:
+   *
+   *     # In this example, we'll fill 2 buffers, one with vertex data and the
+   *     # other with index data. In the vertex data we will gather positions,
+   *     # normals and texture coordinates but we will omit vertex colors.
+   *
+   *     vertex_stride = Fiddle::SIZEOF_FLOAT * (
+   *                       3 + # 3 floats for each position (x, y, z)
+   *                       3 + # 3 floats for each normal (x, y, z)
+   *                       2   # 2 floats for each texture coord (u, v)
+   *                     )
+   *     index_stride = 2 # each index will be one uint16, or two 8-bit bytes
+   *     vertex_buffer = Fiddle::Pointer.malloc(obj.num_distinct_vertices * vertex_stride)
+   *     index_buffer  = Fiddle::Pointer.malloc(obj.num_indices           * index_stride)
+   *     obj.fill_buffers(positions:     vertex_buffer,
+   *                      normals:       vertex_buffer + Fiddle::SIZEOF_FLOAT * 3,
+   *                      texcoords:     vertex_buffer + Fiddle::SIZEOF_FLOAT * 6,
+   *                      indices:       index_buffer,
+   *                      vertex_stride: vertex_stride,
+   *                      index_stride:  index_stride,
+   *                      index_type:    :uint16)
+   *
+   *     # vertex_buffer now contains interleaved vertex data, and
+   *     # index_buffer now contains index data. Print the first complete
+   *     # vertex:
+   *     Vertex = Fiddle::Importer.struct(['float pos[3]', 'float normal[3]', 'float texcoord[2]'])
+   *     v = Vertex.new(vertex_buffer)
+   *     p position: v.pos, normal: v.normal, texcoord: v.texcoord
+   */
+  VALUE rb_obj_fill_buffers(int argc, VALUE *argv, VALUE self) {
+    #define UINT8  0
+    #define UINT16 1
+    #define UINT32 2
+    #define UINT64 3
+    static ID kwargs_ids[9];
+    if (!kwargs_ids[0]) {
+      kwargs_ids[0] = rb_intern_const("vertex_stride");
+      kwargs_ids[1] = rb_intern_const("index_stride");
+      kwargs_ids[2] = rb_intern_const("index_type");
+      kwargs_ids[3] = rb_intern_const("positions");
+      kwargs_ids[4] = rb_intern_const("normals");
+      kwargs_ids[5] = rb_intern_const("texcoords");
+      kwargs_ids[6] = rb_intern_const("colors");
+      kwargs_ids[7] = rb_intern_const("indices");
+      kwargs_ids[8] = rb_intern_const("flip_v");
+    };
+    VALUE kwargs[9] = {Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil};
+    VALUE opts = Qnil;
+    rb_scan_args(argc, argv, "00:", &opts);
+    rb_get_kwargs(opts, kwargs_ids, 3, 6, kwargs);
+
+    bool flip_v     = kwargs[8] == Qundef || kwargs[8] == Qfalse || kwargs[8] == Qnil ? false : true;
+    char *positions = (char *) VAL2PTR(kwargs[3]);
+    char *normals   = (char *) VAL2PTR(kwargs[4]);
+    char *texcoords = (char *) VAL2PTR(kwargs[5]);
+    char *colors    = (char *) VAL2PTR(kwargs[6]);
+    char *indices   = (char *) VAL2PTR(kwargs[7]);
+    size_t vertex_stride = NUM2SIZET(kwargs[0]);
+    size_t index_stride  = NUM2SIZET(kwargs[1]);
+    int    index_type = -1;
+    if      (SYM2ID(kwargs[2]) == rb_intern("uint8" )) index_type = UINT8;
+    else if (SYM2ID(kwargs[2]) == rb_intern("uint16")) index_type = UINT16;
+    else if (SYM2ID(kwargs[2]) == rb_intern("uint32")) index_type = UINT32;
+    else if (SYM2ID(kwargs[2]) == rb_intern("uint64")) index_type = UINT64;
+    else rb_raise(rb_eArgError, "unknown index_type");
+
+    obj_t *obj;
+    TypedData_Get_Struct(self, obj_t, &obj_type, obj);
+    std::vector<tinyobj::shape_t> &shapes = *(obj->shapes);
+    tinyobj::attrib_t             &attrib = *(obj->attrib);
+
+    size_t vertex_offset = 0;
+    size_t index_offset = 0;
+    std::unordered_map<size_t, int64_t> vertex_map;
+    for (size_t s = 0; s < shapes.size(); s++) {
+      for (size_t i = 0; i < shapes[s].mesh.indices.size(); i++) {
+        size_t hash = 0;
+        long vertex[] = {
+          3 * shapes[s].mesh.indices[i].vertex_index   + 0,
+          3 * shapes[s].mesh.indices[i].vertex_index   + 1,
+          3 * shapes[s].mesh.indices[i].vertex_index   + 2,
+          2 * shapes[s].mesh.indices[i].texcoord_index + 0,
+          2 * shapes[s].mesh.indices[i].texcoord_index + 1,
+          3 * shapes[s].mesh.indices[i].normal_index   + 0,
+          3 * shapes[s].mesh.indices[i].normal_index   + 1,
+          3 * shapes[s].mesh.indices[i].normal_index   + 2,
+        };
+        hash_combine(hash, sizeof(vertex) / sizeof(long), vertex);
+        uint64_t index;
+        if (vertex_map.count(hash) == 0) {
+          if (positions && vertex[0] >= 0) {
+            *((float *)(positions + vertex_offset                )) = attrib.vertices[vertex[0]];
+            *((float *)(positions + vertex_offset+1*sizeof(float))) = attrib.vertices[vertex[1]];
+            *((float *)(positions + vertex_offset+2*sizeof(float))) = attrib.vertices[vertex[2]];
+          }
+          if (colors && vertex[0] >= 0) {
+            *((float *)(colors    + vertex_offset                )) = attrib.colors[vertex[0]];
+            *((float *)(colors    + vertex_offset+1*sizeof(float))) = attrib.colors[vertex[1]];
+            *((float *)(colors    + vertex_offset+2*sizeof(float))) = attrib.colors[vertex[2]];
+          }
+          if (texcoords && vertex[3] >= 0) {
+            *((float *)(texcoords + vertex_offset                )) = attrib.texcoords[vertex[3]];
+            if (flip_v)
+              *((float *)(texcoords + vertex_offset+1*sizeof(float))) = 1.0f - attrib.texcoords[vertex[4]];
+            else
+              *((float *)(texcoords + vertex_offset+1*sizeof(float))) = attrib.texcoords[vertex[4]];
+          }
+          if (normals && vertex[5] >= 0) {
+            *((float *)(normals   + vertex_offset                )) = attrib.normals[vertex[5]];
+            *((float *)(normals   + vertex_offset+1*sizeof(float))) = attrib.normals[vertex[6]];
+            *((float *)(normals   + vertex_offset+2*sizeof(float))) = attrib.normals[vertex[7]];
+          }
+          index = vertex_map.size();
+          vertex_map[hash] = index;
+          vertex_offset += vertex_stride;
+        } else {
+          index = vertex_map[hash];
+        }
+        // printf("%zu\n", index);
+        if (indices) {
+          switch(index_type) {
+            case UINT8:  *((uint8_t  *)(indices + index_offset)) = (uint8_t)  index; break;
+            case UINT16: *((uint16_t *)(indices + index_offset)) = (uint16_t) index; break;
+            case UINT32: *((uint32_t *)(indices + index_offset)) = (uint32_t) index; break;
+            case UINT64: *((uint64_t *)(indices + index_offset)) = (uint64_t) index; break;
+            default: rb_raise(rb_eRuntimeError, "BUG: unexpected index type: %d", index_type);
+          }
+          index_offset += index_stride;
+        }
+      }
+    }
+
+    return self;
+  }
 
-    rb_hash_aset(ret, ID2SYM(rb_intern("success")), result ? Qtrue : Qfalse);
+  VALUE rb_obj_num_distinct_vertices(int argc, VALUE *argv, VALUE self) {
+    // cache = {}
+    // h[:shapes].each do |shape|
+    //   shape[:mesh][:indices].each_with_index do |index, i|
+    //     hash = [
+    //              index[  :vertex_index] && 3.times.map { |i| 3 * index[:vertex_index]   + i },
+    //              index[  :vertex_index] && 3.times.map { |i| 3 * index[:vertex_index]   + i },
+    //              index[  :normal_index] && 3.times.map { |i| 3 * index[:normal_index]   + i },
+    //              index[:texcoord_index] && 2.times.map { |i| 2 * index[:texcoord_index] + i }
+    //            ]
+    //     cache[hash] = cache.size unless cache.include?(hash)
+    //   end
+    // end
 
-    if (!warn.empty())
-      rb_hash_aset(ret, ID2SYM(rb_intern("warnings")), rb_str_new2(warn.c_str()));
+    obj_t *obj;
+    TypedData_Get_Struct(self, obj_t, &obj_type, obj);
+    std::vector<tinyobj::shape_t> &shapes = *(obj->shapes);
+
+    size_t count = 0;
+    std::unordered_map<size_t, size_t> vertex_map;
+    for (size_t s = 0; s < shapes.size(); s++) {
+      for (size_t i = 0; i < shapes[s].mesh.indices.size(); i++) {
+        tinyobj::index_t &index = shapes[s].mesh.indices[i];
+        size_t hash = 0;
+        long vertex[] = {
+          3 * index.vertex_index   + 0,
+          3 * index.vertex_index   + 1,
+          3 * index.vertex_index   + 2,
+          2 * index.texcoord_index + 0,
+          2 * index.texcoord_index + 1,
+          3 * index.normal_index   + 0,
+          3 * index.normal_index   + 1,
+          3 * index.normal_index   + 2
+        };
+        hash_combine(hash, sizeof(vertex) / sizeof(long), vertex);
+        if (vertex_map.count(hash) == 0) {
+          vertex_map[hash] = hash;
+          count++;
+        }
+      }
+    }
+
+    return SIZET2NUM(count);
+  }
+
+  VALUE rb_obj_num_indices(int argc, VALUE *argv, VALUE self) {
+    // h[:shapes].reduce(0) { |a, shape| a + shape[:mesh][:indices].size }
+
+    obj_t *obj;
+    TypedData_Get_Struct(self, obj_t, &obj_type, obj);
+    std::vector<tinyobj::shape_t>    &shapes    = *(obj->shapes);
+
+    long count = 0;
+    for (size_t s = 0; s < shapes.size(); s++) {
+      count += shapes[s].mesh.indices.size();
+    }
+
+    return LONG2NUM(count);
+  }
+
+  VALUE rb_obj_vertices(int argc, VALUE *argv, VALUE self) {
+    obj_t *obj;
+    TypedData_Get_Struct(self, obj_t, &obj_type, obj);
+    tinyobj::attrib_t &attrib = *(obj->attrib);
+    VALUE rb_vertices = rb_ary_new2(attrib.vertices.size());
+    for (size_t i = 0; i < attrib.vertices.size(); i++)
+      rb_ary_push(rb_vertices, DBL2NUM(attrib.vertices[i]));
+    return rb_vertices;
+  }
+
+  VALUE rb_obj_normals(int argc, VALUE *argv, VALUE self) {
+    obj_t *obj;
+    TypedData_Get_Struct(self, obj_t, &obj_type, obj);
+    tinyobj::attrib_t &attrib = *(obj->attrib);
+    VALUE rb_normals = rb_ary_new2(attrib.normals.size());
+    for (size_t i = 0; i < attrib.normals.size(); i++)
+      rb_ary_push(rb_normals, DBL2NUM(attrib.normals[i]));
+    return rb_normals;
+  }
+
+  VALUE rb_obj_texcoords(int argc, VALUE *argv, VALUE self) {
+    obj_t *obj;
+    TypedData_Get_Struct(self, obj_t, &obj_type, obj);
+    tinyobj::attrib_t &attrib = *(obj->attrib);
+    VALUE rb_texcoords = rb_ary_new2(attrib.texcoords.size());
+    for (size_t i = 0; i < attrib.texcoords.size(); i++)
+      rb_ary_push(rb_texcoords, DBL2NUM(attrib.texcoords[i]));
+    return rb_texcoords;
+  }
+
+  VALUE rb_obj_colors(int argc, VALUE *argv, VALUE self) {
+    obj_t *obj;
+    TypedData_Get_Struct(self, obj_t, &obj_type, obj);
+    tinyobj::attrib_t &attrib = *(obj->attrib);
+    VALUE rb_colors = rb_ary_new2(attrib.colors.size());
+    for (size_t i = 0; i < attrib.colors.size(); i++)
+      rb_ary_push(rb_colors, DBL2NUM(attrib.colors[i]));
+    return rb_colors;
+  }
+
+  VALUE rb_obj_to_hash(VALUE self) {
+    obj_t *obj;
+    TypedData_Get_Struct(self, obj_t, &obj_type, obj);
+    std::string                      &warnings  = *(obj->warnings);
+    std::vector<tinyobj::shape_t>    &shapes    = *(obj->shapes);
+    std::vector<tinyobj::material_t> &materials = *(obj->materials);
+
+    VALUE ret = rb_hash_new();
+    rb_hash_aset(ret, ID2SYM(rb_intern("success")), obj->result ? Qtrue : Qfalse);
+
+    if (warnings.size() > 0)
+      rb_hash_aset(ret, ID2SYM(rb_intern("warnings")), rb_str_new2(warnings.c_str()));
 
     VALUE rb_materials = rb_ary_new2(materials.size());
+    rb_hash_aset(ret, ID2SYM(rb_intern("materials")), rb_materials);
     for (size_t m = 0; m < materials.size(); m++) {
       VALUE rb_material = rb_hash_new();
       rb_ary_push(rb_materials, rb_material);
@@ -138,22 +499,10 @@ extern "C" {
         rb_hash_aset(rb_material, ID2SYM(rb_intern("unknown_parameters")), rb_unknown_parameter);
     }
 
-    VALUE rb_vertices  = rb_ary_new2(attrib.vertices.size()),
-          rb_normals   = rb_ary_new2(attrib.normals.size()),
-          rb_texcoords = rb_ary_new2(attrib.texcoords.size()),
-          rb_colors    = rb_ary_new2(attrib.colors.size());
-    rb_hash_aset(ret, ID2SYM(rb_intern("vertices")),  rb_vertices);
-    rb_hash_aset(ret, ID2SYM(rb_intern("normals")),   rb_normals);
-    rb_hash_aset(ret, ID2SYM(rb_intern("texcoords")), rb_texcoords);
-    rb_hash_aset(ret, ID2SYM(rb_intern("colors")),    rb_colors);
-    for (size_t i = 0; i < attrib.vertices.size();  i++)
-      rb_ary_push(rb_vertices,  DBL2NUM(attrib.vertices[i]));
-    for (size_t i = 0; i < attrib.normals.size();   i++)
-      rb_ary_push(rb_normals,   DBL2NUM(attrib.normals[i]));
-    for (size_t i = 0; i < attrib.texcoords.size(); i++)
-      rb_ary_push(rb_texcoords, DBL2NUM(attrib.texcoords[i]));
-    for (size_t i = 0; i < attrib.colors.size();    i++)
-      rb_ary_push(rb_colors,    DBL2NUM(attrib.colors[i]));
+    rb_hash_aset(ret, ID2SYM(rb_intern("vertices")),  rb_funcall(self, rb_intern("vertices"),  0));
+    rb_hash_aset(ret, ID2SYM(rb_intern("normals")),   rb_funcall(self, rb_intern("normals"),   0));
+    rb_hash_aset(ret, ID2SYM(rb_intern("texcoords")), rb_funcall(self, rb_intern("texcoords"), 0));
+    rb_hash_aset(ret, ID2SYM(rb_intern("colors")),    rb_funcall(self, rb_intern("colors"),    0));
 
     VALUE rb_shapes = rb_ary_new2(shapes.size());
     rb_hash_aset(ret, ID2SYM(rb_intern("shapes")), rb_shapes);

data/lib/tiny_obj/version.rb

@@ -1,3 +1,3 @@
 module TinyOBJ
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tiny_obj
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Colin MacKenzie IV
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-15 00:00:00.000000000 Z
+date: 2018-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler