tiny_gltf 0.1.0

data/ext/tiny_gltf/rb_tiny_gltf_light.cpp

@@ -0,0 +1,16 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rLight_new(const Light *light) {
+  VALUE rlight = rb_funcall(rb_cLight, rb_intern("new"), 0);
+  // *Light_unwrap(rlight) = *light;
+
+  VALUE rcolor = rb_ary_new();
+  for (size_t i = 0; i < light->color.size(); i++)
+    rb_ary_push(rcolor, DBL2NUM(light->color[i]));
+
+  rb_ivar_set(rlight, rb_intern("@name"),  rb_str_new2(light->name.c_str()));
+  rb_ivar_set(rlight, rb_intern("@type"),  rb_intern(light->type.c_str()));
+  rb_ivar_set(rlight, rb_intern("@color"), rcolor);
+
+  return rlight;
+}

data/ext/tiny_gltf/rb_tiny_gltf_material.cpp

@@ -0,0 +1,14 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rMaterial_new(const Material *matr) {
+  VALUE rmatr = rb_funcall(rb_cMaterial, rb_intern("new"), 0);
+  // *Material_unwrap(rmatr) = *matr;
+
+  rb_ivar_set(rmatr, rb_intern("@name"),              rb_str_new2(matr->name.c_str()));
+  rb_ivar_set(rmatr, rb_intern("@values"),            rParameterMap_new(&matr->values));
+  rb_ivar_set(rmatr, rb_intern("@additional_values"), rParameterMap_new(&matr->additionalValues));
+  rb_ivar_set(rmatr, rb_intern("@extensions"),        rExtensionMap_new(&matr->extensions));
+  rb_ivar_set(rmatr, rb_intern("@extras"),            rValue_new(&matr->extras));
+
+  return rmatr;
+}

data/ext/tiny_gltf/rb_tiny_gltf_mesh.cpp

@@ -0,0 +1,37 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rMesh_new(const Mesh *mesh) {
+  VALUE rmesh = rb_funcall(rb_cMesh, rb_intern("new"), 0);
+  // *Mesh_unwrap(rmesh) = *mesh;
+
+  VALUE rtargets = rb_ary_new();
+  for (size_t i = 0; i < mesh->targets.size(); i++) {
+    VALUE rtarget = rb_hash_new();
+    rb_ary_push(rtargets, rtarget);
+    for (std::map<std::string, int>::const_iterator it = mesh->targets[i].begin();
+         it != mesh->targets[i].end(); ++it) {
+      std::string key = it->first;
+      std::transform(key.begin(), key.end(), key.begin(), ::tolower);
+      rb_hash_aset(rtarget, ID2SYM(rb_intern(key.c_str())), INT2NUM(it->second));
+    }
+  }
+
+  VALUE rprimitives = rb_ary_new();
+  for (size_t i = 0; i < mesh->primitives.size(); i++) {
+    rb_ary_push(rprimitives, rPrimitive_new(&mesh->primitives[i]));
+  }
+
+  VALUE rweights = rb_ary_new();
+  for (size_t i = 0; i < mesh->weights.size(); i++) {
+    rb_ary_push(rprimitives, DBL2NUM(mesh->weights[i]));
+  }
+
+  rb_ivar_set(rmesh, rb_intern("@name"),           rb_str_new2(mesh->name.c_str()));
+  rb_ivar_set(rmesh, rb_intern("@primitives"),     rprimitives);
+  rb_ivar_set(rmesh, rb_intern("@weights"),        rweights);
+  rb_ivar_set(rmesh, rb_intern("@extensions"),     rExtensionMap_new(&mesh->extensions));
+  rb_ivar_set(rmesh, rb_intern("@morph_targets"),  rtargets);
+  rb_ivar_set(rmesh, rb_intern("@extras"),         rValue_new(&mesh->extras));
+
+  return rmesh;
+}

data/ext/tiny_gltf/rb_tiny_gltf_model.cpp

@@ -0,0 +1,52 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rModel_new(const Model *model) {
+  VALUE rmodel = rb_funcall(rb_cModel, rb_intern("new"), 0);
+  // *Model_unwrap(rmodel) = *model;
+
+  VALUE rext_used = rb_ary_new();
+  for (size_t i = 0; i < model->extensionsUsed.size(); i++)
+    rb_ary_push(rext_used, rb_str_new2(model->extensionsUsed[i].c_str()));
+
+  VALUE rext_required = rb_ary_new();
+  for (size_t i = 0; i < model->extensionsRequired.size(); i++)
+    rb_ary_push(rext_required, rb_str_new2(model->extensionsRequired[i].c_str()));
+
+  rb_ivar_set(rmodel, rb_intern("@asset"),               rAsset_new(&model->asset));
+  rb_ivar_set(rmodel, rb_intern("@default_scene_index"), INT2NUM(model->defaultScene));
+  rb_ivar_set(rmodel, rb_intern("@extensions"),          rExtensionMap_new(&model->extensions));
+  rb_ivar_set(rmodel, rb_intern("@extras"),              rValue_new(&model->extras));
+  rb_ivar_set(rmodel, rb_intern("@extensions_used"),     rext_used);
+  rb_ivar_set(rmodel, rb_intern("@extensions_required"), rext_required);
+
+  /*
+    VALUE ary = rb_funcall(rmodel, rb_intern("accessors"), 0);
+    for (size_t i = 0; i < model->accessors.size(); i++) {
+      rb_ary_push(ary, rAccessor_new(&model->accessors[i]));
+    }
+  */
+  #define CONCAT_VECTOR_TO_RARRAY3(klass, name, method) {    \
+    VALUE ary = rb_funcall(rmodel, rb_intern(method), 0);    \
+    for (size_t i = 0; i < model->name.size(); i++) {        \
+      rb_ary_push(ary, r ## klass ## _new(&model->name[i])); \
+    }                                                        \
+  }
+  #define CONCAT_VECTOR_TO_RARRAY(klass, name) CONCAT_VECTOR_TO_RARRAY3(klass, name, #name)
+
+  CONCAT_VECTOR_TO_RARRAY(Accessor,    accessors);
+  CONCAT_VECTOR_TO_RARRAY(Animation,   animations);
+  CONCAT_VECTOR_TO_RARRAY(Buffer,      buffers);
+  CONCAT_VECTOR_TO_RARRAY3(BufferView, bufferViews, "buffer_views");
+  CONCAT_VECTOR_TO_RARRAY(Material,    materials);
+  CONCAT_VECTOR_TO_RARRAY(Mesh,        meshes);
+  CONCAT_VECTOR_TO_RARRAY(Node,        nodes);
+  CONCAT_VECTOR_TO_RARRAY(Texture,     textures);
+  CONCAT_VECTOR_TO_RARRAY(Image,       images);
+  CONCAT_VECTOR_TO_RARRAY(Skin,        skins);
+  CONCAT_VECTOR_TO_RARRAY(Sampler,     samplers);
+  CONCAT_VECTOR_TO_RARRAY(Camera,      cameras);
+  CONCAT_VECTOR_TO_RARRAY(Scene,       scenes);
+  CONCAT_VECTOR_TO_RARRAY(Light,       lights);
+
+  return rmodel;
+}

data/ext/tiny_gltf/rb_tiny_gltf_node.cpp

@@ -0,0 +1,67 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rNode_new(const Node *node) {
+  VALUE rnode = rb_funcall(rb_cNode, rb_intern("new"), 0);
+  // *Node_unwrap(rnode) = *node;
+
+  VALUE rweights = rb_ary_new();
+  for (size_t i = 0; i < node->weights.size(); i++)
+    rb_ary_push(rweights, DBL2NUM(node->weights[i]));
+
+  VALUE rchildren = rb_ary_new();
+  for (size_t i = 0; i < node->children.size(); i++)
+    rb_ary_push(rchildren, INT2NUM(node->children[i]));
+
+  VALUE rmatrix = Qnil, rrotation = Qnil, rtranslation = Qnil, rscale = Qnil;
+  if (node->matrix.size() == 0) {
+    rrotation = rb_ary_new();
+    if (node->rotation.size() == 0) {
+      rb_ary_push(rrotation, INT2NUM(0));
+      rb_ary_push(rrotation, INT2NUM(0));
+      rb_ary_push(rrotation, INT2NUM(0));
+      rb_ary_push(rrotation, INT2NUM(1));
+    } else {
+      for (size_t i = 0; i < node->rotation.size(); i++)
+        rb_ary_push(rrotation, INT2NUM(node->rotation[i]));
+    }
+
+    rscale = rb_ary_new();
+    if (node->rotation.size() == 0) {
+      rb_ary_push(rscale, INT2NUM(0));
+      rb_ary_push(rscale, INT2NUM(0));
+      rb_ary_push(rscale, INT2NUM(0));
+    } else {
+      for (size_t i = 0; i < node->scale.size(); i++)
+        rb_ary_push(rscale, INT2NUM(node->scale[i]));
+    }
+
+    rtranslation = rb_ary_new();
+    if (node->translation.size() == 0) {
+      rb_ary_push(rtranslation, INT2NUM(0));
+      rb_ary_push(rtranslation, INT2NUM(0));
+      rb_ary_push(rtranslation, INT2NUM(0));
+    } else {
+      for (size_t i = 0; i < node->translation.size(); i++)
+        rb_ary_push(rtranslation, INT2NUM(node->translation[i]));
+    }
+  } else {
+    rmatrix = rb_ary_new();
+    for (size_t i = 0; i < node->matrix.size(); i++)
+      rb_ary_push(rmatrix, INT2NUM(node->matrix[i]));
+  }
+
+  rb_ivar_set(rnode, rb_intern("@name"),             rb_str_new2(node->name.c_str()));
+  rb_ivar_set(rnode, rb_intern("@camera_index"),     INT2NUM(node->camera));
+  rb_ivar_set(rnode, rb_intern("@skin_index"),       INT2NUM(node->skin));
+  rb_ivar_set(rnode, rb_intern("@mesh_index"),       INT2NUM(node->mesh));
+  rb_ivar_set(rnode, rb_intern("@children_indices"), rchildren);
+  rb_ivar_set(rnode, rb_intern("@rotation"),         rrotation);
+  rb_ivar_set(rnode, rb_intern("@translation"),      rtranslation);
+  rb_ivar_set(rnode, rb_intern("@scale"),            rscale);
+  rb_ivar_set(rnode, rb_intern("@matrix"),           rmatrix);
+  rb_ivar_set(rnode, rb_intern("@weights"),          rweights);
+  rb_ivar_set(rnode, rb_intern("@extensions"),       rExtensionMap_new(&node->extensions));
+  rb_ivar_set(rnode, rb_intern("@extras"),           rValue_new(&node->extras));
+
+  return rnode;
+}

data/ext/tiny_gltf/rb_tiny_gltf_parameter_map.cpp

@@ -0,0 +1,39 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rParameterMap_new(const ParameterMap *value) {
+  VALUE res = Qnil;
+
+  for (ParameterMap::const_iterator paramIt = value->begin(); paramIt != value->end();
+       ++paramIt) {
+    if (NIL_P(res)) res = rb_hash_new();
+    VALUE key = ID2SYM(rb_intern(paramIt->first.c_str()));
+    VALUE val = Qnil;
+
+    if (paramIt->second.number_array.size()) {
+      val = rb_ary_new();
+      for (size_t i = 0; i < paramIt->second.number_array.size(); i++)
+        rb_ary_push(val, DBL2NUM(paramIt->second.number_array[i]));
+    } else if (paramIt->second.json_double_value.size()) {
+      val = rb_hash_new();
+      for (std::map<std::string, double>::const_iterator it =
+               paramIt->second.json_double_value.begin();
+           it != paramIt->second.json_double_value.end(); ++it) {
+        if (it->first == "index") {
+          rb_hash_aset(val, ID2SYM(rb_intern("index")), INT2NUM(paramIt->second.TextureIndex()));
+        } else {
+          rb_hash_aset(val, ID2SYM(rb_intern(it->first.c_str())), DBL2NUM(it->second));
+        }
+      }
+    } else if (!paramIt->second.string_value.empty()) {
+      val = rb_str_new2(paramIt->second.string_value.c_str());
+    } else if (paramIt->second.has_number_value) {
+      val = DBL2NUM(paramIt->second.number_value);
+    } else {
+      val = paramIt->second.bool_value ? Qtrue : Qfalse;
+    }
+
+    rb_hash_aset(res, key, val);
+  }
+
+  return res;
+}

data/ext/tiny_gltf/rb_tiny_gltf_primitive.cpp

@@ -0,0 +1,35 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rPrimitive_new(const Primitive *prim) {
+  VALUE rprim = rb_funcall(rb_cPrimitive, rb_intern("new"), 0);
+  // *Primitive_unwrap(rprim) = *prim;
+
+  VALUE rattrs = rb_hash_new();
+  for (std::map<std::string, int>::const_iterator it = prim->attributes.begin();
+       it != prim->attributes.end(); ++it) {
+    std::string key = it->first;
+    std::transform(key.begin(), key.end(), key.begin(), ::tolower);
+    rb_hash_aset(rattrs, ID2SYM(rb_intern(key.c_str())), INT2NUM(it->second));
+  }
+
+  VALUE rtargets = rb_ary_new();
+  for (size_t i = 0; i < prim->targets.size(); i++) {
+    VALUE rtarget = rb_hash_new();
+    rb_ary_push(rtargets, rtarget);
+    for (std::map<std::string, int>::const_iterator it = prim->targets[i].begin();
+         it != prim->targets[i].end(); ++it) {
+      std::string key = it->first;
+      std::transform(key.begin(), key.end(), key.begin(), ::tolower);
+      rb_hash_aset(rtarget, ID2SYM(rb_intern(key.c_str())), INT2NUM(it->second));
+    }
+  }
+
+  rb_ivar_set(rprim, rb_intern("@attributes"),     rattrs);
+  rb_ivar_set(rprim, rb_intern("@material_index"), INT2NUM(prim->material));
+  rb_ivar_set(rprim, rb_intern("@indices"),        INT2NUM(prim->indices));
+  rb_ivar_set(rprim, rb_intern("@mode"),           mode_to_sym(prim->mode));
+  rb_ivar_set(rprim, rb_intern("@morph_targets"),  rtargets);
+  rb_ivar_set(rprim, rb_intern("@extras"),         rValue_new(&prim->extras));
+
+  return rprim;
+}

data/ext/tiny_gltf/rb_tiny_gltf_sampler.cpp

@@ -0,0 +1,16 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rSampler_new(const Sampler *sampler) {
+  VALUE rsampler = rb_funcall(rb_cSampler, rb_intern("new"), 0);
+  // *Sampler_unwrap(rsampler) = *sampler;
+
+  rb_ivar_set(rsampler, rb_intern("@name"),       rb_str_new2(sampler->name.c_str()));
+  rb_ivar_set(rsampler, rb_intern("@min_filter"), texture_filter_to_sym(sampler->minFilter));
+  rb_ivar_set(rsampler, rb_intern("@mag_filter"), texture_filter_to_sym(sampler->magFilter));
+  rb_ivar_set(rsampler, rb_intern("@wrap_s"),     texture_wrap_to_sym(sampler->wrapS));
+  rb_ivar_set(rsampler, rb_intern("@wrap_t"),     texture_wrap_to_sym(sampler->wrapT));
+  rb_ivar_set(rsampler, rb_intern("@wrap_r"),     texture_wrap_to_sym(sampler->wrapR));
+  rb_ivar_set(rsampler, rb_intern("@extras"),     rValue_new(&sampler->extras));
+
+  return rsampler;
+}

data/ext/tiny_gltf/rb_tiny_gltf_scene.cpp

@@ -0,0 +1,17 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rScene_new(const Scene *scene) {
+  VALUE rscene = rb_funcall(rb_cScene, rb_intern("new"), 0);
+  // *Scene_unwrap(rscene) = *scene;
+
+  VALUE rnodes = rb_ary_new();
+  for (size_t i = 0; i < scene->nodes.size(); i++)
+    rb_ary_push(rnodes, INT2NUM(scene->nodes[i]));
+
+  rb_ivar_set(rscene, rb_intern("@name"),              rb_str_new2(scene->name.c_str()));
+  rb_ivar_set(rscene, rb_intern("@nodes"),             rnodes);
+  rb_ivar_set(rscene, rb_intern("@extensions"),        rExtensionMap_new(&scene->extensions));
+  rb_ivar_set(rscene, rb_intern("@extras"),            rValue_new(&scene->extras));
+
+  return rscene;
+}

data/ext/tiny_gltf/rb_tiny_gltf_skin.cpp

@@ -0,0 +1,17 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rSkin_new(const Skin *skin) {
+  VALUE rskin = rb_funcall(rb_cSkin, rb_intern("new"), 0);
+  // *Skin_unwrap(rskin) = *skin;
+
+  VALUE rjoints = rb_ary_new();
+  for (size_t i = 0; i < skin->joints.size(); i++)
+    rb_ary_push(rjoints, INT2NUM(skin->joints[i]));
+
+  rb_ivar_set(rskin, rb_intern("@name"),                     rb_str_new2(skin->name.c_str()));
+  rb_ivar_set(rskin, rb_intern("@inverse_bind_matrices"),    INT2NUM(skin->inverseBindMatrices));
+  rb_ivar_set(rskin, rb_intern("@skeleton_root_node_index"), INT2NUM(skin->skeleton));
+  rb_ivar_set(rskin, rb_intern("@joints"),                   rjoints);
+
+  return rskin;
+}

data/ext/tiny_gltf/rb_tiny_gltf_texture.cpp

@@ -0,0 +1,14 @@
+#include "rb_tiny_gltf.h"
+
+VALUE rTexture_new(const Texture *texture) {
+  VALUE rtexture = rb_funcall(rb_cTexture, rb_intern("new"), 0);
+  // *Texture_unwrap(rtexture) = *texture;
+
+  rb_ivar_set(rtexture, rb_intern("@name"),              rb_str_new2(texture->name.c_str()));
+  rb_ivar_set(rtexture, rb_intern("@sampler_index"),     INT2NUM(texture->sampler));
+  rb_ivar_set(rtexture, rb_intern("@source_index"),      INT2NUM(texture->source));
+  rb_ivar_set(rtexture, rb_intern("@extensions"),        rExtensionMap_new(&texture->extensions));
+  rb_ivar_set(rtexture, rb_intern("@extras"),            rValue_new(&texture->extras));
+
+  return rtexture;
+}

data/ext/tiny_gltf/rb_tiny_gltf_types.cpp

@@ -0,0 +1,229 @@
+#include "rb_tiny_gltf.h"
+
+/*
+  void model_free(void* data) {
+    Model *model = (Model *) data;
+    delete model;
+  }
+
+  size_t model_size(const void* data) {
+    return sizeof(Model);
+  }
+
+  static const rb_data_type_t T_Model = {
+    .wrap_struct_name = "TinyGLTFModel",
+    .function = {
+      .dmark = NULL,
+      .dfree = model_free,
+      .dsize = model_size,
+      .reserved = { 0, 0 }
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+  };
+
+  VALUE alloc_model(VALUE klass) {
+    return TypedData_Wrap_Struct(klass, &T_Model, new Model());
+  }
+
+  VALUE Model_is_equal(VALUE self, VALUE other) {
+    Model *a, *b;
+    TypedData_Get_Struct(self,  Model, &T_Model, a);
+    TypedData_Get_Struct(other, Model, &T_Model, b);
+    return (*a) == (*b) ? Qtrue : Qfalse;
+  }
+*/
+#define DEFN_GLTF_TYPE(klass)                                       \
+  void klass ## _free(void* data) {                                 \
+    klass *obj = (klass *) data;                                    \
+    delete obj;                                                     \
+  }                                                                 \
+                                                                    \
+  size_t klass ## _size(const void* data) {                         \
+    return sizeof(klass);                                           \
+  }                                                                 \
+                                                                    \
+  const rb_data_type_t T_ ## klass = {                              \
+    .wrap_struct_name = "TinyGLTF" #klass,                          \
+    .function = {                                                   \
+      .dmark = NULL,                                                \
+      .dfree = klass ## _free,                                      \
+      .dsize = klass ## _size,                                      \
+      .reserved = { 0, 0 }                                          \
+    },                                                              \
+    .parent = NULL,                                                 \
+    .data = NULL,                                                   \
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY                            \
+  };                                                                \
+                                                                    \
+  VALUE klass ## _alloc(VALUE k) {                                  \
+    return TypedData_Wrap_Struct(k, &T_ ## klass, new klass());     \
+  }                                                                 \
+                                                                    \
+  VALUE klass ## _is_equal(VALUE self, VALUE other) {               \
+    klass *a, *b;                                                   \
+    TypedData_Get_Struct(self,  klass, &T_ ## klass, a);            \
+    TypedData_Get_Struct(other, klass, &T_ ## klass, b);            \
+    return (*a) == (*b) ? Qtrue : Qfalse;                           \
+  }
+
+DEFN_GLTF_TYPE(Model);
+DEFN_GLTF_TYPE(Asset);
+DEFN_GLTF_TYPE(Accessor);
+DEFN_GLTF_TYPE(Animation);
+DEFN_GLTF_TYPE(AnimationChannel);
+DEFN_GLTF_TYPE(AnimationSampler);
+DEFN_GLTF_TYPE(Buffer);
+DEFN_GLTF_TYPE(BufferView);
+DEFN_GLTF_TYPE(Material);
+DEFN_GLTF_TYPE(Mesh);
+DEFN_GLTF_TYPE(Node);
+DEFN_GLTF_TYPE(Primitive);
+DEFN_GLTF_TYPE(Texture);
+DEFN_GLTF_TYPE(Image);
+DEFN_GLTF_TYPE(Skin);
+DEFN_GLTF_TYPE(Sampler);
+DEFN_GLTF_TYPE(Camera);
+DEFN_GLTF_TYPE(Scene);
+DEFN_GLTF_TYPE(Light);
+
+VALUE mode_to_sym(int mode) {
+  switch(mode) {
+    case TINYGLTF_MODE_POINTS:         return ID2SYM(rb_intern("points"));
+    case TINYGLTF_MODE_LINE:           return ID2SYM(rb_intern("line"));
+    case TINYGLTF_MODE_LINE_LOOP:      return ID2SYM(rb_intern("line_loop"));
+    case TINYGLTF_MODE_TRIANGLES:      return ID2SYM(rb_intern("triangles"));
+    case TINYGLTF_MODE_TRIANGLE_STRIP: return ID2SYM(rb_intern("triangle_strip"));
+    case TINYGLTF_MODE_TRIANGLE_FAN:   return ID2SYM(rb_intern("triangle_fan"));
+    default:                           return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE component_type_to_sym(int type) {
+  switch(type) {
+    case TINYGLTF_COMPONENT_TYPE_BYTE:           return ID2SYM(rb_intern("byte"));
+    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:  return ID2SYM(rb_intern("ubyte"));
+    case TINYGLTF_COMPONENT_TYPE_SHORT:          return ID2SYM(rb_intern("short"));
+    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT: return ID2SYM(rb_intern("ushort"));
+    case TINYGLTF_COMPONENT_TYPE_INT:            return ID2SYM(rb_intern("int"));
+    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:   return ID2SYM(rb_intern("uint"));
+    case TINYGLTF_COMPONENT_TYPE_FLOAT:          return ID2SYM(rb_intern("float"));
+    case TINYGLTF_COMPONENT_TYPE_DOUBLE:         return ID2SYM(rb_intern("double"));
+    default:                                     return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE texture_filter_to_sym(int filter) {
+  switch(filter) {
+    case TINYGLTF_TEXTURE_FILTER_NEAREST:                return ID2SYM(rb_intern("nearest"));
+    case TINYGLTF_TEXTURE_FILTER_LINEAR:                 return ID2SYM(rb_intern("linear"));
+    case TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST: return ID2SYM(rb_intern("nearest_mipmap_nearest"));
+    case TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST:  return ID2SYM(rb_intern("linear_mipmap_nearest"));
+    case TINYGLTF_TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR:  return ID2SYM(rb_intern("nearest_mipmap_linear"));
+    case TINYGLTF_TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR:   return ID2SYM(rb_intern("linear_mipmap_linear"));
+    default:                                             return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE texture_wrap_to_sym(int wrap) {
+  switch(wrap) {
+    case TINYGLTF_TEXTURE_WRAP_REPEAT:          return ID2SYM(rb_intern("repeat"));
+    case TINYGLTF_TEXTURE_WRAP_CLAMP_TO_EDGE:   return ID2SYM(rb_intern("clamp_to_edge"));
+    case TINYGLTF_TEXTURE_WRAP_MIRRORED_REPEAT: return ID2SYM(rb_intern("mirrored_repeat"));
+    default:                                    return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE parameter_type_to_sym(int type) {
+  switch(type) {
+    case TINYGLTF_PARAMETER_TYPE_BYTE:           return ID2SYM(rb_intern("byte"));
+    case TINYGLTF_PARAMETER_TYPE_UNSIGNED_BYTE:  return ID2SYM(rb_intern("ubyte"));
+    case TINYGLTF_PARAMETER_TYPE_SHORT:          return ID2SYM(rb_intern("short"));
+    case TINYGLTF_PARAMETER_TYPE_UNSIGNED_SHORT: return ID2SYM(rb_intern("ushort"));
+    case TINYGLTF_PARAMETER_TYPE_INT:            return ID2SYM(rb_intern("int"));
+    case TINYGLTF_PARAMETER_TYPE_UNSIGNED_INT:   return ID2SYM(rb_intern("uint"));
+    case TINYGLTF_PARAMETER_TYPE_FLOAT:          return ID2SYM(rb_intern("float"));
+    case TINYGLTF_PARAMETER_TYPE_FLOAT_VEC2:     return ID2SYM(rb_intern("float_vec2"));
+    case TINYGLTF_PARAMETER_TYPE_FLOAT_VEC3:     return ID2SYM(rb_intern("float_vec3"));
+    case TINYGLTF_PARAMETER_TYPE_FLOAT_VEC4:     return ID2SYM(rb_intern("float_vec4"));
+    case TINYGLTF_PARAMETER_TYPE_INT_VEC2:       return ID2SYM(rb_intern("int_vec2"));
+    case TINYGLTF_PARAMETER_TYPE_INT_VEC3:       return ID2SYM(rb_intern("int_vec3"));
+    case TINYGLTF_PARAMETER_TYPE_INT_VEC4:       return ID2SYM(rb_intern("int_vec4"));
+    case TINYGLTF_PARAMETER_TYPE_BOOL:           return ID2SYM(rb_intern("bool"));
+    case TINYGLTF_PARAMETER_TYPE_BOOL_VEC2:      return ID2SYM(rb_intern("bool_vec2"));
+    case TINYGLTF_PARAMETER_TYPE_BOOL_VEC3:      return ID2SYM(rb_intern("bool_vec3"));
+    case TINYGLTF_PARAMETER_TYPE_BOOL_VEC4:      return ID2SYM(rb_intern("bool_vec4"));
+    case TINYGLTF_PARAMETER_TYPE_FLOAT_MAT2:     return ID2SYM(rb_intern("float_mat2"));
+    case TINYGLTF_PARAMETER_TYPE_FLOAT_MAT3:     return ID2SYM(rb_intern("float_mat3"));
+    case TINYGLTF_PARAMETER_TYPE_FLOAT_MAT4:     return ID2SYM(rb_intern("float_mat4"));
+    case TINYGLTF_PARAMETER_TYPE_SAMPLER_2D:     return ID2SYM(rb_intern("sampler_2d"));
+    default:                                     return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE type_to_sym(int type) {
+  switch(type) {
+    case TINYGLTF_TYPE_VEC2:   return ID2SYM(rb_intern("vec2"));
+    case TINYGLTF_TYPE_VEC3:   return ID2SYM(rb_intern("vec3"));
+    case TINYGLTF_TYPE_VEC4:   return ID2SYM(rb_intern("vec4"));
+    case TINYGLTF_TYPE_MAT2:   return ID2SYM(rb_intern("mat2"));
+    case TINYGLTF_TYPE_MAT3:   return ID2SYM(rb_intern("mat3"));
+    case TINYGLTF_TYPE_MAT4:   return ID2SYM(rb_intern("mat4"));
+    case TINYGLTF_TYPE_SCALAR: return ID2SYM(rb_intern("scalar"));
+    case TINYGLTF_TYPE_VECTOR: return ID2SYM(rb_intern("vector"));
+    case TINYGLTF_TYPE_MATRIX: return ID2SYM(rb_intern("matrix"));
+    default:                   return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE image_format_to_sym(int fmt) {
+  switch(fmt) {
+    case TINYGLTF_IMAGE_FORMAT_JPEG: return ID2SYM(rb_intern("jpeg"));
+    case TINYGLTF_IMAGE_FORMAT_PNG:  return ID2SYM(rb_intern("png"));
+    case TINYGLTF_IMAGE_FORMAT_BMP:  return ID2SYM(rb_intern("bmp"));
+    case TINYGLTF_IMAGE_FORMAT_GIF:  return ID2SYM(rb_intern("gif"));
+    default:                         return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE texture_format_to_sym(int fmt) {
+  switch(fmt) {
+    case TINYGLTF_TEXTURE_FORMAT_ALPHA:           return ID2SYM(rb_intern("alpha"));
+    case TINYGLTF_TEXTURE_FORMAT_RGB:             return ID2SYM(rb_intern("rgb"));
+    case TINYGLTF_TEXTURE_FORMAT_RGBA:            return ID2SYM(rb_intern("rgba"));
+    case TINYGLTF_TEXTURE_FORMAT_LUMINANCE:       return ID2SYM(rb_intern("luminance"));
+    case TINYGLTF_TEXTURE_FORMAT_LUMINANCE_ALPHA: return ID2SYM(rb_intern("luminance_alpha"));
+    default:                                      return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE texture_target_to_sym(int tgt) {
+  switch(tgt) {
+    case TINYGLTF_TEXTURE_TARGET_TEXTURE2D: return ID2SYM(rb_intern("texture2d"));
+    default:                                return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE texture_type_to_sym(int type) {
+  switch(type) {
+    case TINYGLTF_TEXTURE_TYPE_UNSIGNED_BYTE: return ID2SYM(rb_intern("ubyte"));
+    default:                                  return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE target_to_sym(int tgt) {
+  switch(tgt) {
+    case TINYGLTF_TARGET_ARRAY_BUFFER:         return ID2SYM(rb_intern("array_buffer"));
+    case TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER: return ID2SYM(rb_intern("element_array_buffer"));
+    default:                                   return ID2SYM(rb_intern("unknown"));
+  }
+}
+
+VALUE shader_type_to_sym(int type) {
+  switch(type) {
+    case TINYGLTF_SHADER_TYPE_VERTEX_SHADER:   return ID2SYM(rb_intern("vertex_shader"));
+    case TINYGLTF_SHADER_TYPE_FRAGMENT_SHADER: return ID2SYM(rb_intern("fragment_shader"));
+    default:                                   return ID2SYM(rb_intern("unknown"));
+  }
+}