tiny_gltf 0.1.0

data/ext/tiny_gltf/rb_tiny_gltf.cpp

@@ -0,0 +1,55 @@
+#define TINYGLTF_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "rb_tiny_gltf.h"
+
+/* call-seq: GLTF.load(filename_or_data[, base_dir]) => new Model
+ *
+ * Loads a model from the given file or data string. The data string can be
+ * ASCII or binary GLTF. `base_dir` is used to look up external dependencies
+ * such as images. If `base_dir` is omitted, it defaults to either the
+ * directory containing the file (if loading a file), or `'.'` (if loading a
+ * data string).
+ *
+ * Returns the new model, or raises an error if the model could not be loaded.
+ */
+VALUE rb_tgltf_load(int argc, VALUE *argv, VALUE self) {
+  TinyGLTF gltf;
+  VALUE rstr, rbase_dir;
+  rb_scan_args(argc, argv, "11", &rstr, &rbase_dir);
+  VALUE is_file = rb_funcall(rb_cFile, rb_intern("exist?"), 1, rstr);
+
+  if (NIL_P(rbase_dir)) {
+    if (is_file == Qtrue) {
+      rbase_dir = rb_funcall(rb_cFile, rb_intern("dirname"), 1, rstr);
+    } else {
+      rbase_dir = rb_str_new2(".");
+    }
+  }
+
+  if (is_file) {
+    VALUE rfile = rb_funcall(rb_cFile, rb_intern("open"), 2, rstr, rb_str_new2("rb"));
+    rstr = rb_funcall(rfile, rb_intern("read"), 0);
+    rb_funcall(rfile, rb_intern("close"), 0);
+  }
+
+  try {
+    Model model;
+    std::string err, warn, base_dir(StringValueCStr(rbase_dir));
+    bool res;
+    if (RSTRING_LEN(rstr) > 0 && *RSTRING_PTR(rstr) == 'g') { // 'glTF'
+      res = gltf.LoadBinaryFromMemory(&model, &err, &warn,
+                                      (unsigned char *) RSTRING_PTR(rstr), (unsigned int) RSTRING_LEN(rstr), base_dir);
+    } else {
+      res = gltf.LoadASCIIFromString( &model, &err, &warn,
+                                      RSTRING_PTR(rstr), (unsigned int) RSTRING_LEN(rstr), base_dir);
+    }
+    if (err.size()  > 0) rb_raise(rb_eTinyGLTFError, "%s", err.c_str());
+    if (warn.size() > 0) rb_raise(rb_eTinyGLTFError, "%s", warn.c_str());
+    if (!res) rb_raise(rb_eTinyGLTFError, "unknown failure to load model");
+    return rModel_new(&model);
+  } catch(const std::exception &ex) {
+    rb_raise(rb_eTinyGLTFError, "%s", ex.what());
+  }
+  return Qnil;
+}

data/ext/tiny_gltf/rb_tiny_gltf.h

@@ -0,0 +1,118 @@
+#ifndef TINY_GLTF_H
+#define TINY_GLTF_H 1
+
+#if __cplusplus
+  #include "tiny_gltf.h"
+  using namespace tinygltf;
+  extern "C" {
+#endif
+
+#include "ruby.h"
+
+void Init_tiny_gltf(void);
+VALUE rb_tgltf_load(int argc, VALUE *argv, VALUE self);
+
+extern VALUE rb_mTinyGLTF,
+             rb_eTinyGLTFError;
+
+/*
+  extern VALUE rb_cModel;
+  extern const rb_data_type_t T_Model;
+  VALUE Model_is_equal(VALUE self, VALUE other);
+  VALUE Model_alloc(VALUE klass);
+*/
+#define GLTF_TYPE(name)                                 \
+  extern VALUE rb_c ## name;                            \
+  extern const rb_data_type_t T_ ## name;               \
+  VALUE name ## _is_equal(VALUE self, VALUE other);     \
+  VALUE name ## _alloc(VALUE klass);
+
+GLTF_TYPE(Model);
+GLTF_TYPE(Accessor);
+GLTF_TYPE(Asset);
+GLTF_TYPE(Animation);
+GLTF_TYPE(AnimationSampler);
+GLTF_TYPE(AnimationChannel);
+GLTF_TYPE(Buffer);
+GLTF_TYPE(BufferView);
+GLTF_TYPE(Material);
+GLTF_TYPE(Mesh);
+GLTF_TYPE(Node);
+GLTF_TYPE(Primitive);
+GLTF_TYPE(Texture);
+GLTF_TYPE(Image);
+GLTF_TYPE(Skin);
+GLTF_TYPE(Sampler);
+GLTF_TYPE(Camera);
+GLTF_TYPE(Scene);
+GLTF_TYPE(Light);
+
+VALUE mode_to_sym(int mode);
+VALUE component_type_to_sym(int type);
+VALUE texture_filter_to_sym(int filter);
+VALUE texture_wrap_to_sym(int wrap);
+VALUE parameter_type_to_sym(int type);
+VALUE type_to_sym(int type);
+VALUE image_format_to_sym(int fmt);
+VALUE texture_format_to_sym(int fmt);
+VALUE texture_target_to_sym(int tgt);
+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);
+
+#if __cplusplus
+  /*
+    VALUE rModel_new(const Model *);
+  */
+  #define GLTF_RUBY_WRAP(klass) VALUE r ## klass ## _new(const klass *);
+
+  /*
+    static inline Model *Model_unwrap(VALUE val) {
+      Model *a = NULL;
+      TypedData_Get_Struct(val, Model, &T_Model, a);
+      if (a == NULL)
+        rb_raise(rb_eArgError, "BUG: " #name " is NULL");
+      return a;
+    }
+  */
+  #define GLTF_RUBY_UNWRAP(klass)                          \
+    static inline klass *klass ## _unwrap(VALUE val) {     \
+      klass *a = NULL;                                     \
+      TypedData_Get_Struct(val, klass, &T_ ## klass, a);   \
+      if (a == NULL)                                       \
+        rb_raise(rb_eArgError, "BUG: " #klass " is NULL"); \
+      return a;                                            \
+    }
+
+  #define GLTF_RUBY_WRAPPERS(klass) GLTF_RUBY_WRAP(klass);   \
+                                    GLTF_RUBY_UNWRAP(klass);
+
+  GLTF_RUBY_WRAP(ExtensionMap);
+  GLTF_RUBY_WRAP(ParameterMap);
+  GLTF_RUBY_WRAP(Value);
+
+  GLTF_RUBY_WRAPPERS(Asset);
+  GLTF_RUBY_WRAPPERS(Primitive);
+  GLTF_RUBY_WRAPPERS(Model);
+  GLTF_RUBY_WRAPPERS(Accessor);
+  GLTF_RUBY_WRAPPERS(Animation);
+  GLTF_RUBY_WRAPPERS(AnimationSampler);
+  GLTF_RUBY_WRAPPERS(AnimationChannel);
+  GLTF_RUBY_WRAPPERS(Buffer);
+  GLTF_RUBY_WRAPPERS(BufferView);
+  GLTF_RUBY_WRAPPERS(Material);
+  GLTF_RUBY_WRAPPERS(Mesh);
+  GLTF_RUBY_WRAPPERS(Node);
+  GLTF_RUBY_WRAPPERS(Texture);
+  GLTF_RUBY_WRAPPERS(Image);
+  GLTF_RUBY_WRAPPERS(Skin);
+  GLTF_RUBY_WRAPPERS(Sampler);
+  GLTF_RUBY_WRAPPERS(Camera);
+  GLTF_RUBY_WRAPPERS(Scene);
+  GLTF_RUBY_WRAPPERS(Light);
+}
+#endif
+
+#endif /* TINY_GLTF_H */

data/ext/tiny_gltf/rb_tiny_gltf_accessor.cpp

@@ -0,0 +1,42 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rAccessor_new(const Accessor *accessor) {
+  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("@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("@min"),               Qnil);
+  rb_ivar_set(raccessor, rb_intern("@max"),               Qnil);
+
+  if (accessor->minValues.size() > 0) {
+    VALUE ary = rb_ary_new();
+    for (size_t i = 0; i < accessor->minValues.size(); i++)
+      rb_ary_push(ary, DBL2NUM(accessor->minValues[i]));
+    rb_ivar_set(raccessor, rb_intern("@min"), ary);
+  }
+
+  if (accessor->maxValues.size() > 0) {
+    VALUE ary = rb_ary_new();
+    for (size_t i = 0; i < accessor->maxValues.size(); i++)
+      rb_ary_push(ary, DBL2NUM(accessor->maxValues[i]));
+    rb_ivar_set(raccessor, rb_intern("@max"), ary);
+  }
+
+  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

@@ -0,0 +1,21 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rAnimation_new(const Animation *animation) {
+  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]));
+
+  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_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));
+
+  return ranimation;
+}

data/ext/tiny_gltf/rb_tiny_gltf_animation_channel.cpp

@@ -0,0 +1,13 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rAnimationChannel_new(const AnimationChannel *animation_channel) {
+  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));
+
+  return ranimation_channel;
+}

data/ext/tiny_gltf/rb_tiny_gltf_animation_sampler.cpp

@@ -0,0 +1,16 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rAnimationSampler_new(const AnimationSampler *animation_sampler) {
+  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));
+
+  return ranimation_sampler;
+}

data/ext/tiny_gltf/rb_tiny_gltf_asset.cpp

@@ -0,0 +1,15 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rAsset_new(const Asset *asset) {
+  VALUE rasset = rb_funcall(rb_cAsset, rb_intern("new"), 0);
+  // *Asset_unwrap(rasset) = *asset;
+
+  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));
+  
+  return rasset;
+}

data/ext/tiny_gltf/rb_tiny_gltf_buffer.cpp

@@ -0,0 +1,16 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rBuffer_new(const Buffer *buf) {
+  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));
+
+  if (buf->uri.size() > 0)
+    rb_ivar_set(rbuf, rb_intern("@uri"),  rb_str_new2(buf->uri.c_str()));
+
+  return rbuf;
+}

data/ext/tiny_gltf/rb_tiny_gltf_buffer_view.cpp

@@ -0,0 +1,16 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rBufferView_new(const BufferView *view) {
+  VALUE rbuf = rb_funcall(rb_cBufferView, rb_intern("new"), 0);
+  *BufferView_unwrap(rbuf) = *view;
+
+  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("@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));
+
+  return rbuf;
+}

data/ext/tiny_gltf/rb_tiny_gltf_camera.cpp

@@ -0,0 +1,29 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rCamera_new(const Camera *camera) {
+  VALUE rcamera = rb_funcall(rb_cCamera, rb_intern("new"), 0);
+  // *Camera_unwrap(rcamera) = *camera;
+
+  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));
+
+  if (!strcmp(camera->type.c_str(), "perspective")) {
+    rb_ivar_set(rcamera, rb_intern("@aspect_ratio"), DBL2NUM(camera->perspective.aspectRatio));
+    rb_ivar_set(rcamera, rb_intern("@yfov"),         DBL2NUM(camera->perspective.yfov));
+    rb_ivar_set(rcamera, rb_intern("@znear"),        DBL2NUM(camera->perspective.znear));
+    if (camera->perspective.zfar == 0.0)
+      rb_ivar_set(rcamera, rb_intern("@zfar"), rb_const_get(rb_cFloat, rb_intern("INFINITY")));
+    else
+      rb_ivar_set(rcamera, rb_intern("@zfar"), DBL2NUM(camera->perspective.zfar));
+  } else {
+    rb_ivar_set(rcamera, rb_intern("@xmag"),  DBL2NUM(camera->orthographic.xmag));
+    rb_ivar_set(rcamera, rb_intern("@ymag"),  DBL2NUM(camera->orthographic.ymag));
+    rb_ivar_set(rcamera, rb_intern("@znear"), DBL2NUM(camera->orthographic.znear));
+    rb_ivar_set(rcamera, rb_intern("@zfar"),  DBL2NUM(camera->orthographic.zfar));
+  }
+
+  return rcamera;
+}
+

data/ext/tiny_gltf/rb_tiny_gltf_extension_map.cpp

@@ -0,0 +1,12 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rExtensionMap_new(const ExtensionMap *value) {
+  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));
+  }
+
+  return res;
+}

data/ext/tiny_gltf/rb_tiny_gltf_image.cpp

@@ -0,0 +1,25 @@
+#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;
+
+  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()));
+
+  if (img->mimeType.size() > 0)
+    rb_ivar_set(rimg, rb_intern("@mime_type"), rb_str_new2(img->mimeType.c_str()));
+
+  return rimg;
+}

data/ext/tiny_gltf/rb_tiny_gltf_init.c

@@ -0,0 +1,81 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rb_mTinyGLTF,
+      rb_eTinyGLTFError,
+      rb_cModel,
+      rb_cAccessor,
+      rb_cAsset,
+      rb_cAnimation,
+      rb_cAnimationChannel,
+      rb_cAnimationSampler,
+      rb_cBuffer,
+      rb_cBufferView,
+      rb_cMaterial,
+      rb_cMesh,
+      rb_cNode,
+      rb_cPrimitive,
+      rb_cTexture,
+      rb_cImage,
+      rb_cSkin,
+      rb_cSampler,
+      rb_cCamera,
+      rb_cScene,
+      rb_cLight;
+
+void Init_tiny_gltf(void) {
+  rb_mTinyGLTF = rb_define_module("TinyGLTF");
+
+  // not part of the macro below just to help the yardoc parser out
+  rb_cModel            = rb_define_class_under(rb_mTinyGLTF, "Model",            rb_cObject);
+  rb_cAccessor         = rb_define_class_under(rb_mTinyGLTF, "Accessor",         rb_cObject);
+  rb_cAsset            = rb_define_class_under(rb_mTinyGLTF, "Asset",            rb_cObject);
+  rb_cAnimation        = rb_define_class_under(rb_mTinyGLTF, "Animation",        rb_cObject);
+  rb_cAnimationChannel = rb_define_class_under(rb_mTinyGLTF, "AnimationChannel", rb_cObject);
+  rb_cAnimationSampler = rb_define_class_under(rb_mTinyGLTF, "AnimationSampler", rb_cObject);
+  rb_cBuffer           = rb_define_class_under(rb_mTinyGLTF, "Buffer",           rb_cObject);
+  rb_cBufferView       = rb_define_class_under(rb_mTinyGLTF, "BufferView",       rb_cObject);
+  rb_cMaterial         = rb_define_class_under(rb_mTinyGLTF, "Material",         rb_cObject);
+  rb_cMesh             = rb_define_class_under(rb_mTinyGLTF, "Mesh",             rb_cObject);
+  rb_cNode             = rb_define_class_under(rb_mTinyGLTF, "Node",             rb_cObject);
+  rb_cTexture          = rb_define_class_under(rb_mTinyGLTF, "Texture",          rb_cObject);
+  rb_cImage            = rb_define_class_under(rb_mTinyGLTF, "Image",            rb_cObject);
+  rb_cPrimitive        = rb_define_class_under(rb_mTinyGLTF, "Primitive",        rb_cObject);
+  rb_cSkin             = rb_define_class_under(rb_mTinyGLTF, "Skin",             rb_cObject);
+  rb_cSampler          = rb_define_class_under(rb_mTinyGLTF, "Sampler",          rb_cObject);
+  rb_cCamera           = rb_define_class_under(rb_mTinyGLTF, "Camera",           rb_cObject);
+  rb_cScene            = rb_define_class_under(rb_mTinyGLTF, "Scene",            rb_cObject);
+  rb_cLight            = rb_define_class_under(rb_mTinyGLTF, "Light",            rb_cObject);
+
+  /*
+    rb_define_alloc_func(rb_cModel, Model_alloc);
+    rb_define_method(rb_cModel, "==", Model_is_equal, 1);
+  */
+  #define DEFINE_RB_GLTF_CLASS(name)                                         \
+    rb_define_alloc_func(rb_c ## name, name ## _alloc);                      \
+    rb_define_method(rb_c ## name, "==", name ## _is_equal, 1);
+
+  DEFINE_RB_GLTF_CLASS(Model);
+  DEFINE_RB_GLTF_CLASS(Accessor);
+  DEFINE_RB_GLTF_CLASS(Asset);
+  DEFINE_RB_GLTF_CLASS(Animation);
+  DEFINE_RB_GLTF_CLASS(AnimationChannel);
+  DEFINE_RB_GLTF_CLASS(AnimationSampler);
+  DEFINE_RB_GLTF_CLASS(Buffer);
+  DEFINE_RB_GLTF_CLASS(BufferView);
+  DEFINE_RB_GLTF_CLASS(Material);
+  DEFINE_RB_GLTF_CLASS(Mesh);
+  DEFINE_RB_GLTF_CLASS(Node);
+  DEFINE_RB_GLTF_CLASS(Texture);
+  DEFINE_RB_GLTF_CLASS(Image);
+  DEFINE_RB_GLTF_CLASS(Primitive);
+  DEFINE_RB_GLTF_CLASS(Skin);
+  DEFINE_RB_GLTF_CLASS(Sampler);
+  DEFINE_RB_GLTF_CLASS(Camera);
+  DEFINE_RB_GLTF_CLASS(Scene);
+  DEFINE_RB_GLTF_CLASS(Light);
+
+  rb_define_method(rb_cAccessor, "byte_stride", Accessor_byte_stride, 1);
+
+  rb_eTinyGLTFError = rb_define_class_under(rb_mTinyGLTF, "Error", rb_eStandardError);
+  rb_define_singleton_method(rb_mTinyGLTF, "load", rb_tgltf_load, -1);
+}