@reactvision/react-viro 2.41.3

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/tiny_obj_loader.h

@@ -0,0 +1,1754 @@
+/*
+ The MIT License (MIT)
+ 
+ Copyright (c) 2012-2016 Syoyo Fujita and many contributors.
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+//
+// version 1.0.4 : Support multiple filenames for 'mtllib'(#112)
+// version 1.0.3 : Support parsing texture options(#85)
+// version 1.0.2 : Improve parsing speed by about a factor of 2 for large
+// files(#105)
+// version 1.0.1 : Fixes a shape is lost if obj ends with a 'usemtl'(#104)
+// version 1.0.0 : Change data structure. Change license from BSD to MIT.
+//
+
+//
+// Use this in *one* .cc
+//   #define TINYOBJLOADER_IMPLEMENTATION
+//   #include "tiny_obj_loader.h"
+//
+
+#ifndef TINY_OBJ_LOADER_H_
+#define TINY_OBJ_LOADER_H_
+
+#include <map>
+#include <string>
+#include <vector>
+#include "VROLog.h"
+#include "VROPlatformUtil.h"
+#include "VROTaskQueue.h"
+
+namespace tinyobj {
+    
+    // https://en.wikipedia.org/wiki/Wavefront_.obj_file says ...
+    //
+    //  -blendu on | off                       # set horizontal texture blending
+    //  (default on)
+    //  -blendv on | off                       # set vertical texture blending
+    //  (default on)
+    //  -boost float_value                     # boost mip-map sharpness
+    //  -mm base_value gain_value              # modify texture map values (default
+    //  0 1)
+    //                                         #     base_value = brightness,
+    //                                         gain_value = contrast
+    //  -o u [v [w]]                           # Origin offset             (default
+    //  0 0 0)
+    //  -s u [v [w]]                           # Scale                     (default
+    //  1 1 1)
+    //  -t u [v [w]]                           # Turbulence                (default
+    //  0 0 0)
+    //  -texres resolution                     # texture resolution to create
+    //  -clamp on | off                        # only render texels in the clamped
+    //  0-1 range (default off)
+    //                                         #   When unclamped, textures are
+    //                                         repeated across a surface,
+    //                                         #   when clamped, only texels which
+    //                                         fall within the 0-1
+    //                                         #   range are rendered.
+    //  -bm mult_value                         # bump multiplier (for bump maps
+    //  only)
+    //
+    //  -imfchan r | g | b | m | l | z         # specifies which channel of the file
+    //  is used to
+    //                                         # create a scalar or bump texture.
+    //                                         r:red, g:green,
+    //                                         # b:blue, m:matte, l:luminance,
+    //                                         z:z-depth..
+    //                                         # (the default for bump is 'l' and
+    //                                         for decal is 'm')
+    //  bump -imfchan r bumpmap.tga            # says to use the red channel of
+    //  bumpmap.tga as the bumpmap
+    //
+    // For reflection maps...
+    //
+    //   -type sphere                           # specifies a sphere for a "refl"
+    //   reflection map
+    //   -type cube_top    | cube_bottom |      # when using a cube map, the texture
+    //   file for each
+    //         cube_front  | cube_back   |      # side of the cube is specified
+    //         separately
+    //         cube_left   | cube_right
+    
+    typedef enum {
+        TEXTURE_TYPE_NONE,  // default
+        TEXTURE_TYPE_SPHERE,
+        TEXTURE_TYPE_CUBE_TOP,
+        TEXTURE_TYPE_CUBE_BOTTOM,
+        TEXTURE_TYPE_CUBE_FRONT,
+        TEXTURE_TYPE_CUBE_BACK,
+        TEXTURE_TYPE_CUBE_LEFT,
+        TEXTURE_TYPE_CUBE_RIGHT
+    } texture_type_t;
+    
+    typedef struct {
+        texture_type_t type;     // -type (default TEXTURE_TYPE_NONE)
+        float sharpness;         // -boost (default 1.0?)
+        float brightness;        // base_value in -mm option (default 0)
+        float contrast;          // gain_value in -mm option (default 1)
+        float origin_offset[3];  // -o u [v [w]] (default 0 0 0)
+        float scale[3];          // -s u [v [w]] (default 1 1 1)
+        float turbulence[3];     // -t u [v [w]] (default 0 0 0)
+        // int   texture_resolution; // -texres resolution (default = ?) TODO
+        bool clamp;    // -clamp (default false)
+        char imfchan;  // -imfchan (the default for bump is 'l' and for decal is 'm')
+        bool blendu;   // -blendu (default on)
+        bool blendv;   // -blendv (default on)
+        float bump_multiplier;  // -bm (for bump maps only, default 1.0)
+    } texture_option_t;
+    
+    typedef struct {
+        std::string name;
+        
+        float ambient[3];
+        float diffuse[3];
+        float specular[3];
+        float transmittance[3];
+        float emission[3];
+        float shininess;
+        float ior;       // index of refraction
+        float dissolve;  // 1 == opaque; 0 == fully transparent
+        // illumination model (see http://www.fileformat.info/format/material/)
+        int illum;
+        
+        int dummy;  // Suppress padding warning.
+        
+        std::string ambient_texname;             // map_Ka
+        std::string diffuse_texname;             // map_Kd
+        std::string specular_texname;            // map_Ks
+        std::string specular_highlight_texname;  // map_Ns
+        std::string bump_texname;                // map_bump, bump
+        std::string displacement_texname;        // disp
+        std::string alpha_texname;               // map_d
+        
+        texture_option_t ambient_texopt;
+        texture_option_t diffuse_texopt;
+        texture_option_t specular_texopt;
+        texture_option_t specular_highlight_texopt;
+        texture_option_t bump_texopt;
+        texture_option_t displacement_texopt;
+        texture_option_t alpha_texopt;
+        
+        // PBR extension
+        // http://exocortex.com/blog/extending_wavefront_mtl_to_support_pbr
+        float roughness;            // [0, 1] default 0
+        float metallic;             // [0, 1] default 0
+        float sheen;                // [0, 1] default 0
+        float clearcoat_thickness;  // [0, 1] default 0
+        float clearcoat_roughness;  // [0, 1] default 0
+        float anisotropy;           // aniso. [0, 1] default 0
+        float anisotropy_rotation;  // anisor. [0, 1] default 0
+        float pad0;
+        float pad1;
+        std::string roughness_texname;  // map_Pr
+        std::string metallic_texname;   // map_Pm
+        std::string sheen_texname;      // map_Ps
+        std::string emissive_texname;   // map_Ke
+        std::string normal_texname;     // norm. For normal mapping.
+        
+        texture_option_t roughness_texopt;
+        texture_option_t metallic_texopt;
+        texture_option_t sheen_texopt;
+        texture_option_t emissive_texopt;
+        texture_option_t normal_texopt;
+        
+        int pad2;
+        
+        std::map<std::string, std::string> unknown_parameter;
+        
+        bool has_diffuse_color;
+        bool has_illum;
+    } material_t;
+    
+    typedef struct {
+        std::string name;
+        
+        std::vector<int> intValues;
+        std::vector<float> floatValues;
+        std::vector<std::string> stringValues;
+    } tag_t;
+    
+    // Index struct to support different indices for vtx/normal/texcoord.
+    // -1 means not used.
+    typedef struct {
+        int vertex_index;
+        int normal_index;
+        int texcoord_index;
+    } index_t;
+    
+    typedef struct {
+        std::vector<index_t> indices;
+        std::vector<unsigned char> num_face_vertices;  // The number of vertices per
+        // face. 3 = polygon, 4 = quad,
+        // ... Up to 255.
+        std::vector<int> material_ids;                 // per-face material ID
+        std::vector<tag_t> tags;                       // SubD tag
+    } mesh_t;
+    
+    typedef struct {
+        std::string name;
+        mesh_t mesh;
+    } shape_t;
+    
+    // Vertex attributes
+    typedef struct {
+        std::vector<float> vertices;   // 'v'
+        std::vector<float> normals;    // 'vn'
+        std::vector<float> texcoords;  // 'vt'
+    } attrib_t;
+    
+    typedef struct callback_t_ {
+        // W is optional and set to 1 if there is no `w` item in `v` line
+        void (*vertex_cb)(void *user_data, float x, float y, float z, float w);
+        void (*normal_cb)(void *user_data, float x, float y, float z);
+        
+        // y and z are optional and set to 0 if there is no `y` and/or `z` item(s) in
+        // `vt` line.
+        void (*texcoord_cb)(void *user_data, float x, float y, float z);
+        
+        // called per 'f' line. num_indices is the number of face indices(e.g. 3 for
+        // triangle, 4 for quad)
+        // 0 will be passed for undefined index in index_t members.
+        void (*index_cb)(void *user_data, index_t *indices, int num_indices);
+        // `name` material name, `material_id` = the array index of material_t[]. -1
+        // if
+        // a material not found in .mtl
+        void (*usemtl_cb)(void *user_data, const char *name, int material_id);
+        // `materials` = parsed material data.
+        void (*mtllib_cb)(void *user_data, const material_t *materials,
+                          int num_materials);
+        // There may be multiple group names
+        void (*group_cb)(void *user_data, const char **names, int num_names);
+        void (*object_cb)(void *user_data, const char *name);
+        
+        callback_t_()
+        : vertex_cb(NULL),
+        normal_cb(NULL),
+        texcoord_cb(NULL),
+        index_cb(NULL),
+        usemtl_cb(NULL),
+        mtllib_cb(NULL),
+        group_cb(NULL),
+        object_cb(NULL) {}
+    } callback_t;
+    
+    class MaterialReader {
+    public:
+        MaterialReader() {}
+        virtual ~MaterialReader();
+        
+        virtual bool operator()(const std::string &matId,
+                                std::shared_ptr<std::vector<material_t>> materials,
+                                std::shared_ptr<std::map<std::string, int>> matMap,
+                                std::string *err) = 0;
+    };
+    
+    class MaterialFileReader : public MaterialReader {
+    public:
+        explicit MaterialFileReader() {}
+        explicit MaterialFileReader(const std::string &mtl_basedir, bool baseurl, std::shared_ptr<VROTaskQueue> taskQueue)
+        : m_mtlBaseDir(mtl_basedir), m_baseurl(baseurl), m_taskQueue(taskQueue), m_resourceMap(nullptr) {}
+        explicit MaterialFileReader(std::map<std::string, std::string> *resourceMap, std::shared_ptr<VROTaskQueue> taskQueue)
+        : m_taskQueue(taskQueue), m_resourceMap(resourceMap) {}
+        virtual ~MaterialFileReader() {}
+        virtual bool operator()(const std::string &matId,
+                                std::shared_ptr<std::vector<material_t>> materials,
+                                std::shared_ptr<std::map<std::string, int>> matMap,
+                                std::string *err);
+        
+    private:
+        std::string m_mtlBaseDir;
+        bool m_baseurl;
+        std::shared_ptr<VROTaskQueue> m_taskQueue;
+        std::map<std::string, std::string> *m_resourceMap;
+        
+        static bool readMaterialFile(std::string filePath, const std::string &matId,
+                                     std::shared_ptr<std::vector<material_t>> materials,
+                                     std::shared_ptr<std::map<std::string, int>> matMap, std::string *err);
+    };
+    
+    /// Loads .obj from a file.
+    /// 'attrib', 'shapes' and 'materials' will be filled with parsed shape data
+    /// 'shapes' will be filled with parsed shape data
+    /// Returns true when loading .obj become success.
+    /// Returns warning and error message into `err`
+    /// 'mtl_basedir' is optional, and used for base directory for .mtl file.
+    /// In default(`NULL'), .mtl file is searched from an application's working directory.
+    /// 'triangulate' is optional, and used whether triangulate polygon face in .obj
+    /// or not.
+    
+    /// Viro notes: this is called from any background thread, and will use an internal
+    ///             task queue. When complete, the callback will be invoked on the
+    ///             rendering thread.
+    void LoadObj(std::shared_ptr<attrib_t> attrib, std::shared_ptr<std::vector<shape_t>> shapes,
+                 std::shared_ptr<std::vector<material_t>> materials, std::string *err,
+                 const char *filename, const char *mtl_basedir,
+                 bool baseurl,
+                 std::map<std::string, std::string> *resourceMap,
+                 std::shared_ptr<VROTaskQueue> taskQueue,
+                 std::function<void(bool)> onFinished,
+                 bool triangulate = true);
+    
+    // Load all the MTL files into the given map, which can then be passed
+    // into LoadObj
+    bool LoadMTLFiles(std::shared_ptr<std::vector<material_t>> materials,
+                      std::shared_ptr<std::map<std::string, int>> material_map,
+                      std::string *err,
+                      std::shared_ptr<std::istream> inStream, MaterialReader *readMatFn);
+    
+    /// Loads object from a std::istream, uses GetMtlIStreamFn to retrieve
+    /// std::istream for materials.
+    /// Returns true when loading .obj become success.
+    /// Returns warning and error message into `err`
+    bool LoadObj(std::shared_ptr<attrib_t> attrib, std::shared_ptr<std::vector<shape_t>> shapes,
+                 std::shared_ptr<std::map<std::string, int>> material_map,
+                 std::string *err,
+                 std::shared_ptr<std::istream> inStream,
+                 bool triangulate = true);
+    
+    /// Loads materials into std::map
+    void LoadMtl(std::shared_ptr<std::map<std::string, int>> material_map,
+                 std::shared_ptr<std::vector<material_t>> materials, std::shared_ptr<std::istream> inStream);
+    
+}  // namespace tinyobj
+
+#ifdef TINYOBJLOADER_IMPLEMENTATION
+#include <cassert>
+#include <cctype>
+#include <cmath>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <utility>
+
+#include <fstream>
+#include <sstream>
+
+namespace tinyobj {
+    
+    MaterialReader::~MaterialReader() {}
+    
+#define TINYOBJ_SSCANF_BUFFER_SIZE (4096)
+    
+    struct vertex_index {
+        int v_idx, vt_idx, vn_idx;
+        vertex_index() : v_idx(-1), vt_idx(-1), vn_idx(-1) {}
+        explicit vertex_index(int idx) : v_idx(idx), vt_idx(idx), vn_idx(idx) {}
+        vertex_index(int vidx, int vtidx, int vnidx)
+        : v_idx(vidx), vt_idx(vtidx), vn_idx(vnidx) {}
+    };
+    
+    struct tag_sizes {
+        tag_sizes() : num_ints(0), num_floats(0), num_strings(0) {}
+        int num_ints;
+        int num_floats;
+        int num_strings;
+    };
+    
+    struct obj_shape {
+        std::vector<float> v;
+        std::vector<float> vn;
+        std::vector<float> vt;
+    };
+    
+    // See
+    // http://stackoverflow.com/questions/6089231/getting-std-ifstream-to-handle-lf-cr-and-crlf
+    static std::istream &safeGetline(std::istream &is, std::string &t) {
+        t.clear();
+        
+        // The characters in the stream are read one-by-one using a std::streambuf.
+        // That is faster than reading them one-by-one using the std::istream.
+        // Code that uses streambuf this way must be guarded by a sentry object.
+        // The sentry object performs various tasks,
+        // such as thread synchronization and updating the stream state.
+        
+        std::istream::sentry se(is, true);
+        std::streambuf *sb = is.rdbuf();
+        
+        for (;;) {
+            int c = sb->sbumpc();
+            switch (c) {
+                case '\n':
+                    return is;
+                case '\r':
+                    if (sb->sgetc() == '\n') sb->sbumpc();
+                    return is;
+                case EOF:
+                    // Also handle the case when the last line has no line ending
+                    if (t.empty()) is.setstate(std::ios::eofbit);
+                    return is;
+                default:
+                    t += static_cast<char>(c);
+            }
+        }
+    }
+    
+#define IS_SPACE(x) (((x) == ' ') || ((x) == '\t'))
+#define IS_DIGIT(x) \
+(static_cast<unsigned int>((x) - '0') < static_cast<unsigned int>(10))
+#define IS_NEW_LINE(x) (((x) == '\r') || ((x) == '\n') || ((x) == '\0'))
+    
+    // Make index zero-base, and also support relative index.
+    static inline int fixIndex(int idx, int n) {
+        if (idx > 0) return idx - 1;
+        if (idx == 0) return 0;
+        return n + idx;  // negative value = relative
+    }
+    
+    static inline std::string parseString(const char **token) {
+        std::string s;
+        (*token) += strspn((*token), " \t");
+        size_t e = strcspn((*token), " \t\r");
+        s = std::string((*token), &(*token)[e]);
+        (*token) += e;
+        return s;
+    }
+    
+    static inline int parseInt(const char **token) {
+        (*token) += strspn((*token), " \t");
+        int i = atoi((*token));
+        (*token) += strcspn((*token), " \t\r");
+        return i;
+    }
+    
+    // Tries to parse a floating point number located at s.
+    //
+    // s_end should be a location in the string where reading should absolutely
+    // stop. For example at the end of the string, to prevent buffer overflows.
+    //
+    // Parses the following EBNF grammar:
+    //   sign    = "+" | "-" ;
+    //   END     = ? anything not in digit ?
+    //   digit   = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+    //   integer = [sign] , digit , {digit} ;
+    //   decimal = integer , ["." , integer] ;
+    //   float   = ( decimal , END ) | ( decimal , ("E" | "e") , integer , END ) ;
+    //
+    //  Valid strings are for example:
+    //   -0  +3.1417e+2  -0.0E-3  1.0324  -1.41   11e2
+    //
+    // If the parsing is a success, result is set to the parsed value and true
+    // is returned.
+    //
+    // The function is greedy and will parse until any of the following happens:
+    //  - a non-conforming character is encountered.
+    //  - s_end is reached.
+    //
+    // The following situations triggers a failure:
+    //  - s >= s_end.
+    //  - parse failure.
+    //
+    static bool tryParseDouble(const char *s, const char *s_end, double *result) {
+        if (s >= s_end) {
+            return false;
+        }
+        
+        double mantissa = 0.0;
+        // This exponent is base 2 rather than 10.
+        // However the exponent we parse is supposed to be one of ten,
+        // thus we must take care to convert the exponent/and or the
+        // mantissa to a * 2^E, where a is the mantissa and E is the
+        // exponent.
+        // To get the final double we will use ldexp, it requires the
+        // exponent to be in base 2.
+        int exponent = 0;
+        
+        // NOTE: THESE MUST BE DECLARED HERE SINCE WE ARE NOT ALLOWED
+        // TO JUMP OVER DEFINITIONS.
+        char sign = '+';
+        char exp_sign = '+';
+        char const *curr = s;
+        
+        // How many characters were read in a loop.
+        int read = 0;
+        // Tells whether a loop terminated due to reaching s_end.
+        bool end_not_reached = false;
+        
+        /*
+         BEGIN PARSING.
+         */
+        
+        // Find out what sign we've got.
+        if (*curr == '+' || *curr == '-') {
+            sign = *curr;
+            curr++;
+        } else if (IS_DIGIT(*curr)) { /* Pass through. */
+        } else {
+            goto fail;
+        }
+        
+        // Read the integer part.
+        end_not_reached = (curr != s_end);
+        while (end_not_reached && IS_DIGIT(*curr)) {
+            mantissa *= 10;
+            mantissa += static_cast<int>(*curr - 0x30);
+            curr++;
+            read++;
+            end_not_reached = (curr != s_end);
+        }
+        
+        // We must make sure we actually got something.
+        if (read == 0) goto fail;
+        // We allow numbers of form "#", "###" etc.
+        if (!end_not_reached) goto assemble;
+        
+        // Read the decimal part.
+        if (*curr == '.') {
+            curr++;
+            read = 1;
+            end_not_reached = (curr != s_end);
+            while (end_not_reached && IS_DIGIT(*curr)) {
+                static const double pow_lut[] = {
+                    1.0, 0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001,
+                };
+                const int lut_entries = sizeof pow_lut / sizeof pow_lut[0];
+                
+                // NOTE: Don't use powf here, it will absolutely murder precision.
+                mantissa += static_cast<int>(*curr - 0x30) *
+                (read < lut_entries ? pow_lut[read] : pow(10.0, -read));
+                read++;
+                curr++;
+                end_not_reached = (curr != s_end);
+            }
+        } else if (*curr == 'e' || *curr == 'E') {
+        } else {
+            goto assemble;
+        }
+        
+        if (!end_not_reached) goto assemble;
+        
+        // Read the exponent part.
+        if (*curr == 'e' || *curr == 'E') {
+            curr++;
+            // Figure out if a sign is present and if it is.
+            end_not_reached = (curr != s_end);
+            if (end_not_reached && (*curr == '+' || *curr == '-')) {
+                exp_sign = *curr;
+                curr++;
+            } else if (IS_DIGIT(*curr)) { /* Pass through. */
+            } else {
+                // Empty E is not allowed.
+                goto fail;
+            }
+            
+            read = 0;
+            end_not_reached = (curr != s_end);
+            while (end_not_reached && IS_DIGIT(*curr)) {
+                exponent *= 10;
+                exponent += static_cast<int>(*curr - 0x30);
+                curr++;
+                read++;
+                end_not_reached = (curr != s_end);
+            }
+            exponent *= (exp_sign == '+' ? 1 : -1);
+            if (read == 0) goto fail;
+        }
+        
+    assemble:
+        *result =
+        (sign == '+' ? 1 : -1) *
+        (exponent ? ldexp(mantissa * pow(5.0, exponent), exponent) : mantissa);
+        return true;
+    fail:
+        return false;
+    }
+    
+    static inline float parseFloat(const char **token, double default_value = 0.0) {
+        (*token) += strspn((*token), " \t");
+        const char *end = (*token) + strcspn((*token), " \t\r");
+        double val = default_value;
+        tryParseDouble((*token), end, &val);
+        float f = static_cast<float>(val);
+        (*token) = end;
+        return f;
+    }
+    
+    static inline void parseFloat2(float *x, float *y, const char **token,
+                                   const double default_x = 0.0,
+                                   const double default_y = 0.0) {
+        (*x) = parseFloat(token, default_x);
+        (*y) = parseFloat(token, default_y);
+    }
+    
+    static inline void parseFloat3(float *x, float *y, float *z, const char **token,
+                                   const double default_x = 0.0,
+                                   const double default_y = 0.0,
+                                   const double default_z = 0.0) {
+        (*x) = parseFloat(token, default_x);
+        (*y) = parseFloat(token, default_y);
+        (*z) = parseFloat(token, default_z);
+    }
+    
+    static inline void parseV(float *x, float *y, float *z, float *w,
+                              const char **token, const double default_x = 0.0,
+                              const double default_y = 0.0,
+                              const double default_z = 0.0,
+                              const double default_w = 1.0) {
+        (*x) = parseFloat(token, default_x);
+        (*y) = parseFloat(token, default_y);
+        (*z) = parseFloat(token, default_z);
+        (*w) = parseFloat(token, default_w);
+    }
+    
+    static inline bool parseOnOff(const char **token, bool default_value = true) {
+        (*token) += strspn((*token), " \t");
+        const char *end = (*token) + strcspn((*token), " \t\r");
+        
+        bool ret = default_value;
+        if ((0 == strncmp((*token), "on", 2))) {
+            ret = true;
+        } else if ((0 == strncmp((*token), "off", 3))) {
+            ret = false;
+        }
+        
+        (*token) = end;
+        return ret;
+    }
+    
+    static inline texture_type_t parseTextureType(
+                                                  const char **token, texture_type_t default_value = TEXTURE_TYPE_NONE) {
+        (*token) += strspn((*token), " \t");
+        const char *end = (*token) + strcspn((*token), " \t\r");
+        texture_type_t ty = default_value;
+        
+        if ((0 == strncmp((*token), "cube_top", strlen("cube_top")))) {
+            ty = TEXTURE_TYPE_CUBE_TOP;
+        } else if ((0 == strncmp((*token), "cube_bottom", strlen("cube_bottom")))) {
+            ty = TEXTURE_TYPE_CUBE_BOTTOM;
+        } else if ((0 == strncmp((*token), "cube_left", strlen("cube_left")))) {
+            ty = TEXTURE_TYPE_CUBE_LEFT;
+        } else if ((0 == strncmp((*token), "cube_right", strlen("cube_right")))) {
+            ty = TEXTURE_TYPE_CUBE_RIGHT;
+        } else if ((0 == strncmp((*token), "cube_front", strlen("cube_front")))) {
+            ty = TEXTURE_TYPE_CUBE_FRONT;
+        } else if ((0 == strncmp((*token), "cube_back", strlen("cube_back")))) {
+            ty = TEXTURE_TYPE_CUBE_BACK;
+        } else if ((0 == strncmp((*token), "sphere", strlen("sphere")))) {
+            ty = TEXTURE_TYPE_SPHERE;
+        }
+        
+        (*token) = end;
+        return ty;
+    }
+    
+    static tag_sizes parseTagTriple(const char **token) {
+        tag_sizes ts;
+        
+        ts.num_ints = atoi((*token));
+        (*token) += strcspn((*token), "/ \t\r");
+        if ((*token)[0] != '/') {
+            return ts;
+        }
+        (*token)++;
+        
+        ts.num_floats = atoi((*token));
+        (*token) += strcspn((*token), "/ \t\r");
+        if ((*token)[0] != '/') {
+            return ts;
+        }
+        (*token)++;
+        
+        ts.num_strings = atoi((*token));
+        (*token) += strcspn((*token), "/ \t\r") + 1;
+        
+        return ts;
+    }
+    
+    // Parse triples with index offsets: i, i/j/k, i//k, i/j
+    static vertex_index parseTriple(const char **token, int vsize, int vnsize,
+                                    int vtsize) {
+        vertex_index vi(-1);
+        
+        vi.v_idx = fixIndex(atoi((*token)), vsize);
+        (*token) += strcspn((*token), "/ \t\r");
+        if ((*token)[0] != '/') {
+            return vi;
+        }
+        (*token)++;
+        
+        // i//k
+        if ((*token)[0] == '/') {
+            (*token)++;
+            vi.vn_idx = fixIndex(atoi((*token)), vnsize);
+            (*token) += strcspn((*token), "/ \t\r");
+            return vi;
+        }
+        
+        // i/j/k or i/j
+        vi.vt_idx = fixIndex(atoi((*token)), vtsize);
+        (*token) += strcspn((*token), "/ \t\r");
+        if ((*token)[0] != '/') {
+            return vi;
+        }
+        
+        // i/j/k
+        (*token)++;  // skip '/'
+        vi.vn_idx = fixIndex(atoi((*token)), vnsize);
+        (*token) += strcspn((*token), "/ \t\r");
+        return vi;
+    }
+    
+    static bool ParseTextureNameAndOption(std::string *texname,
+                                          texture_option_t *texopt,
+                                          const char *linebuf, const bool is_bump) {
+        // @todo { write more robust lexer and parser. }
+        bool found_texname = false;
+        std::string texture_name;
+        
+        // Fill with default value for texopt.
+        if (is_bump) {
+            texopt->imfchan = 'l';
+        } else {
+            texopt->imfchan = 'm';
+        }
+        texopt->bump_multiplier = 1.0f;
+        texopt->clamp = false;
+        texopt->blendu = true;
+        texopt->blendv = true;
+        texopt->sharpness = 1.0f;
+        texopt->brightness = 0.0f;
+        texopt->contrast = 1.0f;
+        texopt->origin_offset[0] = 0.0f;
+        texopt->origin_offset[1] = 0.0f;
+        texopt->origin_offset[2] = 0.0f;
+        texopt->scale[0] = 1.0f;
+        texopt->scale[1] = 1.0f;
+        texopt->scale[2] = 1.0f;
+        texopt->turbulence[0] = 0.0f;
+        texopt->turbulence[1] = 0.0f;
+        texopt->turbulence[2] = 0.0f;
+        texopt->type = TEXTURE_TYPE_NONE;
+        
+        const char *token = linebuf;  // Assume line ends with NULL
+        
+        while (!IS_NEW_LINE((*token))) {
+            if ((0 == strncmp(token, "-blendu", 7)) && IS_SPACE((token[7]))) {
+                token += 8;
+                texopt->blendu = parseOnOff(&token, /* default */ true);
+            } else if ((0 == strncmp(token, "-blendv", 7)) && IS_SPACE((token[7]))) {
+                token += 8;
+                texopt->blendv = parseOnOff(&token, /* default */ true);
+            } else if ((0 == strncmp(token, "-clamp", 6)) && IS_SPACE((token[6]))) {
+                token += 7;
+                texopt->clamp = parseOnOff(&token, /* default */ true);
+            } else if ((0 == strncmp(token, "-boost", 6)) && IS_SPACE((token[6]))) {
+                token += 7;
+                texopt->sharpness = parseFloat(&token, 1.0);
+            } else if ((0 == strncmp(token, "-bm", 3)) && IS_SPACE((token[3]))) {
+                token += 4;
+                texopt->bump_multiplier = parseFloat(&token, 1.0);
+            } else if ((0 == strncmp(token, "-o", 2)) && IS_SPACE((token[2]))) {
+                token += 3;
+                parseFloat3(&(texopt->origin_offset[0]), &(texopt->origin_offset[1]),
+                            &(texopt->origin_offset[2]), &token);
+            } else if ((0 == strncmp(token, "-s", 2)) && IS_SPACE((token[2]))) {
+                token += 3;
+                parseFloat3(&(texopt->scale[0]), &(texopt->scale[1]), &(texopt->scale[2]),
+                            &token, 1.0, 1.0, 1.0);
+            } else if ((0 == strncmp(token, "-t", 2)) && IS_SPACE((token[2]))) {
+                token += 3;
+                parseFloat3(&(texopt->turbulence[0]), &(texopt->turbulence[1]),
+                            &(texopt->turbulence[2]), &token);
+            } else if ((0 == strncmp(token, "-type", 5)) && IS_SPACE((token[5]))) {
+                token += 5;
+                texopt->type = parseTextureType((&token), TEXTURE_TYPE_NONE);
+            } else if ((0 == strncmp(token, "-imfchan", 8)) && IS_SPACE((token[8]))) {
+                token += 9;
+                token += strspn(token, " \t");
+                const char *end = token + strcspn(token, " \t\r");
+                if ((end - token) == 1) {  // Assume one char for -imfchan
+                    texopt->imfchan = (*token);
+                }
+                token = end;
+            } else if ((0 == strncmp(token, "-mm", 3)) && IS_SPACE((token[3]))) {
+                token += 4;
+                parseFloat2(&(texopt->brightness), &(texopt->contrast), &token, 0.0, 1.0);
+            } else {
+                // Assume texture filename
+                token += strspn(token, " \t");         // skip space
+                size_t len = strcspn(token, " \t\r");  // untile next space
+                texture_name = std::string(token, token + len);
+                token += len;
+                
+                token += strspn(token, " \t");  // skip space
+                
+                found_texname = true;
+            }
+        }
+        
+        if (found_texname) {
+            (*texname) = texture_name;
+            return true;
+        } else {
+            return false;
+        }
+    }
+    
+    static void InitMaterial(material_t *material) {
+        material->name = "";
+        material->ambient_texname = "";
+        material->diffuse_texname = "";
+        material->specular_texname = "";
+        material->specular_highlight_texname = "";
+        material->bump_texname = "";
+        material->displacement_texname = "";
+        material->alpha_texname = "";
+        for (int i = 0; i < 3; i++) {
+            material->ambient[i] = 0.f;
+            material->diffuse[i] = 0.f;
+            material->specular[i] = 0.f;
+            material->transmittance[i] = 0.f;
+            material->emission[i] = 0.f;
+        }
+        material->illum = 0;
+        material->dissolve = 1.f;
+        material->shininess = 1.f;
+        material->ior = 1.f;
+        
+        material->roughness = 0.f;
+        material->metallic = 0.f;
+        material->sheen = 0.f;
+        material->clearcoat_thickness = 0.f;
+        material->clearcoat_roughness = 0.f;
+        material->anisotropy_rotation = 0.f;
+        material->anisotropy = 0.f;
+        material->roughness_texname = "";
+        material->metallic_texname = "";
+        material->sheen_texname = "";
+        material->emissive_texname = "";
+        material->normal_texname = "";
+        
+        material->has_diffuse_color = false;
+        material->has_illum = false;
+        material->unknown_parameter.clear();
+    }
+    
+    static bool exportFaceGroupToShape(
+                                       shape_t *shape, const std::vector<std::vector<vertex_index> > &faceGroup,
+                                       const std::vector<tag_t> &tags, const int material_id,
+                                       const std::string &name, bool triangulate) {
+        if (faceGroup.empty()) {
+            return false;
+        }
+        
+        // Flatten vertices and indices
+        for (size_t i = 0; i < faceGroup.size(); i++) {
+            const std::vector<vertex_index> &face = faceGroup[i];
+            
+            vertex_index i0 = face[0];
+            vertex_index i1(-1);
+            vertex_index i2 = face[1];
+            
+            size_t npolys = face.size();
+            
+            if (triangulate) {
+                // Polygon -> triangle fan conversion
+                for (size_t k = 2; k < npolys; k++) {
+                    i1 = i2;
+                    i2 = face[k];
+                    
+                    index_t idx0, idx1, idx2;
+                    idx0.vertex_index = i0.v_idx;
+                    idx0.normal_index = i0.vn_idx;
+                    idx0.texcoord_index = i0.vt_idx;
+                    idx1.vertex_index = i1.v_idx;
+                    idx1.normal_index = i1.vn_idx;
+                    idx1.texcoord_index = i1.vt_idx;
+                    idx2.vertex_index = i2.v_idx;
+                    idx2.normal_index = i2.vn_idx;
+                    idx2.texcoord_index = i2.vt_idx;
+                    
+                    shape->mesh.indices.push_back(idx0);
+                    shape->mesh.indices.push_back(idx1);
+                    shape->mesh.indices.push_back(idx2);
+                    
+                    shape->mesh.num_face_vertices.push_back(3);
+                    shape->mesh.material_ids.push_back(material_id);
+                }
+            } else {
+                for (size_t k = 0; k < npolys; k++) {
+                    index_t idx;
+                    idx.vertex_index = face[k].v_idx;
+                    idx.normal_index = face[k].vn_idx;
+                    idx.texcoord_index = face[k].vt_idx;
+                    shape->mesh.indices.push_back(idx);
+                }
+                
+                shape->mesh.num_face_vertices.push_back(
+                                                        static_cast<unsigned char>(npolys));
+                shape->mesh.material_ids.push_back(material_id);  // per face
+            }
+        }
+        
+        shape->name = name;
+        shape->mesh.tags = tags;
+        
+        return true;
+    }
+    
+    // Split a string with specified delimiter character.
+    // http://stackoverflow.com/questions/236129/split-a-string-in-c
+    static void SplitString(const std::string &s, char delim, std::vector<std::string> &elems)
+    {
+        std::stringstream ss;
+        ss.str(s);
+        std::string item;
+        while (std::getline(ss, item, delim)) {
+            elems.push_back(item);
+        }
+    }
+    
+    void LoadMtl(std::shared_ptr<std::map<std::string, int>> material_map,
+                 std::shared_ptr<std::vector<material_t>> materials, std::shared_ptr<std::istream> inStream) {
+        // Create a default material anyway.
+        material_t material;
+        InitMaterial(&material);
+        
+        std::string linebuf;
+        while (inStream->peek() != -1) {
+            safeGetline(*inStream, linebuf);
+            
+            // Trim trailing whitespace.
+            if (linebuf.size() > 0) {
+                linebuf = linebuf.substr(0, linebuf.find_last_not_of(" \t") + 1);
+            }
+            
+            // Trim newline '\r\n' or '\n'
+            if (linebuf.size() > 0) {
+                if (linebuf[linebuf.size() - 1] == '\n')
+                    linebuf.erase(linebuf.size() - 1);
+            }
+            if (linebuf.size() > 0) {
+                if (linebuf[linebuf.size() - 1] == '\r')
+                    linebuf.erase(linebuf.size() - 1);
+            }
+            
+            // Skip if empty line.
+            if (linebuf.empty()) {
+                continue;
+            }
+            
+            // Skip leading space.
+            const char *token = linebuf.c_str();
+            token += strspn(token, " \t");
+            
+            assert(token);
+            if (token[0] == '\0') continue;  // empty line
+            
+            if (token[0] == '#') continue;  // comment line
+            
+            // new mtl
+            if ((0 == strncmp(token, "newmtl", 6)) && IS_SPACE((token[6]))) {
+                // flush previous material.
+                if (!material.name.empty()) {
+                    material_map->insert(std::pair<std::string, int>(
+                                                                     material.name, static_cast<int>(materials->size())));
+                    materials->push_back(material);
+                }
+                
+                // initial temporary material
+                InitMaterial(&material);
+                
+                // set new mtl name
+                char namebuf[TINYOBJ_SSCANF_BUFFER_SIZE];
+                token += 7;
+#ifdef _MSC_VER
+                sscanf_s(token, "%s", namebuf, (unsigned)_countof(namebuf));
+#else
+                sscanf(token, "%s", namebuf);
+#endif
+                material.name = namebuf;
+                continue;
+            }
+            
+            // ambient
+            if (token[0] == 'K' && token[1] == 'a' && IS_SPACE((token[2]))) {
+                token += 2;
+                float r, g, b;
+                parseFloat3(&r, &g, &b, &token);
+                material.ambient[0] = r;
+                material.ambient[1] = g;
+                material.ambient[2] = b;
+                continue;
+            }
+            
+            // diffuse
+            if (token[0] == 'K' && token[1] == 'd' && IS_SPACE((token[2]))) {
+                token += 2;
+                float r, g, b;
+                parseFloat3(&r, &g, &b, &token);
+                material.diffuse[0] = r;
+                material.diffuse[1] = g;
+                material.diffuse[2] = b;
+                
+                material.has_diffuse_color = true;
+                continue;
+            }
+            
+            // specular
+            if (token[0] == 'K' && token[1] == 's' && IS_SPACE((token[2]))) {
+                token += 2;
+                float r, g, b;
+                parseFloat3(&r, &g, &b, &token);
+                material.specular[0] = r;
+                material.specular[1] = g;
+                material.specular[2] = b;
+                continue;
+            }
+            
+            // transmittance
+            if ((token[0] == 'K' && token[1] == 't' && IS_SPACE((token[2]))) ||
+                (token[0] == 'T' && token[1] == 'f' && IS_SPACE((token[2])))) {
+                token += 2;
+                float r, g, b;
+                parseFloat3(&r, &g, &b, &token);
+                material.transmittance[0] = r;
+                material.transmittance[1] = g;
+                material.transmittance[2] = b;
+                continue;
+            }
+            
+            // ior(index of refraction)
+            if (token[0] == 'N' && token[1] == 'i' && IS_SPACE((token[2]))) {
+                token += 2;
+                material.ior = parseFloat(&token);
+                continue;
+            }
+            
+            // emission
+            if (token[0] == 'K' && token[1] == 'e' && IS_SPACE(token[2])) {
+                token += 2;
+                float r, g, b;
+                parseFloat3(&r, &g, &b, &token);
+                material.emission[0] = r;
+                material.emission[1] = g;
+                material.emission[2] = b;
+                continue;
+            }
+            
+            // shininess
+            if (token[0] == 'N' && token[1] == 's' && IS_SPACE(token[2])) {
+                token += 2;
+                material.shininess = parseFloat(&token);
+                continue;
+            }
+            
+            // illum model
+            if (0 == strncmp(token, "illum", 5) && IS_SPACE(token[5])) {
+                token += 6;
+                material.illum = parseInt(&token);
+                material.has_illum = true;
+                continue;
+            }
+            
+            // dissolve
+            if ((token[0] == 'd' && IS_SPACE(token[1]))) {
+                token += 1;
+                material.dissolve = parseFloat(&token);
+                continue;
+            }
+            if (token[0] == 'T' && token[1] == 'r' && IS_SPACE(token[2])) {
+                token += 2;
+                // Invert value of Tr(assume Tr is in range [0, 1])
+                material.dissolve = 1.0f - parseFloat(&token);
+                continue;
+            }
+            
+            // PBR: roughness
+            if (token[0] == 'P' && token[1] == 'r' && IS_SPACE(token[2])) {
+                token += 2;
+                material.roughness = parseFloat(&token);
+                continue;
+            }
+            
+            // PBR: metallic
+            if (token[0] == 'P' && token[1] == 'm' && IS_SPACE(token[2])) {
+                token += 2;
+                material.metallic = parseFloat(&token);
+                continue;
+            }
+            
+            // PBR: sheen
+            if (token[0] == 'P' && token[1] == 's' && IS_SPACE(token[2])) {
+                token += 2;
+                material.sheen = parseFloat(&token);
+                continue;
+            }
+            
+            // PBR: clearcoat thickness
+            if (token[0] == 'P' && token[1] == 'c' && IS_SPACE(token[2])) {
+                token += 2;
+                material.clearcoat_thickness = parseFloat(&token);
+                continue;
+            }
+            
+            // PBR: clearcoat roughness
+            if ((0 == strncmp(token, "Pcr", 3)) && IS_SPACE(token[3])) {
+                token += 4;
+                material.clearcoat_roughness = parseFloat(&token);
+                continue;
+            }
+            
+            // PBR: anisotropy
+            if ((0 == strncmp(token, "aniso", 5)) && IS_SPACE(token[5])) {
+                token += 6;
+                material.anisotropy = parseFloat(&token);
+                continue;
+            }
+            
+            // PBR: anisotropy rotation
+            if ((0 == strncmp(token, "anisor", 6)) && IS_SPACE(token[6])) {
+                token += 7;
+                material.anisotropy_rotation = parseFloat(&token);
+                continue;
+            }
+            
+            // ambient texture
+            if ((0 == strncmp(token, "map_Ka", 6)) && IS_SPACE(token[6])) {
+                token += 7;
+                ParseTextureNameAndOption(&(material.ambient_texname),
+                                          &(material.ambient_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // diffuse texture
+            if ((0 == strncmp(token, "map_Kd", 6)) && IS_SPACE(token[6])) {
+                token += 7;
+                ParseTextureNameAndOption(&(material.diffuse_texname),
+                                          &(material.diffuse_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // specular texture
+            if ((0 == strncmp(token, "map_Ks", 6)) && IS_SPACE(token[6])) {
+                token += 7;
+                ParseTextureNameAndOption(&(material.specular_texname),
+                                          &(material.specular_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // specular highlight texture
+            if ((0 == strncmp(token, "map_Ns", 6)) && IS_SPACE(token[6])) {
+                token += 7;
+                ParseTextureNameAndOption(&(material.specular_highlight_texname),
+                                          &(material.specular_highlight_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // bump texture
+            if ((0 == strncmp(token, "map_bump", 8)) && IS_SPACE(token[8])) {
+                token += 9;
+                ParseTextureNameAndOption(&(material.bump_texname),
+                                          &(material.bump_texopt), token,
+                                          /* is_bump */ true);
+                continue;
+            }
+            
+            // bump texture
+            if ((0 == strncmp(token, "bump", 4)) && IS_SPACE(token[4])) {
+                token += 5;
+                ParseTextureNameAndOption(&(material.bump_texname),
+                                          &(material.bump_texopt), token,
+                                          /* is_bump */ true);
+                continue;
+            }
+            
+            // alpha texture
+            if ((0 == strncmp(token, "map_d", 5)) && IS_SPACE(token[5])) {
+                token += 6;
+                material.alpha_texname = token;
+                ParseTextureNameAndOption(&(material.alpha_texname),
+                                          &(material.alpha_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // displacement texture
+            if ((0 == strncmp(token, "disp", 4)) && IS_SPACE(token[4])) {
+                token += 5;
+                ParseTextureNameAndOption(&(material.displacement_texname),
+                                          &(material.displacement_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // PBR: roughness texture
+            if ((0 == strncmp(token, "map_Pr", 6)) && IS_SPACE(token[6])) {
+                token += 7;
+                ParseTextureNameAndOption(&(material.roughness_texname),
+                                          &(material.roughness_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // PBR: metallic texture
+            if ((0 == strncmp(token, "map_Pm", 6)) && IS_SPACE(token[6])) {
+                token += 7;
+                ParseTextureNameAndOption(&(material.metallic_texname),
+                                          &(material.metallic_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // PBR: sheen texture
+            if ((0 == strncmp(token, "map_Ps", 6)) && IS_SPACE(token[6])) {
+                token += 7;
+                ParseTextureNameAndOption(&(material.sheen_texname),
+                                          &(material.sheen_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // PBR: emissive texture
+            if ((0 == strncmp(token, "map_Ke", 6)) && IS_SPACE(token[6])) {
+                token += 7;
+                ParseTextureNameAndOption(&(material.emissive_texname),
+                                          &(material.emissive_texopt), token,
+                                          /* is_bump */ false);
+                continue;
+            }
+            
+            // PBR: normal map texture
+            if ((0 == strncmp(token, "norm", 4)) && IS_SPACE(token[4])) {
+                token += 5;
+                ParseTextureNameAndOption(
+                                          &(material.normal_texname), &(material.normal_texopt), token,
+                                          /* is_bump */ false);  // @fixme { is_bump will be true? }
+                continue;
+            }
+            
+            // unknown parameter
+            const char *_space = strchr(token, ' ');
+            if (!_space) {
+                _space = strchr(token, '\t');
+            }
+            if (_space) {
+                std::ptrdiff_t len = _space - token;
+                std::string key(token, static_cast<size_t>(len));
+                std::string value = _space + 1;
+                material.unknown_parameter.insert(
+                                                  std::pair<std::string, std::string>(key, value));
+            }
+        }
+        // flush last material.
+        material_map->insert(std::pair<std::string, int>(
+                                                         material.name, static_cast<int>(materials->size())));
+        materials->push_back(material);
+    }
+    
+    bool MaterialFileReader::operator()(const std::string &matId,
+                                        std::shared_ptr<std::vector<material_t>> materials,
+                                        std::shared_ptr<std::map<std::string, int>> matMap,
+                                        std::string *err) {
+        std::string filepath;
+        
+        if (!m_mtlBaseDir.empty()) {
+            filepath = std::string(m_mtlBaseDir) + "/" + matId;
+        } else {
+            filepath = matId;
+        }
+        
+        // If we have a resource map, attempt to find the location where the mtl was downloaded to
+        if (m_resourceMap != nullptr) {
+            filepath = VROPlatformFindValueInResourceMap(matId, *m_resourceMap);
+            return readMaterialFile(filepath, matId, materials, matMap, err);
+        }
+        
+        // If the path is a URL, we have to download it to a temporary file
+        else if (m_baseurl) {
+            std::weak_ptr<VROTaskQueue> taskQueue_w = m_taskQueue;
+            
+            VROPlatformDispatchAsyncRenderer([taskQueue_w, filepath, matId, materials, matMap, err] {
+                std::shared_ptr<VROTaskQueue> taskQueue = taskQueue_w.lock();
+                if (!taskQueue) {
+                    return;
+                }
+                
+                taskQueue->addTask([taskQueue_w, filepath, matId, materials, matMap, err] {
+                    VROPlatformDownloadURLToFileAsync(filepath,
+                                                      [taskQueue_w, matId, materials, matMap, err](std::string path, bool isTemp) {
+                                                          std::shared_ptr<VROTaskQueue> taskQueue_s = taskQueue_w.lock();
+                                                          if (taskQueue_s) {
+                                                              readMaterialFile(path, matId, materials, matMap, err);
+                                                              taskQueue_s->onTaskComplete();
+                                                          }
+                                                          if (isTemp) {
+                                                              VROPlatformDeleteFile(path);
+                                                          }
+                                                      },
+                                                      [taskQueue_w, matId]() {
+                                                          pinfo("Material map [%s] not downloaded", matId.c_str());
+                                                          std::shared_ptr<VROTaskQueue> taskQueue_s = taskQueue_w.lock();
+                                                          if (taskQueue_s) {
+                                                              taskQueue_s->onTaskComplete();
+                                                          }
+                                                      });
+                });
+            });
+        }
+        return true;
+    }
+    
+    bool MaterialFileReader::readMaterialFile(std::string filepath, const std::string &matId,
+                                              std::shared_ptr<std::vector<material_t>> materials,
+                                              std::shared_ptr<std::map<std::string, int>> matMap, std::string *err) {
+        std::shared_ptr<std::ifstream> matIStream = std::make_shared<std::ifstream>(filepath.c_str());
+        if (!matIStream) {
+            std::stringstream ss;
+            ss << "WARN: path to material [" << matId + "] not found" << std::endl;
+            if (err) {
+                (*err) += ss.str();
+            }
+            return false;
+        }
+        
+        LoadMtl(matMap, materials, matIStream);
+        return true;
+    }
+    
+    void LoadObj(std::shared_ptr<attrib_t> attrib, std::shared_ptr<std::vector<shape_t>> shapes,
+                 std::shared_ptr<std::vector<material_t>> materials, std::string *err,
+                 const char *filename, const char *mtl_basedir, bool baseurl,
+                 std::map<std::string, std::string> *resourceMap,
+                 std::shared_ptr<VROTaskQueue> taskQueue,
+                 std::function<void(bool)> onFinished,
+                 bool triangulate) {
+        attrib->vertices.clear();
+        attrib->normals.clear();
+        attrib->texcoords.clear();
+        shapes->clear();
+        
+        std::shared_ptr<std::ifstream> ifs = std::make_shared<std::ifstream>(filename);
+        if (!(*ifs)) {
+            pinfo("Failed to open file %s for OBJ", filename);
+            VROPlatformDispatchAsyncRenderer([onFinished] {
+                onFinished(false);
+            });
+            return;
+        }
+        
+        std::string baseDir;
+        if (mtl_basedir) {
+            baseDir = mtl_basedir;
+        }
+        
+        // The material file reader includes a task queue. We will wait on this
+        // task queue after reading the MTL files, so we know the MTL files are
+        // fully loaded before running loadOBJ
+        MaterialFileReader matFileReader;
+        if (resourceMap != nullptr) {
+            matFileReader = MaterialFileReader(resourceMap, taskQueue);
+        } else {
+            matFileReader = MaterialFileReader(baseDir, baseurl, taskQueue);
+        }
+        
+        // Read the MTL libs in the file
+        std::shared_ptr<std::map<std::string, int>> material_map = std::make_shared<std::map<std::string, int>>();
+        LoadMTLFiles(materials, material_map, err, ifs, &matFileReader);
+        pinfo("   MTL files queued for reading");
+        // Reset the stream
+        ifs->clear( );
+        ifs->seekg( 0, std::ios::beg );
+
+        std::weak_ptr<VROTaskQueue> taskQueue_w = taskQueue;
+
+        // Read the rest of the OBJ after the MTL is finished. We have to switch
+        // over to the rendering thread in order to wait on the task queue
+        VROPlatformDispatchAsyncRenderer([attrib, shapes, material_map, err, ifs, triangulate, onFinished, taskQueue_w] {
+            std::shared_ptr<VROTaskQueue> taskQueue_s = taskQueue_w.lock();
+            if (taskQueue_s) {
+                pinfo("   Reading MTL files (if any)...");
+                taskQueue_s->processTasksAsync([attrib, shapes, material_map, err, ifs, triangulate, onFinished] {
+                    pinfo("   MTL files read, loading OBJ");
+                    bool ret = LoadObj(attrib, shapes, material_map, err, ifs, triangulate);
+                    onFinished(ret);
+                });
+            }
+        });
+    }
+    
+    bool LoadObj(std::shared_ptr<attrib_t> attrib, std::shared_ptr<std::vector<shape_t>> shapes,
+                 std::shared_ptr<std::map<std::string, int>> material_map,
+                 std::string *err,
+                 std::shared_ptr<std::istream> inStream,
+                 bool triangulate) {
+        
+        std::vector<float> v;
+        std::vector<float> vn;
+        std::vector<float> vt;
+        std::vector<tag_t> tags;
+        std::vector<std::vector<vertex_index> > faceGroup;
+        std::string name;
+        
+        // material
+        int material = -1;
+        
+        shape_t shape;
+        
+        std::string linebuf;
+        while (inStream->peek() != -1) {
+            safeGetline(*inStream, linebuf);
+            
+            // Trim newline '\r\n' or '\n'
+            if (linebuf.size() > 0) {
+                if (linebuf[linebuf.size() - 1] == '\n')
+                    linebuf.erase(linebuf.size() - 1);
+            }
+            if (linebuf.size() > 0) {
+                if (linebuf[linebuf.size() - 1] == '\r')
+                    linebuf.erase(linebuf.size() - 1);
+            }
+            
+            // Skip if empty line.
+            if (linebuf.empty()) {
+                continue;
+            }
+            
+            // Skip leading space.
+            const char *token = linebuf.c_str();
+            token += strspn(token, " \t");
+            
+            assert(token);
+            if (token[0] == '\0') continue;  // empty line
+            
+            if (token[0] == '#') continue;  // comment line
+            
+            // vertex
+            if (token[0] == 'v' && IS_SPACE((token[1]))) {
+                token += 2;
+                float x, y, z;
+                parseFloat3(&x, &y, &z, &token);
+                v.push_back(x);
+                v.push_back(y);
+                v.push_back(z);
+                continue;
+            }
+            
+            // normal
+            if (token[0] == 'v' && token[1] == 'n' && IS_SPACE((token[2]))) {
+                token += 3;
+                float x, y, z;
+                parseFloat3(&x, &y, &z, &token);
+                vn.push_back(x);
+                vn.push_back(y);
+                vn.push_back(z);
+                continue;
+            }
+            
+            // texcoord
+            if (token[0] == 'v' && token[1] == 't' && IS_SPACE((token[2]))) {
+                token += 3;
+                float x, y;
+                parseFloat2(&x, &y, &token);
+                vt.push_back(x);
+                vt.push_back(y);
+                continue;
+            }
+            
+            // face
+            if (token[0] == 'f' && IS_SPACE((token[1]))) {
+                token += 2;
+                token += strspn(token, " \t");
+                
+                std::vector<vertex_index> face;
+                face.reserve(3);
+                
+                while (!IS_NEW_LINE(token[0])) {
+                    vertex_index vi = parseTriple(&token, static_cast<int>(v.size() / 3),
+                                                  static_cast<int>(vn.size() / 3),
+                                                  static_cast<int>(vt.size() / 2));
+                    face.push_back(vi);
+                    size_t n = strspn(token, " \t\r");
+                    token += n;
+                }
+                
+                // replace with emplace_back + std::move on C++11
+                faceGroup.push_back(std::vector<vertex_index>());
+                faceGroup[faceGroup.size() - 1].swap(face);
+                
+                continue;
+            }
+            
+            // use mtl
+            if ((0 == strncmp(token, "usemtl", 6)) && IS_SPACE((token[6]))) {
+                char namebuf[TINYOBJ_SSCANF_BUFFER_SIZE];
+                token += 7;
+#ifdef _MSC_VER
+                sscanf_s(token, "%s", namebuf, (unsigned)_countof(namebuf));
+#else
+                sscanf(token, "%s", namebuf);
+#endif
+                
+                int newMaterialId = -1;
+                if (material_map->find(namebuf) != material_map->end()) {
+                    newMaterialId = material_map->find(namebuf)->second;
+                } else {
+                    // { error!! material not found }
+                }
+                
+                if (newMaterialId != material) {
+                    // Create per-face material. Thus we don't add `shape` to `shapes` at
+                    // this time.
+                    // just clear `faceGroup` after `exportFaceGroupToShape()` call.
+                    exportFaceGroupToShape(&shape, faceGroup, tags, material, name,
+                                           triangulate);
+                    faceGroup.clear();
+                    material = newMaterialId;
+                }
+                
+                continue;
+            }
+            
+            // load mtl
+            if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) {
+                // MTL files are read before processing the OBJ (in LoadMTLFiles)
+                continue;
+            }
+            
+            // group name
+            if (token[0] == 'g' && IS_SPACE((token[1]))) {
+                // flush previous face group.
+                bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name,
+                                                  triangulate);
+                if (ret) {
+                    shapes->push_back(shape);
+                }
+                
+                shape = shape_t();
+                
+                // material = -1;
+                faceGroup.clear();
+                
+                std::vector<std::string> names;
+                names.reserve(2);
+                
+                while (!IS_NEW_LINE(token[0])) {
+                    std::string str = parseString(&token);
+                    names.push_back(str);
+                    token += strspn(token, " \t\r");  // skip tag
+                }
+                
+                assert(names.size() > 0);
+                
+                // names[0] must be 'g', so skip the 0th element.
+                if (names.size() > 1) {
+                    name = names[1];
+                } else {
+                    name = "";
+                }
+                
+                continue;
+            }
+            
+            // object name
+            if (token[0] == 'o' && IS_SPACE((token[1]))) {
+                // flush previous face group.
+                bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name,
+                                                  triangulate);
+                if (ret) {
+                    shapes->push_back(shape);
+                }
+                
+                // material = -1;
+                faceGroup.clear();
+                shape = shape_t();
+                
+                // @todo { multiple object name? }
+                char namebuf[TINYOBJ_SSCANF_BUFFER_SIZE];
+                token += 2;
+#ifdef _MSC_VER
+                sscanf_s(token, "%s", namebuf, (unsigned)_countof(namebuf));
+#else
+                sscanf(token, "%s", namebuf);
+#endif
+                name = std::string(namebuf);
+                
+                continue;
+            }
+            
+            if (token[0] == 't' && IS_SPACE(token[1])) {
+                tag_t tag;
+                
+                char namebuf[4096];
+                token += 2;
+#ifdef _MSC_VER
+                sscanf_s(token, "%s", namebuf, (unsigned)_countof(namebuf));
+#else
+                sscanf(token, "%s", namebuf);
+#endif
+                tag.name = std::string(namebuf);
+                token += tag.name.size() + 1;
+                
+                tag_sizes ts = parseTagTriple(&token);
+                
+                tag.intValues.resize(static_cast<size_t>(ts.num_ints));
+                for (size_t i = 0; i < static_cast<size_t>(ts.num_ints); ++i) {
+                    tag.intValues[i] = atoi(token);
+                    token += strcspn(token, "/ \t\r") + 1;
+                }
+                
+                tag.floatValues.resize(static_cast<size_t>(ts.num_floats));
+                for (size_t i = 0; i < static_cast<size_t>(ts.num_floats); ++i) {
+                    tag.floatValues[i] = parseFloat(&token);
+                    token += strcspn(token, "/ \t\r") + 1;
+                }
+                
+                tag.stringValues.resize(static_cast<size_t>(ts.num_strings));
+                for (size_t i = 0; i < static_cast<size_t>(ts.num_strings); ++i) {
+                    char stringValueBuffer[4096];
+                    
+#ifdef _MSC_VER
+                    sscanf_s(token, "%s", stringValueBuffer,
+                             (unsigned)_countof(stringValueBuffer));
+#else
+                    sscanf(token, "%s", stringValueBuffer);
+#endif
+                    tag.stringValues[i] = stringValueBuffer;
+                    token += tag.stringValues[i].size() + 1;
+                }
+                
+                tags.push_back(tag);
+            }
+            
+            // Ignore unknown command.
+        }
+        
+        bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name,
+                                          triangulate);
+        // exportFaceGroupToShape return false when `usemtl` is called in the last
+        // line.
+        // we also add `shape` to `shapes` when `shape.mesh` has already some
+        // faces(indices)
+        if (ret || shape.mesh.indices.size()) {
+            shapes->push_back(shape);
+        }
+        faceGroup.clear();  // for safety
+        
+        attrib->vertices.swap(v);
+        attrib->normals.swap(vn);
+        attrib->texcoords.swap(vt);
+        
+        return true;
+    }
+    
+    bool LoadMTLFiles(std::shared_ptr<std::vector<material_t>> materials,
+                      std::shared_ptr<std::map<std::string, int>> material_map,
+                      std::string *err,
+                      std::shared_ptr<std::istream> inStream, MaterialReader *readMatFn) {
+        
+        std::vector<float> v;
+        std::vector<float> vn;
+        std::vector<float> vt;
+        std::vector<tag_t> tags;
+        std::vector<std::vector<vertex_index> > faceGroup;
+        std::string name;
+        
+        std::string linebuf;
+        while (inStream->peek() != -1) {
+            safeGetline(*inStream, linebuf);
+            
+            // Trim newline '\r\n' or '\n'
+            if (linebuf.size() > 0) {
+                if (linebuf[linebuf.size() - 1] == '\n')
+                    linebuf.erase(linebuf.size() - 1);
+            }
+            if (linebuf.size() > 0) {
+                if (linebuf[linebuf.size() - 1] == '\r')
+                    linebuf.erase(linebuf.size() - 1);
+            }
+            
+            // Skip if empty line.
+            if (linebuf.empty()) {
+                continue;
+            }
+            
+            // Skip leading space.
+            const char *token = linebuf.c_str();
+            token += strspn(token, " \t");
+            
+            assert(token);
+            if (token[0] == '\0') continue;  // empty line
+            
+            if (token[0] == '#') continue;  // comment line
+            
+            // load mtl
+            if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) {
+                if (readMatFn) {
+                    token += 7;
+                    
+                    std::vector<std::string> filenames;
+                    SplitString(std::string(token), ' ', filenames);
+                    
+                    if (filenames.empty()) {
+                        if (err) {
+                            (*err) += "WARN: Looks like empty filename for mtllib. Use default material. \n";
+                        }
+                    } else {
+                        bool found = false;
+                        for (size_t s = 0; s < filenames.size(); s++) {
+                            
+                            std::string err_mtl;
+                            bool ok = (*readMatFn)(filenames[s].c_str(), materials, material_map,
+                                                   &err_mtl);
+                            pinfo("   Queued reading of material file [%s]", filenames[s].c_str());
+                            if (err && (!err_mtl.empty())) {
+                                (*err) += err_mtl; // This should be warn message.
+                            }
+                            
+                            if (ok) {
+                                found = true;
+                                break;
+                            }
+                        }
+                        
+                        if (!found) {
+                            if (err) {
+                                (*err) += "WARN: Failed to load material file(s). Use default material.\n";
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            // Ignore unknown command.
+        }
+        
+        return true;
+    }
+}  // namespace tinyobj
+
+#endif
+
+#endif  // TINY_OBJ_LOADER_H_