text: //
  // Copyright 2012-2016, Syoyo Fujita.
  //
  // Licensed under 2-clause BSD license.
  //
  
  //
  // version 0.9.22: Introduce `load_flags_t`.
  // version 0.9.20: Fixes creating per-face material using `usemtl`(#68)
  // version 0.9.17: Support n-polygon and crease tag(OpenSubdiv extension)
  // version 0.9.16: Make tinyobjloader header-only
  // version 0.9.15: Change API to handle no mtl file case correctly(#58)
  // version 0.9.14: Support specular highlight, bump, displacement and alpha
  // map(#53)
  // version 0.9.13: Report "Material file not found message" in `err`(#46)
  // version 0.9.12: Fix groups being ignored if they have 'usemtl' just before
  // 'g' (#44)
  // version 0.9.11: Invert `Tr` parameter(#43)
  // version 0.9.10: Fix seg fault on windows.
  // version 0.9.9 : Replace atof() with custom parser.
  // version 0.9.8 : Fix multi-materials(per-face material ID).
  // version 0.9.7 : Support multi-materials(per-face material ID) per
  // object/group.
  // version 0.9.6 : Support Ni(index of refraction) mtl parameter.
  //                 Parse transmittance material parameter correctly.
  // version 0.9.5 : Parse multiple group name.
  //                 Add support of specifying the base path to load material
  //                 file.
  // version 0.9.4 : Initial support of group tag(g)
  // version 0.9.3 : Fix parsing triple 'x/y/z'
  // version 0.9.2 : Add more .mtl load support
  // version 0.9.1 : Add initial .mtl load support
  // version 0.9.0 : Initial
  //
  
  //
  // Use this in *one* .cc
  //   #define TINYOBJLOADER_IMPLEMENTATION
  //   #include "tiny_obj_loader.h"
  //
  
  #ifndef TINY_OBJ_LOADER_H_
  #define TINY_OBJ_LOADER_H_
  
  #include <cmath>
  #include <map>
  #include <string>
  #include <vector>
  
  namespace tinyobj {
  
    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
      std::map<std::string, std::string> unknown_parameter;
    } material_t;
  
    typedef struct {
      std::string name;
  
      std::vector<int> intValues;
      std::vector<float> floatValues;
      std::vector<std::string> stringValues;
    } tag_t;
  
    typedef struct {
      std::vector<float> positions;
      std::vector<float> normals;
      std::vector<float> texcoords;
      std::vector<unsigned int> indices;
      std::vector<unsigned char>
        num_vertices;              // The number of vertices per face. 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;
  
    typedef enum {
      triangulation = 1, // used whether triangulate polygon face in .obj
      calculate_normals =
      2, // used whether calculate the normals if the .obj normals are empty
  // Some nice stuff here
    } load_flags_t;
  
    class float3 {
    public:
      float3() : x(0.0f), y(0.0f), z(0.0f) {}
  
      float3(float coord_x, float coord_y, float coord_z)
        : x(coord_x), y(coord_y), z(coord_z) {}
  
      float3(const float3 &from, const float3 &to) {
        coord[0] = to.coord[0] - from.coord[0];
        coord[1] = to.coord[1] - from.coord[1];
        coord[2] = to.coord[2] - from.coord[2];
      }
  
      float3 crossproduct(const float3 &vec) {
        float a = y * vec.z - z * vec.y;
        float b = z * vec.x - x * vec.z;
        float c = x * vec.y - y * vec.x;
        return float3(a, b, c);
      }
  
      void normalize() {
        const float length = std::sqrt(
          (coord[0] * coord[0]) + (coord[1] * coord[1]) + (coord[2] * coord[2]));
        if (length != 1) {
          coord[0] = (coord[0] / length);
          coord[1] = (coord[1] / length);
          coord[2] = (coord[2] / length);
        }
      }
  
    private:
      union {
        float coord[3];
        struct {
          float x, y, z;
        };
      };
    };
  
    class MaterialReader {
    public:
      MaterialReader() {}
      virtual ~MaterialReader();
  
      virtual bool operator()(const std::string &matId,
        std::vector<material_t> &materials,
        std::map<std::string, int> &matMap,
        std::string &err) = 0;
    };
  
    class MaterialFileReader : public MaterialReader {
    public:
      MaterialFileReader(const std::string &mtl_basepath)
        : m_mtlBasePath(mtl_basepath) {}
      virtual ~MaterialFileReader() {}
      virtual bool operator()(const std::string &matId,
        std::vector<material_t> &materials,
        std::map<std::string, int> &matMap, std::string &err);
  
    private:
      std::string m_mtlBasePath;
    };
  
    /// Loads .obj from a file.
    /// 'shapes' will be filled with parsed shape data
    /// The function returns error string.
    /// Returns true when loading .obj become success.
    /// Returns warning and error message into `err`
    /// 'mtl_basepath' is optional, and used for base path for .mtl file.
    /// 'optional flags
    bool LoadObj(std::vector<shape_t> &shapes,       // [output]
      std::vector<material_t> &materials, // [output]
      std::string &err,                   // [output]
      const char *filename, const char *mtl_basepath = NULL,
      unsigned int flags = 1);
  
    /// 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::vector<shape_t> &shapes,       // [output]
      std::vector<material_t> &materials, // [output]
      std::string &err,                   // [output]
      std::istream &inStream, MaterialReader &readMatFn,
      unsigned int flags = 1);
  
    /// Loads materials into std::map
    void LoadMtl(std::map<std::string, int> &material_map, // [output]
      std::vector<material_t> &materials,       // [output]
      std::istream &inStream);
  }
  
  #ifdef TINYOBJLOADER_IMPLEMENTATION
  #include <cassert>
  #include <cctype>
  #include <cmath>
  #include <cstddef>
  #include <cstdlib>
  #include <cstring>
  
  #include <fstream>
  #include <sstream>
  
  #include "tiny_obj_loader.h"
  
  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;
    };
  
    // for std::map
    static inline bool operator<(const vertex_index &a, const vertex_index &b) {
      if (a.v_idx != b.v_idx)
        return (a.v_idx < b.v_idx);
      if (a.vn_idx != b.vn_idx)
        return (a.vn_idx < b.vn_idx);
      if (a.vt_idx != b.vt_idx)
        return (a.vt_idx < b.vt_idx);
  
      return false;
    }
  
    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
    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 += (char)c;
        }
      }
    }
  
  #define IS_SPACE(x) (((x) == ' ') || ((x) == '\t'))
  #define IS_DIGIT(x) ((unsigned int)((x) - '0') < (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.
      while ((end_not_reached = (curr != s_end)) && IS_DIGIT(*curr)) {
        mantissa *= 10;
        mantissa += static_cast<int>(*curr - 0x30);
        curr++;
        read++;
      }
  
      // 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;
        while ((end_not_reached = (curr != s_end)) && IS_DIGIT(*curr)) {
          // NOTE: Don't use powf here, it will absolutely murder precision.
          mantissa += static_cast<int>(*curr - 0x30) * pow(10.0, -read);
          read++;
          curr++;
        }
      }
      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.
        if ((end_not_reached = (curr != s_end)) && (*curr == '+' || *curr == '-')) {
          exp_sign = *curr;
          curr++;
        }
        else if (IS_DIGIT(*curr)) { /* Pass through. */
        }
        else {
          // Empty E is not allowed.
          goto fail;
        }
  
        read = 0;
        while ((end_not_reached = (curr != s_end)) && IS_DIGIT(*curr)) {
          exponent *= 10;
          exponent += static_cast<int>(*curr - 0x30);
          curr++;
          read++;
        }
        exponent *= (exp_sign == '+' ? 1 : -1);
        if (read == 0)
          goto fail;
      }
  
    assemble:
      *result =
        (sign == '+' ? 1 : -1) * ldexp(mantissa * pow(5.0, exponent), exponent);
      return true;
    fail:
      return false;
    }
    static inline float parseFloat(const char *&token) {
      token += strspn(token, " \t");
  #ifdef TINY_OBJ_LOADER_OLD_FLOAT_PARSER
      float f = (float)atof(token);
      token += strcspn(token, " \t\r");
  #else
      const char *end = token + strcspn(token, " \t\r");
      double val = 0.0;
      tryParseDouble(token, end, &val);
      float f = static_cast<float>(val);
      token = end;
  #endif
      return f;
    }
  
    static inline void parseFloat2(float &x, float &y, const char *&token) {
      x = parseFloat(token);
      y = parseFloat(token);
    }
  
    static inline void parseFloat3(float &x, float &y, float &z,
      const char *&token) {
      x = parseFloat(token);
      y = parseFloat(token);
      z = parseFloat(token);
    }
  
    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: 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 unsigned int
      updateVertex(std::map<vertex_index, unsigned int> &vertexCache,
        std::vector<float> &positions, std::vector<float> &normals,
        std::vector<float> &texcoords,
        const std::vector<float> &in_positions,
        const std::vector<float> &in_normals,
        const std::vector<float> &in_texcoords, const vertex_index &i) {
      const std::map<vertex_index, unsigned int>::iterator it = vertexCache.find(i);
  
      if (it != vertexCache.end()) {
        // found cache
        return it->second;
      }
  
      assert(in_positions.size() > static_cast<unsigned int>(3 * i.v_idx + 2));
  
      positions.push_back(in_positions[3 * static_cast<size_t>(i.v_idx) + 0]);
      positions.push_back(in_positions[3 * static_cast<size_t>(i.v_idx) + 1]);
      positions.push_back(in_positions[3 * static_cast<size_t>(i.v_idx) + 2]);
  
      if ((i.vn_idx >= 0) &&
        (static_cast<size_t>(i.vn_idx * 3 + 2) < in_normals.size())) {
        normals.push_back(in_normals[3 * static_cast<size_t>(i.vn_idx) + 0]);
        normals.push_back(in_normals[3 * static_cast<size_t>(i.vn_idx) + 1]);
        normals.push_back(in_normals[3 * static_cast<size_t>(i.vn_idx) + 2]);
      }
  
      if ((i.vt_idx >= 0) &&
        (static_cast<size_t>(i.vt_idx * 2 + 1) < in_texcoords.size())) {
        texcoords.push_back(in_texcoords[2 * static_cast<size_t>(i.vt_idx) + 0]);
        texcoords.push_back(in_texcoords[2 * static_cast<size_t>(i.vt_idx) + 1]);
      }
  
      unsigned int idx = static_cast<unsigned int>(positions.size() / 3 - 1);
      vertexCache[i] = idx;
  
      return idx;
    }
  
    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.unknown_parameter.clear();
    }
  
    static bool exportFaceGroupToShape(
      shape_t &shape, std::map<vertex_index, unsigned int> vertexCache,
      const std::vector<float> &in_positions,
      const std::vector<float> &in_normals,
      const std::vector<float> &in_texcoords,
      const std::vector<std::vector<vertex_index> > &faceGroup,
      std::vector<tag_t> &tags, const int material_id, const std::string &name,
      bool clearCache, unsigned int flags, std::string &err) {
      if (faceGroup.empty()) {
        return false;
      }
  
      bool triangulate((flags & triangulation) == triangulation);
      bool normals_calculation((flags & calculate_normals) == calculate_normals);
  
      // 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];
  
            unsigned int v0 = updateVertex(
              vertexCache, shape.mesh.positions, shape.mesh.normals,
              shape.mesh.texcoords, in_positions, in_normals, in_texcoords, i0);
            unsigned int v1 = updateVertex(
              vertexCache, shape.mesh.positions, shape.mesh.normals,
              shape.mesh.texcoords, in_positions, in_normals, in_texcoords, i1);
            unsigned int v2 = updateVertex(
              vertexCache, shape.mesh.positions, shape.mesh.normals,
              shape.mesh.texcoords, in_positions, in_normals, in_texcoords, i2);
  
            shape.mesh.indices.push_back(v0);
            shape.mesh.indices.push_back(v1);
            shape.mesh.indices.push_back(v2);
  
            shape.mesh.num_vertices.push_back(3);
            shape.mesh.material_ids.push_back(material_id);
          }
        }
        else {
  
          for (size_t k = 0; k < npolys; k++) {
            unsigned int v =
              updateVertex(vertexCache, shape.mesh.positions, shape.mesh.normals,
                shape.mesh.texcoords, in_positions, in_normals,
                in_texcoords, face[k]);
  
            shape.mesh.indices.push_back(v);
          }
  
          shape.mesh.num_vertices.push_back(static_cast<unsigned char>(npolys));
          shape.mesh.material_ids.push_back(material_id); // per face
        }
      }
  
      if (normals_calculation && shape.mesh.normals.empty()) {
        const size_t nIndexs = shape.mesh.indices.size();
        if (nIndexs % 3 == 0) {
          shape.mesh.normals.resize(shape.mesh.positions.size());
          for (size_t iIndices = 0; iIndices < nIndexs; iIndices += 3) {
            float3 v1, v2, v3;
            memcpy(&v1, &shape.mesh.positions[shape.mesh.indices[iIndices] * 3],
              sizeof(float3));
            memcpy(&v2, &shape.mesh.positions[shape.mesh.indices[iIndices + 1] * 3],
              sizeof(float3));
            memcpy(&v3, &shape.mesh.positions[shape.mesh.indices[iIndices + 2] * 3],
              sizeof(float3));
  
            float3 v12(v1, v2);
            float3 v13(v1, v3);
  
            float3 normal = v12.crossproduct(v13);
            normal.normalize();
  
            memcpy(&shape.mesh.normals[shape.mesh.indices[iIndices] * 3], &normal,
              sizeof(float3));
            memcpy(&shape.mesh.normals[shape.mesh.indices[iIndices + 1] * 3],
              &normal, sizeof(float3));
            memcpy(&shape.mesh.normals[shape.mesh.indices[iIndices + 2] * 3],
              &normal, sizeof(float3));
          }
        }
        else {
  
          std::stringstream ss;
          ss << "WARN: The shape " << name
            << " does not have a topology of triangles, therfore the normals "
            "calculation could not be performed. Select the "
            "tinyobj::triangulation flag for this object."
            << std::endl;
          err += ss.str();
        }
      }
  
      shape.name = name;
      shape.mesh.tags.swap(tags);
  
      if (clearCache)
        vertexCache.clear();
  
      return true;
    }
  
    void LoadMtl(std::map<std::string, int> &material_map,
      std::vector<material_t> &materials, std::istream &inStream) {
  
      // Create a default material anyway.
      material_t material;
      InitMaterial(material);
  
      while (inStream.peek() != -1) {
        std::string linebuf;
        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;
          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 += 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);
          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;
        }
  
        // ambient texture
        if ((0 == strncmp(token, "map_Ka", 6)) && IS_SPACE(token[6])) {
          token += 7;
          material.ambient_texname = token;
          continue;
        }
  
        // diffuse texture
        if ((0 == strncmp(token, "map_Kd", 6)) && IS_SPACE(token[6])) {
          token += 7;
          material.diffuse_texname = token;
          continue;
        }
  
        // specular texture
        if ((0 == strncmp(token, "map_Ks", 6)) && IS_SPACE(token[6])) {
          token += 7;
          material.specular_texname = token;
          continue;
        }
  
        // specular highlight texture
        if ((0 == strncmp(token, "map_Ns", 6)) && IS_SPACE(token[6])) {
          token += 7;
          material.specular_highlight_texname = token;
          continue;
        }
  
        // bump texture
        if ((0 == strncmp(token, "map_bump", 8)) && IS_SPACE(token[8])) {
          token += 9;
          material.bump_texname = token;
          continue;
        }
  
        // alpha texture
        if ((0 == strncmp(token, "map_d", 5)) && IS_SPACE(token[5])) {
          token += 6;
          material.alpha_texname = token;
          continue;
        }
  
        // bump texture
        if ((0 == strncmp(token, "bump", 4)) && IS_SPACE(token[4])) {
          token += 5;
          material.bump_texname = token;
          continue;
        }
  
        // displacement texture
        if ((0 == strncmp(token, "disp", 4)) && IS_SPACE(token[4])) {
          token += 5;
          material.displacement_texname = token;
          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::vector<material_t> &materials,
      std::map<std::string, int> &matMap,
      std::string &err) {
      std::string filepath;
  
      if (!m_mtlBasePath.empty()) {
        filepath = std::string(m_mtlBasePath) + matId;
      }
      else {
        filepath = matId;
      }
  
      std::ifstream matIStream(filepath.c_str());
      LoadMtl(matMap, materials, matIStream);
      if (!matIStream) {
        std::stringstream ss;
        ss << "WARN: Material file [ " << filepath
          << " ] not found. Created a default material.";
        err += ss.str();
      }
      return true;
    }
  
    bool LoadObj(std::vector<shape_t> &shapes,       // [output]
      std::vector<material_t> &materials, // [output]
      std::string &err, const char *filename, const char *mtl_basepath,
      unsigned int flags) {
  
      shapes.clear();
  
      std::stringstream errss;
  
      std::ifstream ifs(filename);
      if (!ifs) {
        errss << "Cannot open file [" << filename << "]" << std::endl;
        err = errss.str();
        return false;
      }
  
      std::string basePath;
      if (mtl_basepath) {
        basePath = mtl_basepath;
      }
      MaterialFileReader matFileReader(basePath);
  
      return LoadObj(shapes, materials, err, ifs, matFileReader, flags);
    }
  
    bool LoadObj(std::vector<shape_t> &shapes,       // [output]
      std::vector<material_t> &materials, // [output]
      std::string &err, std::istream &inStream,
      MaterialReader &readMatFn, unsigned int flags) {
  
      std::stringstream errss;
  
      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
      std::map<std::string, int> material_map;
      std::map<vertex_index, unsigned int> vertexCache;
      int material = -1;
  
      shape_t shape;
  
      while (inStream.peek() != -1) {
        std::string linebuf;
        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[namebuf];
          }
          else {
            // { error!! material not found }
          }
  
          if (newMaterialId != material) {
            // Create per-face material
            exportFaceGroupToShape(shape, vertexCache, v, vn, vt, faceGroup, tags,
              material, name, true, flags, err);
            faceGroup.clear();
            material = newMaterialId;
          }
  
          continue;
        }
  
        // load mtl
        if ((0 == strncmp(token, "mtllib", 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
  
          std::string err_mtl;
          bool ok = readMatFn(namebuf, materials, material_map, err_mtl);
          err += err_mtl;
  
          if (!ok) {
            faceGroup.clear(); // for safety
            return false;
          }
  
          continue;
        }
  
        // group name
        if (token[0] == 'g' && IS_SPACE((token[1]))) {
  
          // flush previous face group.
          bool ret =
            exportFaceGroupToShape(shape, vertexCache, v, vn, vt, faceGroup, tags,
              material, name, true, flags, err);
          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, vertexCache, v, vn, vt, faceGroup, tags,
              material, name, true, flags, err);
          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, vertexCache, v, vn, vt, faceGroup,
        tags, material, name, true, flags, err);
      if (ret) {
        shapes.push_back(shape);
      }
      faceGroup.clear(); // for safety
  
      err += errss.str();
  
      return true;
    }
  
  } // namespace
  
  #endif
  
  #endif // TINY_OBJ_LOADER_H_