tiny_gltf 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b954a969cc444a33651e63d72d15d816b3b5f109d419179dfded48934099c9d3
-  data.tar.gz: fefc289f2b3c6caa665a267aa5c7f8a19c732c44a8321cca22dc5739b3a75d6f
+  metadata.gz: 5158d1be6e6b7ca81b1811dfe102928bf646465f249aa40d1d9a6c28ff8db94a
+  data.tar.gz: 8144cd44561010a81aeabd21ae722290882e99767d2aa6a1db7dbcac14436756
 SHA512:
-  metadata.gz: de2c43dd86086b3b5abed2be79de26b0720273ad6af6fd56752be3dd12f38a92040824a46179967c672de0e3f2461c03d8df7e9f1e2f8934ca6b009e82c0e650
-  data.tar.gz: d023f445d65862e8b20a52b38b5597e5b2b7606974f6ccddab6f7bd105611fdd1aa538f8dd36da292106bc70e0b6c2b43c4716e478cc53e92f28595f75cc8523
+  metadata.gz: 48dd3bf544f2af2c009c26cbf5d28e14a89a18ab27649fd2ce83863f2a9b4758ae3a7e21f71d6289be4d06ba09eac43f1db46af47e5357ae5aa36bf47036b92e
+  data.tar.gz: a6eb083a256ea2fb43a8ee9c241ee2ce596b32d267907a84a533c11433a47c18812934a69bed7f603470512402c1eb7e748062b528c0c753ec581126b0ae11c1

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "test/fixtures/gltf_sample_models"]
+	path = test/fixtures/gltf_sample_models
+	url = https://github.com/KhronosGroup/glTF-Sample-Models

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tiny_gltf (0.1.0)
+    tiny_gltf (1.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -12,7 +12,7 @@ GEM
     rake-compiler (1.0.5)
       rake
     redcarpet (3.4.0)
-    yard (0.9.16)
+    yard (0.9.20)
 
 PLATFORMS
   ruby
@@ -28,4 +28,4 @@ DEPENDENCIES
   yard (~> 0.9)
 
 BUNDLED WITH
-   2.0.0.pre.1
+   2.0.2

data/bin/setup

@@ -6,3 +6,5 @@ set -vx
 bundle install
 
 # Do any other automated setup that you need to do here
+git submodule init
+git submodule update

data/ext/tiny_gltf/rb_tiny_gltf.h

@@ -35,6 +35,8 @@ extern VALUE rb_mTinyGLTF,
   VALUE name ## _is_equal(VALUE self, VALUE other);     \
   VALUE name ## _alloc(VALUE klass);
 
+#define RINDEX_OR_NIL(n) (n == -1 ? Qnil : INT2NUM(n))
+
 GLTF_TYPE(Model);
 GLTF_TYPE(Accessor);
 GLTF_TYPE(Asset);
@@ -68,18 +70,26 @@ VALUE texture_type_to_sym(int type);
 VALUE target_to_sym(int tgt);
 VALUE shader_type_to_sym(int type);
 
-VALUE Accessor_byte_stride(VALUE self, VALUE buffer_view);
+VALUE Buffer_to_ptr(VALUE self);
+VALUE Buffer_size(VALUE self);
+VALUE Buffer_to_s(VALUE self);
+VALUE Buffer_uri(VALUE self);
+VALUE Image_set_uri(VALUE self, VALUE uri);
+VALUE Image_to_ptr(VALUE self);
+VALUE Image_size(VALUE self);
+VALUE Image_to_s(VALUE self);
+VALUE Image_uri(VALUE self);
 
 #if __cplusplus
   /*
-    VALUE rModel_new(const Model *);
+    VALUE rAccessor_new(const Accessor *, VALUE);
   */
-  #define GLTF_RUBY_WRAP(klass) VALUE r ## klass ## _new(const klass *);
+  #define GLTF_RUBY_WRAP(klass) VALUE r ## klass ## _new(const klass *, VALUE);
 
   /*
-    static inline Model *Model_unwrap(VALUE val) {
-      Model *a = NULL;
-      TypedData_Get_Struct(val, Model, &T_Model, a);
+    static inline Accessor *Accessor_unwrap(VALUE val) {
+      Accessor *a = NULL;
+      TypedData_Get_Struct(val, Accessor, &T_Accessor, a);
       if (a == NULL)
         rb_raise(rb_eArgError, "BUG: " #name " is NULL");
       return a;
@@ -101,9 +111,10 @@ VALUE Accessor_byte_stride(VALUE self, VALUE buffer_view);
   GLTF_RUBY_WRAP(ParameterMap);
   GLTF_RUBY_WRAP(Value);
 
+  VALUE rModel_new(const Model *);
+  GLTF_RUBY_UNWRAP(Model);
   GLTF_RUBY_WRAPPERS(Asset);
   GLTF_RUBY_WRAPPERS(Primitive);
-  GLTF_RUBY_WRAPPERS(Model);
   GLTF_RUBY_WRAPPERS(Accessor);
   GLTF_RUBY_WRAPPERS(Animation);
   GLTF_RUBY_WRAPPERS(AnimationSampler);

data/ext/tiny_gltf/rb_tiny_gltf_accessor.cpp

@@ -1,17 +1,18 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rAccessor_new(const Accessor *accessor) {
+VALUE rAccessor_new(const Accessor *accessor, VALUE rmodel) {
   VALUE raccessor = rb_funcall(rb_cAccessor, rb_intern("new"), 0);
   *Accessor_unwrap(raccessor) = *accessor;
 
-  rb_ivar_set(raccessor, rb_intern("@buffer_view_index"), INT2NUM(accessor->bufferView));
+  rb_ivar_set(raccessor, rb_intern("@model"),             rmodel);
+  rb_ivar_set(raccessor, rb_intern("@buffer_view_index"), RINDEX_OR_NIL(accessor->bufferView));
   rb_ivar_set(raccessor, rb_intern("@component_type"),    component_type_to_sym(accessor->componentType));
   rb_ivar_set(raccessor, rb_intern("@count"),             SIZET2NUM(accessor->count));
   rb_ivar_set(raccessor, rb_intern("@name"),              rb_str_new2(accessor->name.c_str()));
   rb_ivar_set(raccessor, rb_intern("@byte_offset"),       SIZET2NUM(accessor->byteOffset));
   rb_ivar_set(raccessor, rb_intern("@normalized"),        accessor->normalized ? Qtrue : Qfalse);
   rb_ivar_set(raccessor, rb_intern("@type"),              type_to_sym(accessor->type));
-  rb_ivar_set(raccessor, rb_intern("@extras"),            rValue_new(&accessor->extras));
+  rb_ivar_set(raccessor, rb_intern("@extras"),            rValue_new(&accessor->extras, rmodel));
   rb_ivar_set(raccessor, rb_intern("@min"),               Qnil);
   rb_ivar_set(raccessor, rb_intern("@max"),               Qnil);
 
@@ -31,12 +32,3 @@ VALUE rAccessor_new(const Accessor *accessor) {
 
   return raccessor;
 }
-
-/* call-seq: byte_stride(buffer_view) => Numeric
- *
- * Returns the calculated byte stride for this accessor and the given buffer
- * view.
- */
-VALUE Accessor_byte_stride(VALUE self, VALUE buffer_view) {
-  return INT2NUM(Accessor_unwrap(self)->ByteStride(*BufferView_unwrap(buffer_view)));
-}

data/ext/tiny_gltf/rb_tiny_gltf_animation.cpp

@@ -1,21 +1,22 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rAnimation_new(const Animation *animation) {
+VALUE rAnimation_new(const Animation *animation, VALUE rmodel) {
   VALUE ranimation = rb_funcall(rb_cAnimation, rb_intern("new"), 0);
   // *Animation_unwrap(ranimation) = *animation;
 
   VALUE rchannels = rb_ary_new();
   for (size_t i = 0; i < animation->channels.size(); i++)
-    rb_ary_push(rchannels, rAnimationChannel_new(&animation->channels[i]));
+    rb_ary_push(rchannels, rAnimationChannel_new(&animation->channels[i], ranimation));
 
   VALUE rsamplers = rb_ary_new();
   for (size_t i = 0; i < animation->samplers.size(); i++)
-    rb_ary_push(rsamplers, rAnimationSampler_new(&animation->samplers[i]));
+    rb_ary_push(rsamplers, rAnimationSampler_new(&animation->samplers[i], ranimation));
 
+  rb_ivar_set(ranimation, rb_intern("@model"),     rmodel);
   rb_ivar_set(ranimation, rb_intern("@name"),      rb_str_new2(animation->name.c_str()));
   rb_ivar_set(ranimation, rb_intern("@channels"),  rchannels);
-  rb_ivar_set(ranimation, rb_intern("@rsamplers"), rsamplers);
-  rb_ivar_set(ranimation, rb_intern("@extras"),    rValue_new(&animation->extras));
+  rb_ivar_set(ranimation, rb_intern("@samplers"),  rsamplers);
+  rb_ivar_set(ranimation, rb_intern("@extras"),    rValue_new(&animation->extras, rmodel));
 
   return ranimation;
 }

data/ext/tiny_gltf/rb_tiny_gltf_animation_channel.cpp

@@ -1,13 +1,14 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rAnimationChannel_new(const AnimationChannel *animation_channel) {
+VALUE rAnimationChannel_new(const AnimationChannel *animation_channel, VALUE ranimation) {
   VALUE ranimation_channel = rb_funcall(rb_cAnimationChannel, rb_intern("new"), 0);
   // *AnimationChannel_unwrap(ranimation_channel) = *animation_channel;
 
-  rb_ivar_set(ranimation_channel, rb_intern("@sampler_index"),     INT2NUM(animation_channel->sampler));
-  rb_ivar_set(ranimation_channel, rb_intern("@target_node_index"), INT2NUM(animation_channel->target_node));
-  rb_ivar_set(ranimation_channel, rb_intern("@target_path"),       rb_intern(animation_channel->target_path.c_str()));
-  rb_ivar_set(ranimation_channel, rb_intern("@extras"),            rValue_new(&animation_channel->extras));
+  rb_ivar_set(ranimation_channel, rb_intern("@animation"),         ranimation);
+  rb_ivar_set(ranimation_channel, rb_intern("@sampler_index"),     RINDEX_OR_NIL(animation_channel->sampler));
+  rb_ivar_set(ranimation_channel, rb_intern("@target_node_index"), RINDEX_OR_NIL(animation_channel->target_node));
+  rb_ivar_set(ranimation_channel, rb_intern("@target_path"),       ID2SYM(rb_intern(animation_channel->target_path.c_str())));
+  rb_ivar_set(ranimation_channel, rb_intern("@extras"),            rValue_new(&animation_channel->extras, rb_funcall(ranimation, rb_intern("model"), 0)));
 
   return ranimation_channel;
 }

data/ext/tiny_gltf/rb_tiny_gltf_animation_sampler.cpp

@@ -1,16 +1,17 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rAnimationSampler_new(const AnimationSampler *animation_sampler) {
+VALUE rAnimationSampler_new(const AnimationSampler *animation_sampler, VALUE ranimation) {
   VALUE ranimation_sampler = rb_funcall(rb_cAnimationSampler, rb_intern("new"), 0);
   // *AnimationSampler_unwrap(ranimation_sampler) = *animation_sampler;
 
   std::string interp = animation_sampler->interpolation;
   std::transform(interp.begin(), interp.end(), interp.begin(), ::tolower);
 
-  rb_ivar_set(ranimation_sampler, rb_intern("@input"),         INT2NUM(animation_sampler->input));
-  rb_ivar_set(ranimation_sampler, rb_intern("@output"),        INT2NUM(animation_sampler->output));
-  rb_ivar_set(ranimation_sampler, rb_intern("@interpolation"), rb_intern(interp.c_str()));
-  rb_ivar_set(ranimation_sampler, rb_intern("@extras"),        rValue_new(&animation_sampler->extras));
+  rb_ivar_set(ranimation_sampler, rb_intern("@animation"),     ranimation);
+  rb_ivar_set(ranimation_sampler, rb_intern("@input_index"),   RINDEX_OR_NIL(animation_sampler->input));
+  rb_ivar_set(ranimation_sampler, rb_intern("@output_index"),  RINDEX_OR_NIL(animation_sampler->output));
+  rb_ivar_set(ranimation_sampler, rb_intern("@interpolation"), ID2SYM(rb_intern(interp.c_str())));
+  rb_ivar_set(ranimation_sampler, rb_intern("@extras"),        rValue_new(&animation_sampler->extras, rb_funcall(ranimation, rb_intern("model"), 0)));
 
   return ranimation_sampler;
 }

data/ext/tiny_gltf/rb_tiny_gltf_asset.cpp

@@ -1,15 +1,16 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rAsset_new(const Asset *asset) {
+VALUE rAsset_new(const Asset *asset, VALUE rmodel) {
   VALUE rasset = rb_funcall(rb_cAsset, rb_intern("new"), 0);
   // *Asset_unwrap(rasset) = *asset;
 
+  rb_ivar_set(rasset, rb_intern("@model"),       rmodel);
   rb_ivar_set(rasset, rb_intern("@version"),     rb_str_new2(asset->version.c_str()));
   rb_ivar_set(rasset, rb_intern("@generator"),   rb_str_new2(asset->generator.c_str()));
   rb_ivar_set(rasset, rb_intern("@min_version"), rb_str_new2(asset->minVersion.c_str()));
   rb_ivar_set(rasset, rb_intern("@copyright"),   rb_str_new2(asset->copyright.c_str()));
-  rb_ivar_set(rasset, rb_intern("@extensions"),  rExtensionMap_new(&asset->extensions));
-  rb_ivar_set(rasset, rb_intern("@extras"),      rValue_new(&asset->extras));
+  rb_ivar_set(rasset, rb_intern("@extensions"),  rExtensionMap_new(&asset->extensions, rmodel));
+  rb_ivar_set(rasset, rb_intern("@extras"),      rValue_new(&asset->extras, rmodel));
   
   return rasset;
 }

data/ext/tiny_gltf/rb_tiny_gltf_buffer.cpp

@@ -1,16 +1,45 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rBuffer_new(const Buffer *buf) {
+VALUE rBuffer_new(const Buffer *buf, VALUE rmodel) {
   VALUE rbuf = rb_funcall(rb_cBuffer, rb_intern("new"), 0);
-  // *Buffer_unwrap(rbuf) = *buf;
 
-  rb_ivar_set(rbuf, rb_intern("@name"),   rb_str_new2(buf->name.c_str()));
-  rb_ivar_set(rbuf, rb_intern("@data"),   rb_str_new((char *) buf->data.data(), buf->data.size()));
-  rb_ivar_set(rbuf, rb_intern("@uri"),    Qnil);
-  rb_ivar_set(rbuf, rb_intern("@extras"), rValue_new(&buf->extras));
+  // Keep (yes duplicate but the original will be freed) the buffer data
+  // in memory w/o having to wrap with a ruby string, which can be expensive
+  // and inefficient.
+  Buffer *dup = Buffer_unwrap(rbuf);
+  dup->data = buf->data;
+  dup->uri  = buf->uri;
 
-  if (buf->uri.size() > 0)
-    rb_ivar_set(rbuf, rb_intern("@uri"),  rb_str_new2(buf->uri.c_str()));
+  rb_ivar_set(rbuf, rb_intern("@model"),  rmodel);
+  rb_ivar_set(rbuf, rb_intern("@name"),   rb_str_new2(buf->name.c_str()));
+  rb_ivar_set(rbuf, rb_intern("@extras"), rValue_new(&buf->extras, rmodel));
 
   return rbuf;
 }
+
+VALUE Buffer_to_ptr(VALUE self) {
+  // return Fiddle::Pointer.new(addr, size)
+  VALUE rFiddlePointer = rb_const_get(rb_const_get(rb_cObject, rb_intern("Fiddle")),
+                                      rb_intern("Pointer"));
+  Buffer *buf = Buffer_unwrap(self);
+  return rb_funcall(rFiddlePointer, rb_intern("new"), 2,
+                    ULL2NUM((unsigned long long) buf->data.data()),
+                    ULL2NUM((unsigned long long) buf->data.size()));
+}
+
+VALUE Buffer_size(VALUE self) {
+  return ULONG2NUM(Buffer_unwrap(self)->data.size());
+}
+
+VALUE Buffer_to_s(VALUE self) {
+  Buffer *buf = Buffer_unwrap(self);
+  return rb_str_new((char *) buf->data.data(), buf->data.size());
+}
+
+VALUE Buffer_uri(VALUE self) {
+  Buffer *buf = Buffer_unwrap(self);
+  if (buf->uri.size() > 0)
+    return rb_str_new2(buf->uri.c_str());
+  else
+    return Qnil;
+}

data/ext/tiny_gltf/rb_tiny_gltf_buffer_view.cpp

@@ -1,16 +1,17 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rBufferView_new(const BufferView *view) {
+VALUE rBufferView_new(const BufferView *view, VALUE rmodel) {
   VALUE rbuf = rb_funcall(rb_cBufferView, rb_intern("new"), 0);
   *BufferView_unwrap(rbuf) = *view;
 
+  rb_ivar_set(rbuf, rb_intern("@model"),        rmodel);
   rb_ivar_set(rbuf, rb_intern("@name"),         rb_str_new2(view->name.c_str()));
-  rb_ivar_set(rbuf, rb_intern("@buffer_index"), INT2NUM(view->buffer));
+  rb_ivar_set(rbuf, rb_intern("@buffer_index"), RINDEX_OR_NIL(view->buffer));
   rb_ivar_set(rbuf, rb_intern("@byte_offset"),  SIZET2NUM(view->byteOffset));
   rb_ivar_set(rbuf, rb_intern("@byte_length"),  SIZET2NUM(view->byteLength));
   rb_ivar_set(rbuf, rb_intern("@byte_stride"),  SIZET2NUM(view->byteStride));
   rb_ivar_set(rbuf, rb_intern("@target"),       target_to_sym(view->target));
-  rb_ivar_set(rbuf, rb_intern("@extras"),       rValue_new(&view->extras));
+  rb_ivar_set(rbuf, rb_intern("@extras"),       rValue_new(&view->extras, rmodel));
 
   return rbuf;
 }

data/ext/tiny_gltf/rb_tiny_gltf_camera.cpp

@@ -1,13 +1,14 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rCamera_new(const Camera *camera) {
+VALUE rCamera_new(const Camera *camera, VALUE rmodel) {
   VALUE rcamera = rb_funcall(rb_cCamera, rb_intern("new"), 0);
   // *Camera_unwrap(rcamera) = *camera;
 
+  rb_ivar_set(rcamera, rb_intern("@model"),      rmodel);
   rb_ivar_set(rcamera, rb_intern("@name"),       rb_str_new2(camera->name.c_str()));
   rb_ivar_set(rcamera, rb_intern("@type"),       rb_intern(camera->type.c_str()));
-  rb_ivar_set(rcamera, rb_intern("@extensions"), rExtensionMap_new(&camera->extensions));
-  rb_ivar_set(rcamera, rb_intern("@extras"),     rValue_new(&camera->extras));
+  rb_ivar_set(rcamera, rb_intern("@extensions"), rExtensionMap_new(&camera->extensions, rmodel));
+  rb_ivar_set(rcamera, rb_intern("@extras"),     rValue_new(&camera->extras, rmodel));
 
   if (!strcmp(camera->type.c_str(), "perspective")) {
     rb_ivar_set(rcamera, rb_intern("@aspect_ratio"), DBL2NUM(camera->perspective.aspectRatio));

data/ext/tiny_gltf/rb_tiny_gltf_extension_map.cpp

@@ -1,11 +1,11 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rExtensionMap_new(const ExtensionMap *value) {
+VALUE rExtensionMap_new(const ExtensionMap *value, VALUE rmodel) {
   VALUE res = Qnil;
 
   for (ExtensionMap::const_iterator iterator = value->begin(); iterator != value->end(); iterator++) {
     if (NIL_P(res)) res = rb_hash_new();
-    rb_hash_aset(res, rb_str_new2(iterator->first.c_str()), rValue_new(&iterator->second));
+    rb_hash_aset(res, rb_str_new2(iterator->first.c_str()), rValue_new(&iterator->second, rmodel));
   }
 
   return res;

data/ext/tiny_gltf/rb_tiny_gltf_image.cpp

@@ -1,25 +1,85 @@
 #include "rb_tiny_gltf.h"
 
-VALUE rImage_new(const Image *img) {
-  VALUE rimg = rb_funcall(rb_cImage, rb_intern("new"), 0);
-  // *Image_unwrap(rimg) = *img;
+void Image_set_image_data(const Image *img, VALUE rimg) {
+  // Keep (yes duplicate but the original will be freed) the buffer data
+  // in memory w/o having to wrap with a ruby string, which can be expensive
+  // and inefficient.
+  Image *dst = Image_unwrap(rimg);
+  dst->image = img->image;
+  dst->uri  = img->uri;
 
-  rb_ivar_set(rimg, rb_intern("@name"),              rb_str_new2(img->name.c_str()));
-  rb_ivar_set(rimg, rb_intern("@data"),              rb_str_new((char *) img->image.data(), img->image.size()));
-  rb_ivar_set(rimg, rb_intern("@uri"),               Qnil);
-  rb_ivar_set(rimg, rb_intern("@mime_type"),         Qnil);
-  rb_ivar_set(rimg, rb_intern("@extras"),            rValue_new(&img->extras));
   rb_ivar_set(rimg, rb_intern("@width"),             INT2NUM(img->width));
   rb_ivar_set(rimg, rb_intern("@height"),            INT2NUM(img->height));
   rb_ivar_set(rimg, rb_intern("@components"),        INT2NUM(img->component));
-  rb_ivar_set(rimg, rb_intern("@buffer_view_index"), INT2NUM(img->bufferView));
-  rb_ivar_set(rimg, rb_intern("@extensions"),        rExtensionMap_new(&img->extensions));
+}
 
-  if (img->uri.size() > 0)
-    rb_ivar_set(rimg, rb_intern("@uri"), rb_str_new2(img->uri.c_str()));
+VALUE rImage_new(const Image *img, VALUE rmodel) {
+  VALUE rimg = rb_funcall(rb_cImage, rb_intern("new"), 0);
+
+  Image_set_image_data(img, rimg);
+  rb_ivar_set(rimg, rb_intern("@model"),             rmodel);
+  rb_ivar_set(rimg, rb_intern("@name"),              rb_str_new2(img->name.c_str()));
+  rb_ivar_set(rimg, rb_intern("@mime_type"),         Qnil);
+  rb_ivar_set(rimg, rb_intern("@extras"),            rValue_new(&img->extras, rmodel));
+  rb_ivar_set(rimg, rb_intern("@buffer_view_index"), RINDEX_OR_NIL(img->bufferView));
+  rb_ivar_set(rimg, rb_intern("@extensions"),        rExtensionMap_new(&img->extensions, rmodel));
 
   if (img->mimeType.size() > 0)
     rb_ivar_set(rimg, rb_intern("@mime_type"), rb_str_new2(img->mimeType.c_str()));
 
   return rimg;
 }
+
+VALUE Image_set_uri(VALUE self, VALUE ruri) {
+  if (NIL_P(ruri)) return self;
+  const char *uri = StringValueCStr(ruri);
+  std::string str = uri;
+  if (IsDataURI(str)) {
+    std::vector<unsigned char> data;
+    std::string mime_type;
+    if (DecodeDataURI(&data, mime_type, str, strlen(uri), false)) {
+      std::string err, warn;
+      Image img;
+      rb_ivar_set(self, rb_intern("@mime_type"),  rb_str_new2(mime_type.c_str()));
+      memset(&img, 0, sizeof(img));
+      if (tinygltf::LoadImageData(&img, -1, &err, &warn, 0, 0, data.data(), (int) data.size(), NULL)) {
+        Image_set_image_data(&img, self);
+      } else {
+        rb_raise(rb_eStandardError, "Could not parse image data: %s", err.c_str());
+      }
+      if (warn.size() > 0) {
+        rb_warning("%s", warn.c_str());
+      }
+    } else {
+      rb_raise(rb_eStandardError, "Could not decode data URI");
+    }
+  }
+  return self;
+}
+
+VALUE Image_to_ptr(VALUE self) {
+  // return Fiddle::Pointer.new(addr, size)
+  VALUE rFiddlePointer = rb_const_get(rb_const_get(rb_cObject, rb_intern("Fiddle")),
+                                      rb_intern("Pointer"));
+  Image *img = Image_unwrap(self);
+  return rb_funcall(rFiddlePointer, rb_intern("new"), 2,
+                    ULL2NUM((unsigned long long) img->image.data()),
+                    ULL2NUM((unsigned long long) img->image.size()));
+}
+
+VALUE Image_size(VALUE self) {
+  return ULONG2NUM(Image_unwrap(self)->image.size());
+}
+
+VALUE Image_to_s(VALUE self) {
+  Image *img = Image_unwrap(self);
+  return rb_str_new((char *) img->image.data(), img->image.size());
+}
+
+VALUE Image_uri(VALUE self) {
+  Image *img = Image_unwrap(self);
+  if (img->uri.size() > 0)
+    return rb_str_new2(img->uri.c_str());
+  else
+    return Qnil;
+}

data/ext/tiny_gltf/rb_tiny_gltf_init.c

@@ -74,7 +74,72 @@ void Init_tiny_gltf(void) {
   DEFINE_RB_GLTF_CLASS(Scene);
   DEFINE_RB_GLTF_CLASS(Light);
 
-  rb_define_method(rb_cAccessor, "byte_stride", Accessor_byte_stride, 1);
+  /*
+   * Document-method: to_ptr
+   *
+   * Returns a Fiddle::Pointer representing the start of the buffer data in
+   * memory. For performance, try to use this rather than #to_s.
+   */
+  rb_define_method(rb_cBuffer, "to_ptr", Buffer_to_ptr, 0);
+
+  /*
+   * Document-method: size
+   *
+   * Returns the size of the buffer data in bytes.
+   */
+  rb_define_method(rb_cBuffer, "size",   Buffer_size,   0);
+
+  /*
+   * Document-method: to_s
+   *
+   * Returns a string containing the raw buffer data. For better performance,
+   * prefer #to_ptr where possible.
+   */
+  rb_define_method(rb_cBuffer, "to_s",   Buffer_to_s,   0);
+
+  /*
+   * Document-method: uri
+   *
+   * Returns the URI from which this data was retrieved, if available. Returns
+   * `nil` if a URI was not used.
+   */
+  rb_define_method(rb_cBuffer, "uri",    Buffer_uri,    0);
+
+  /*
+   * Document-method: uri=
+   */
+  rb_define_method(rb_cImage,  "uri=",   Image_set_uri, 1);
+
+  /*
+   * Document-method: to_ptr
+   *
+   * Returns a Fiddle::Pointer representing the start of the image data in
+   * memory. For performance, try to use this rather than #to_s.
+   */
+  rb_define_method(rb_cImage,  "to_ptr", Image_to_ptr,  0);
+
+  /*
+   * Document-method: size
+   *
+   * Returns the size of the image data in bytes.
+   */
+  rb_define_method(rb_cImage,  "size",   Image_size,    0);
+
+  /*
+   * Document-method: to_s
+   *
+   * Returns a string containing the raw image data. For better performance,
+   * prefer #to_ptr where possible.
+   */
+  rb_define_method(rb_cImage,  "to_s",   Image_to_s,    0);
+
+  /*
+   * Document-method: uri
+   *
+   * Returns the URI from which this data was retrieved, if available. Returns
+   * `nil` if a URI was not used.
+   */
+  rb_define_method(rb_cImage,  "uri",    Image_uri,     0);
 
   rb_eTinyGLTFError = rb_define_class_under(rb_mTinyGLTF, "Error", rb_eStandardError);
   rb_define_singleton_method(rb_mTinyGLTF, "load", rb_tgltf_load, -1);