Add more support for parsing texture options.

Add more unit testing for texture options.

README.md

@@ -52,6 +52,7 @@ TinyObjLoader is successfully used in ...
 ### New version(v1.0.x)
 
 * Loading models in Vulkan Tutorial https://vulkan-tutorial.com/Loading_models
+* .obj viewer with Metal https://github.com/middlefeng/NuoModelViewer/tree/master
 * Your project here!
 
 ### Old version(v0.9.x)
@@ -73,6 +74,11 @@ TinyObjLoader is successfully used in ...
 * FireRays SDK https://github.com/GPUOpen-LibrariesAndSDKs/FireRays_SDK
 * parg, tiny C library of various graphics utilities and GL demos https://github.com/prideout/parg
 * Opengl unit of ChronoEngine https://github.com/projectchrono/chrono-opengl
+* Point Based Global Illumination on modern GPU https://pbgi.wordpress.com/code-source/
+* Fast OBJ file importing and parsing in CUDA http://researchonline.jcu.edu.au/42515/1/2015.CVM.OBJCUDA.pdf
+* Sorted Shading for Uni-Directional Pathtracing by Joshua Bainbridge https://nccastaff.bournemouth.ac.uk/jmacey/MastersProjects/MSc15/02Josh/joshua_bainbridge_thesis.pdf
+* GeeXLab http://www.geeks3d.com/hacklab/20160531/geexlab-0-12-0-0-released-for-windows/
+
 
 ## Features
 
@@ -83,6 +89,7 @@ TinyObjLoader is successfully used in ...
 * Material
   * Unknown material attributes are returned as key-value(value is string) map.
 * Crease tag('t'). This is OpenSubdiv specific(not in wavefront .obj specification)
+* PBR material extension for .MTL. Its proposed here: http://exocortex.com/blog/extending_wavefront_mtl_to_support_pbr
 * Callback API for custom loading.
 
 
@@ -90,6 +97,9 @@ TinyObjLoader is successfully used in ...
 
 * [ ] Fix obj_sticker example.
 * [ ] More unit test codes.
+* [ ] Texture options
+* [ ] Normal vector generation
+  * [ ] Support smoothing groups
 
 ## License
 

examples/viewer/viewer.cc

@@ -8,6 +8,7 @@
 #include <cstdlib>
 #include <iostream>
 #include <limits>
+#include <map>
 #include <string>
 #include <vector>
 
@@ -26,12 +27,24 @@
 
 #include "trackball.h"
 
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
 #ifdef _WIN32
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include <mmsystem.h>
 #include <windows.h>
+
+#ifdef max
+ #undef max
+#endif
+
+#ifdef min
+ #undef min
+#endif
+
+#include <mmsystem.h>
 #ifdef __cplusplus
 }
 #endif
@@ -112,6 +125,7 @@ class timerutil {
 typedef struct {
   GLuint vb;  // vertex buffer
   int numTriangles;
+  size_t material_id;
 } DrawObject;
 
 std::vector<DrawObject> gDrawObjects;
@@ -163,10 +177,11 @@ void CalcNormal(float N[3], float v0[3], float v1[3], float v2[3]) {
 
 bool LoadObjAndConvert(float bmin[3], float bmax[3],
                        std::vector<DrawObject>* drawObjects,
+                       std::vector<tinyobj::material_t>& materials,
+                       std::map<std::string, GLuint>& textures,
                        const char* filename) {
   tinyobj::attrib_t attrib;
   std::vector<tinyobj::shape_t> shapes;
-  std::vector<tinyobj::material_t> materials;
 
   timerutil tm;
 
@@ -194,6 +209,43 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3],
   printf("# of materials = %d\n", (int)materials.size());
   printf("# of shapes    = %d\n", (int)shapes.size());
 
+  // Append `default` material
+  materials.push_back(tinyobj::material_t());
+
+  // Load diffuse textures
+  {
+      for (size_t m = 0; m < materials.size(); m++) {
+          tinyobj::material_t* mp = &materials[m];
+          
+          if (mp->diffuse_texname.length() > 0) {
+              // Only load the texture if it is not already loaded
+              if (textures.find(mp->diffuse_texname) == textures.end()) {
+                  GLuint texture_id;
+                  int w, h;
+                  int comp;
+                  unsigned char* image = stbi_load(mp->diffuse_texname.c_str(), &w, &h, &comp, STBI_default);
+                  if (image == nullptr) {
+                      std::cerr << "Unable to load texture: " << mp->diffuse_texname << std::endl;
+                      exit(1);
+                  }
+                  glGenTextures(1, &texture_id);
+                  glBindTexture(GL_TEXTURE_2D, texture_id);
+                  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+                  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+                  if (comp == 3) {
+                      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
+                  }
+                  else if (comp == 4) {
+                      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
+                  }
+                  glBindTexture(GL_TEXTURE_2D, 0);
+                  stbi_image_free(image);
+                  textures.insert(std::make_pair(mp->diffuse_texname, texture_id));
+              }
+          }
+      }
+  }
+
   bmin[0] = bmin[1] = bmin[2] = std::numeric_limits<float>::max();
   bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits<float>::max();
 
@@ -206,6 +258,36 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3],
         tinyobj::index_t idx1 = shapes[s].mesh.indices[3 * f + 1];
         tinyobj::index_t idx2 = shapes[s].mesh.indices[3 * f + 2];
         
+        int current_material_id = shapes[s].mesh.material_ids[f];
+
+        if ((current_material_id < 0) || (current_material_id >= static_cast<int>(materials.size()))) {
+          // Invaid material ID. Use default material.
+          current_material_id = materials.size() - 1; // Default material is added to the last item in `materials`.
+        }
+        //if (current_material_id >= materials.size()) {
+        //    std::cerr << "Invalid material index: " << current_material_id << std::endl;
+        //}
+        //
+        float diffuse[3];
+        for (size_t i = 0; i < 3; i++) {
+            diffuse[i] = materials[current_material_id].diffuse[i];
+        }
+        float tc[3][2];
+        if (attrib.texcoords.size() > 0) {
+            assert(attrib.texcoords.size() > 2 * idx0.texcoord_index + 1);
+            assert(attrib.texcoords.size() > 2 * idx1.texcoord_index + 1);
+            assert(attrib.texcoords.size() > 2 * idx2.texcoord_index + 1);
+            tc[0][0] = attrib.texcoords[2 * idx0.texcoord_index];
+            tc[0][1] = 1.0f - attrib.texcoords[2 * idx0.texcoord_index + 1];
+            tc[1][0] = attrib.texcoords[2 * idx1.texcoord_index];
+            tc[1][1] = 1.0f - attrib.texcoords[2 * idx1.texcoord_index + 1];
+            tc[2][0] = attrib.texcoords[2 * idx2.texcoord_index];
+            tc[2][1] = 1.0f - attrib.texcoords[2 * idx2.texcoord_index + 1];
+        } else {
+            std::cerr << "Texcoordinates are not defined" << std::endl;
+            exit(2);
+        }
+
         float v[3][3];
         for (int k = 0; k < 3; k++) {
           int f0 = idx0.vertex_index;
@@ -227,7 +309,6 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3],
         }
 
         float n[3][3];
-
         if (attrib.normals.size() > 0) {
           int f0 = idx0.normal_index;
           int f1 = idx1.normal_index;
@@ -258,8 +339,14 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3],
           vb.push_back(n[k][0]);
           vb.push_back(n[k][1]);
           vb.push_back(n[k][2]);
-          // Use normal as color.
-          float c[3] = {n[k][0], n[k][1], n[k][2]};
+          // Combine normal and diffuse to get color.
+          float normal_factor = 0.2;
+          float diffuse_factor = 1 - normal_factor;
+          float c[3] = {
+              n[k][0] * normal_factor + diffuse[0] * diffuse_factor,
+              n[k][1] * normal_factor + diffuse[1] * diffuse_factor,
+              n[k][2] * normal_factor + diffuse[2] * diffuse_factor
+          };
           float len2 = c[0] * c[0] + c[1] * c[1] + c[2] * c[2];
           if (len2 > 0.0f) {
             float len = sqrtf(len2);
@@ -271,17 +358,29 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3],
           vb.push_back(c[0] * 0.5 + 0.5);
           vb.push_back(c[1] * 0.5 + 0.5);
           vb.push_back(c[2] * 0.5 + 0.5);
+          
+          vb.push_back(tc[k][0]);
+          vb.push_back(tc[k][1]);
         }
       }
 
       o.vb = 0;
       o.numTriangles = 0;
+
+      // OpenGL viewer does not support texturing with per-face material.
+      if (shapes[s].mesh.material_ids.size() > 0 && shapes[s].mesh.material_ids.size() > s) {
+          // Base case
+          o.material_id = shapes[s].mesh.material_ids[s];
+      } else {
+          o.material_id = materials.size() - 1; // = ID for default material.
+      }
+          
       if (vb.size() > 0) {
         glGenBuffers(1, &o.vb);
         glBindBuffer(GL_ARRAY_BUFFER, o.vb);
         glBufferData(GL_ARRAY_BUFFER, vb.size() * sizeof(float), &vb.at(0),
                      GL_STATIC_DRAW);
-        o.numTriangles = vb.size() / 9 / 3;
+        o.numTriangles = vb.size() / (3 + 3 + 3 + 2) * 3;
         printf("shape[%d] # of triangles = %d\n", static_cast<int>(s),
                o.numTriangles);
       }
@@ -395,13 +494,13 @@ void motionFunc(GLFWwindow* window, double mouse_x, double mouse_y) {
   prevMouseY = mouse_y;
 }
 
-void Draw(const std::vector<DrawObject>& drawObjects) {
+void Draw(const std::vector<DrawObject>& drawObjects, std::vector<tinyobj::material_t>& materials, std::map<std::string, GLuint>& textures) {
   glPolygonMode(GL_FRONT, GL_FILL);
   glPolygonMode(GL_BACK, GL_FILL);
 
   glEnable(GL_POLYGON_OFFSET_FILL);
   glPolygonOffset(1.0, 1.0);
-  glColor3f(1.0f, 1.0f, 1.0f);
+  GLsizei stride = (3 + 3 + 3 + 2) * sizeof(float);
   for (size_t i = 0; i < drawObjects.size(); i++) {
     DrawObject o = drawObjects[i];
     if (o.vb < 1) {
@@ -412,12 +511,20 @@ void Draw(const std::vector<DrawObject>& drawObjects) {
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_NORMAL_ARRAY);
     glEnableClientState(GL_COLOR_ARRAY);
-    glVertexPointer(3, GL_FLOAT, 36, (const void*)0);
-    glNormalPointer(GL_FLOAT, 36, (const void*)(sizeof(float) * 3));
-    glColorPointer(3, GL_FLOAT, 36, (const void*)(sizeof(float) * 6));
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    std::string diffuse_texname = materials[o.material_id].diffuse_texname;
+    if (diffuse_texname.length() > 0) {
+        glBindTexture(GL_TEXTURE_2D, textures[diffuse_texname]);
+    }
+    glVertexPointer(3, GL_FLOAT, stride, (const void*)0);
+    glNormalPointer(GL_FLOAT, stride, (const void*)(sizeof(float) * 3));
+    glColorPointer(3, GL_FLOAT, stride, (const void*)(sizeof(float) * 6));
+    glTexCoordPointer(2, GL_FLOAT, stride, (const void*)(sizeof(float) * 9));
 
     glDrawArrays(GL_TRIANGLES, 0, 3 * o.numTriangles);
     CheckErrors("drawarrays");
+    glBindTexture(GL_TEXTURE_2D, 0);
   }
 
   // draw wireframe
@@ -436,8 +543,11 @@ void Draw(const std::vector<DrawObject>& drawObjects) {
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_NORMAL_ARRAY);
     glDisableClientState(GL_COLOR_ARRAY);
-    glVertexPointer(3, GL_FLOAT, 36, (const void*)0);
-    glNormalPointer(GL_FLOAT, 36, (const void*)(sizeof(float) * 3));
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glVertexPointer(3, GL_FLOAT, stride, (const void*)0);
+    glNormalPointer(GL_FLOAT, stride, (const void*)(sizeof(float) * 3));
+    glColorPointer(3, GL_FLOAT, stride, (const void*)(sizeof(float) * 6));
+    glTexCoordPointer(2, GL_FLOAT, stride, (const void*)(sizeof(float) * 9));
 
     glDrawArrays(GL_TRIANGLES, 0, 3 * o.numTriangles);
     CheckErrors("drawarrays");
@@ -498,7 +608,9 @@ int main(int argc, char** argv) {
   reshapeFunc(window, width, height);
 
   float bmin[3], bmax[3];
-  if (false == LoadObjAndConvert(bmin, bmax, &gDrawObjects, argv[1])) {
+  std::vector<tinyobj::material_t> materials;
+  std::map<std::string, GLuint> textures;
+  if (false == LoadObjAndConvert(bmin, bmax, &gDrawObjects, materials, textures, argv[1])) {
     return -1;
   }
 
@@ -516,6 +628,7 @@ int main(int argc, char** argv) {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     glEnable(GL_DEPTH_TEST);
+    glEnable(GL_TEXTURE_2D);
 
     // camera & rotate
     glMatrixMode(GL_MODELVIEW);
@@ -533,7 +646,7 @@ int main(int argc, char** argv) {
     glTranslatef(-0.5 * (bmax[0] + bmin[0]), -0.5 * (bmax[1] + bmin[1]),
                  -0.5 * (bmax[2] + bmin[2]));
 
-    Draw(gDrawObjects);
+    Draw(gDrawObjects, materials, textures);
 
     glfwSwapBuffers(window);
   }

examples/voxelize/main.cc

@@ -0,0 +1,74 @@
+#define VOXELIZER_IMPLEMENTATION
+#include "voxelizer.h"
+
+#define TINYOBJLOADER_IMPLEMENTATION
+#include "../../tiny_obj_loader.h"
+
+bool Voxelize(const char* filename, float voxelsizex, float voxelsizey, float voxelsizez, float precision)
+{
+    tinyobj::attrib_t attrib;
+    std::vector<tinyobj::shape_t> shapes;
+    std::vector<tinyobj::material_t> materials;
+    std::string err;
+    bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, filename);
+
+    if (!err.empty()) {
+      printf("err: %s\n", err.c_str());
+    }
+
+    if (!ret) {
+      printf("failed to load : %s\n", filename);
+      return false;
+    }
+
+    if (shapes.size() == 0) {
+      printf("err: # of shapes are zero.\n");
+      return false;
+    }
+
+    // Only use first shape.
+    {
+        vx_mesh_t* mesh;
+        vx_mesh_t* result;
+
+        mesh = vx_mesh_alloc(attrib.vertices.size(), shapes[0].mesh.indices.size());
+
+        for (size_t f = 0; f < shapes[0].mesh.indices.size(); f++) {
+            mesh->indices[f] = shapes[0].mesh.indices[f].vertex_index;
+        }
+
+        for (size_t v = 0; v < attrib.vertices.size() / 3; v++) {
+            mesh->vertices[v].x = attrib.vertices[3*v+0];
+            mesh->vertices[v].y = attrib.vertices[3*v+1];
+            mesh->vertices[v].z = attrib.vertices[3*v+2];
+        }
+
+        result = vx_voxelize(mesh, voxelsizex, voxelsizey, voxelsizez, precision);
+
+        printf("Number of vertices: %ld\n", result->nvertices);
+        printf("Number of indices: %ld\n", result->nindices);
+    }
+    return true;
+}
+
+
+int
+main(
+  int argc,
+  char** argv)
+{
+  if (argc < 4) {
+    printf("Usage: voxelize input.obj voxelsizex voxelsizey voxelsizez precision\n");
+    exit(-1);
+  }
+
+  const char* filename = argv[1];
+  float voxelsizex = atof(argv[2]);
+  float voxelsizey = atof(argv[3]);
+  float voxelsizez = atof(argv[4]);
+  float prec = atof(argv[5]);
+  bool ret = Voxelize(filename, voxelsizex, voxelsizey, voxelsizez, prec);
+
+  return ret ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+

experimental/README.md

@@ -0,0 +1,5 @@
+Experimental code for .obj loader.
+
+* Multi-threaded optimized parser : tinyobj_loader_opt.h
+* zstd compressed .obj support. `--with-zstd` premake option.
+* gzip compressed .obj support. `--with-zlib` premake option.

experimental/premake4.lua

@@ -3,6 +3,11 @@ newoption {
    description = "Build with zlib."
 }
 
+newoption {
+   trigger     = "with-zstd",
+   description = "Build with ZStandard compression."
+}
+
 solution "objview"
 	-- location ( "build" )
 	configurations { "Release", "Debug" }
@@ -23,6 +28,15 @@ solution "objview"
 		links { 'z' }
 	end	
 
+	if _OPTIONS['with-zstd'] then
+		print("with-zstd")
+		defines { 'ENABLE_ZSTD' }
+		-- Set path to zstd installed dir.
+		includedirs { '$$HOME/local/include' }
+		libdirs { '$$HOME/local/lib' }
+		links { 'zstd' }
+	end	
+
 	-- Uncomment if you want address sanitizer(gcc/clang only)
 	--buildoptions { "-fsanitize=address" }
 	--linkoptions { "-fsanitize=address" }

experimental/viewer.cc

@@ -16,6 +16,10 @@
 #include <zlib.h>
 #endif
 
+#if defined(ENABLE_ZSTD)
+#include <zstd.h>
+#endif
+
 #include <GL/glew.h>
 
 #ifdef __APPLE__
@@ -182,6 +186,71 @@ bool gz_load(std::vector<char>* buf, const char* filename)
 #endif
 }
 
+#ifdef ENABLE_ZSTD
+static off_t fsize_X(const char *filename)
+{
+    struct stat st;
+    if (stat(filename, &st) == 0) return st.st_size;
+    /* error */
+    printf("stat: %s : %s \n", filename, strerror(errno));
+    exit(1);
+}
+
+static FILE* fopen_X(const char *filename, const char *instruction)
+{
+    FILE* const inFile = fopen(filename, instruction);
+    if (inFile) return inFile;
+    /* error */
+    printf("fopen: %s : %s \n", filename, strerror(errno));
+    exit(2);
+}
+
+static void* malloc_X(size_t size)
+{
+    void* const buff = malloc(size);
+    if (buff) return buff;
+    /* error */
+    printf("malloc: %s \n", strerror(errno));
+    exit(3);
+}
+#endif
+
+bool zstd_load(std::vector<char>* buf, const char* filename)
+{
+#ifdef ENABLE_ZSTD
+    off_t const buffSize = fsize_X(filename);
+    FILE* const inFile = fopen_X(filename, "rb");
+    void* const buffer = malloc_X(buffSize);
+    size_t const readSize = fread(buffer, 1, buffSize, inFile);
+    if (readSize != (size_t)buffSize) {
+        printf("fread: %s : %s \n", filename, strerror(errno));
+        exit(4);
+    }
+    fclose(inFile);
+
+    unsigned long long const rSize = ZSTD_getDecompressedSize(buffer, buffSize);
+    if (rSize==0) {
+        printf("%s : original size unknown \n", filename);
+        exit(5);
+    }
+
+    buf->resize(rSize);
+
+    size_t const dSize = ZSTD_decompress(buf->data(), rSize, buffer, buffSize);
+
+    if (dSize != rSize) {
+        printf("error decoding %s : %s \n", filename, ZSTD_getErrorName(dSize));
+        exit(7);
+    }
+
+    free(buffer);
+
+    return true;
+#else
+  return false;
+#endif
+}
+
 const char* get_file_data(size_t *len, const char* filename)
 {
 
@@ -204,6 +273,20 @@ const char* get_file_data(size_t *len, const char* filename)
       data_len = buf.size();
     }
 
+  } else if (strcmp(ext, ".zst") == 0) {
+    printf("zstd\n");
+    // Zstandard data.
+
+    std::vector<char> buf;
+    bool ret = zstd_load(&buf, filename);
+
+    if (ret) {
+      char *p = static_cast<char*>(malloc(buf.size() + 1));  // @fixme { implement deleter }
+      memcpy(p, &buf.at(0), buf.size());
+      p[buf.size()] = '\0';
+      data = p;
+      data_len = buf.size();
+    }
   } else {
     
     data = mmap_file(&data_len, filename);
@@ -220,13 +303,22 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3], const char* filename, int n
   std::vector<tinyobj_opt::shape_t> shapes;
   std::vector<tinyobj_opt::material_t> materials;
 
+  auto load_t_begin = std::chrono::high_resolution_clock::now();
   size_t data_len = 0;
   const char* data = get_file_data(&data_len, filename);
   if (data == nullptr) {
+    printf("failed to load file\n");
     exit(-1);
     return false;
   }
-  printf("filesize: %d\n", (int)data_len);
+  auto load_t_end = std::chrono::high_resolution_clock::now();
+  std::chrono::duration<double, std::milli> load_ms = load_t_end - load_t_begin;
+  if (verbose) {
+    std::cout << "filesize: " << data_len << std::endl;
+    std::cout << "load time: " << load_ms.count() << " [msecs]" << std::endl;
+  }
+
+
   tinyobj_opt::LoadOption option;
   option.req_num_threads = num_threads;
   option.verbose = verbose;
@@ -534,6 +626,7 @@ int main(int argc, char **argv)
     size_t data_len = 0;
     const char* data = get_file_data(&data_len, argv[1]);
     if (data == nullptr) {
+      printf("failed to load file\n");
       exit(-1);
       return false;
     }

loader_example.cc

@@ -233,16 +233,17 @@ static void PrintInfo(const tinyobj::attrib_t& attrib,
     printf("  material.map_Ns = %s\n",
            materials[i].specular_highlight_texname.c_str());
     printf("  material.map_bump = %s\n", materials[i].bump_texname.c_str());
+    printf("    bump_multiplier = %f\n", static_cast<const double>(materials[i].bump_texopt.bump_multiplier));
     printf("  material.map_d = %s\n", materials[i].alpha_texname.c_str());
     printf("  material.disp = %s\n", materials[i].displacement_texname.c_str());
     printf("  <<PBR>>\n");
-    printf("  material.Pr     = %f\n", materials[i].roughness);
-    printf("  material.Pm     = %f\n", materials[i].metallic);
-    printf("  material.Ps     = %f\n", materials[i].sheen);
-    printf("  material.Pc     = %f\n", materials[i].clearcoat_thickness);
-    printf("  material.Pcr    = %f\n", materials[i].clearcoat_thickness);
-    printf("  material.aniso  = %f\n", materials[i].anisotropy);
-    printf("  material.anisor = %f\n", materials[i].anisotropy_rotation);
+    printf("  material.Pr     = %f\n", static_cast<const double>(materials[i].roughness));
+    printf("  material.Pm     = %f\n", static_cast<const double>(materials[i].metallic));
+    printf("  material.Ps     = %f\n", static_cast<const double>(materials[i].sheen));
+    printf("  material.Pc     = %f\n", static_cast<const double>(materials[i].clearcoat_thickness));
+    printf("  material.Pcr    = %f\n", static_cast<const double>(materials[i].clearcoat_thickness));
+    printf("  material.aniso  = %f\n", static_cast<const double>(materials[i].anisotropy));
+    printf("  material.anisor = %f\n", static_cast<const double>(materials[i].anisotropy_rotation));
     printf("  material.map_Ke = %s\n", materials[i].emissive_texname.c_str());
     printf("  material.map_Pr = %s\n", materials[i].roughness_texname.c_str());
     printf("  material.map_Pm = %s\n", materials[i].metallic_texname.c_str());

models/texture-options-issue-85.mtl

@@ -0,0 +1,36 @@
+newmtl default
+Ka 0 0 0
+Kd 0 0 0
+Ks 0 0 0
+Kt 0.1 0.2 0.3
+map_Ka -clamp on ambient.jpg
+map_Kd -o 0.1 diffuse.jpg
+map_Ks -s 0.1 0.2 specular.jpg
+map_Ns -t 0.1 0.2 0.3 specular_highlight.jpg
+map_bump -bm 3 bumpmap.jpg
+
+newmtl bm2
+Ka 0 0 0
+Kd 0 0 0
+Ks 0 0 0
+Kt 0.1 0.2 0.3
+# blendu
+map_Kd -blendu on diffuse.jpg
+map_Ks -blendv off specular.jpg
+map_Ns -mm 0.1 0.3 specular_highlight.jpg
+# -bm after filename
+map_bump -imfchan r bumpmap2.jpg -bm 1.5
+
+newmtl bm3
+Ka 0 0 0
+Kd 0 0 0
+Ks 0 0 0
+Kt 0.1 0.2 0.3
+# type
+map_Kd -type sphere diffuse.jpg
+map_Ks -type cube_top specular.jpg
+map_Ns -type cube_bottom specular_highlight.jpg
+map_Ka -type cube_left ambient.jpg
+map_d -type cube_right alpha.jpg
+map_bump -type cube_front bump.jpg
+disp -type cube_back displacement.jpg

models/texture-options-issue-85.obj

@@ -0,0 +1,7 @@
+mtllib texture-options-issue-85.mtl
+o Test
+v 1.864151 -1.219172 -5.532511
+v 0.575869 -0.666304 5.896140
+v 0.940448 1.000000 -1.971128
+usemtl default
+f 1 2 3

models/usemtl-issue-104.obj

@@ -0,0 +1,30 @@
+# cornell_box.obj and cornell_box.mtl are grabbed from Intel's embree project.
+# original cornell box data
+  # comment
+
+# empty line including some space
+   
+
+mtllib cornell_box.mtl
+
+o floor
+v 552.8 0.0   0.0
+v 0.0   0.0   0.0
+v 0.0   0.0 559.2
+v 549.6 0.0 559.2
+
+v 130.0 0.0  65.0
+v  82.0 0.0 225.0
+v 240.0 0.0 272.0
+v 290.0 0.0 114.0
+
+v 423.0 0.0 247.0
+v 265.0 0.0 296.0
+v 314.0 0.0 456.0
+v 472.0 0.0 406.0
+
+f 1 2 3 4 
+f 8 7 6 5
+f 12 11 10 9
+
+usemtl white

tests/tester.cc

@@ -184,6 +184,48 @@ TestLoadObj(
   return true;
 }
 
+static bool
+TestLoadObjFromPreopenedFile(
+  const char* filename,
+  const char* basepath = NULL,
+  bool readMaterials = true,
+  bool triangulate = true)
+{
+  std::string fullFilename = std::string(basepath) + filename;
+  std::cout << "Loading " << fullFilename << std::endl;
+
+  std::ifstream fileStream(fullFilename.c_str());
+
+  if (!fileStream) {
+    std::cerr << "Could not find specified file: " << fullFilename << std::endl;
+    return false;
+  }
+
+  tinyobj::MaterialStreamReader materialStreamReader(fileStream);
+  tinyobj::MaterialStreamReader* materialReader = readMaterials
+    ? &materialStreamReader
+    : NULL;
+
+  tinyobj::attrib_t attrib;
+  std::vector<tinyobj::shape_t> shapes;
+  std::vector<tinyobj::material_t> materials;
+
+  std::string err;
+  bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, &fileStream, materialReader);
+
+  if (!err.empty()) {
+    std::cerr << err << std::endl;
+  }
+
+  if (!ret) {
+    printf("Failed to load/parse .obj.\n");
+    return false;
+  }
+
+  std::cout << "Loaded material count: " << materials.size() << "\n";
+
+  return true;
+}
 
 static bool
 TestStreamLoadObj()
@@ -351,6 +393,16 @@ TEST_CASE("stream_load", "[Stream]") {
     REQUIRE(true == TestStreamLoadObj());
 }
 
+TEST_CASE("stream_load_from_file_skipping_materials", "[Stream]") {
+  REQUIRE(true == TestLoadObjFromPreopenedFile(
+    "../models/pbr-mat-ext.obj", gMtlBasePath, /*readMaterials*/false, /*triangulate*/false));
+}
+
+TEST_CASE("stream_load_from_file_with_materials", "[Stream]") {
+  REQUIRE(true == TestLoadObjFromPreopenedFile(
+    "../models/pbr-mat-ext.obj", gMtlBasePath, /*readMaterials*/true, /*triangulate*/false));
+}
+
 TEST_CASE("trailing_whitespace_in_mtl", "[Issue92]") {
   tinyobj::attrib_t attrib;
   std::vector<tinyobj::shape_t> shapes;
@@ -402,6 +454,7 @@ TEST_CASE("transmittance_filter_Tf", "[Issue95-Tf]") {
   REQUIRE(0.2 == Approx(materials[0].transmittance[1]));
   REQUIRE(0.3 == Approx(materials[0].transmittance[2]));
 }
+
 TEST_CASE("transmittance_filter_Kt", "[Issue95-Kt]") {
   tinyobj::attrib_t attrib;
   std::vector<tinyobj::shape_t> shapes;
@@ -420,6 +473,63 @@ TEST_CASE("transmittance_filter_Kt", "[Issue95-Kt]") {
   REQUIRE(0.3 == Approx(materials[0].transmittance[2]));
 }
 
+TEST_CASE("usemtl_at_last_line", "[Issue104]") {
+  tinyobj::attrib_t attrib;
+  std::vector<tinyobj::shape_t> shapes;
+  std::vector<tinyobj::material_t> materials;
+
+  std::string err;
+  bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, "../models/usemtl-issue-104.obj", gMtlBasePath);
+
+  if (!err.empty()) {
+    std::cerr << err << std::endl;
+  }
+  REQUIRE(true == ret);
+  REQUIRE(1 == shapes.size());
+}
+
+TEST_CASE("texture_opts", "[Issue85]") {
+  tinyobj::attrib_t attrib;
+  std::vector<tinyobj::shape_t> shapes;
+  std::vector<tinyobj::material_t> materials;
+
+  std::string err;
+  bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, "../models/texture-options-issue-85.obj", gMtlBasePath);
+
+  if (!err.empty()) {
+    std::cerr << err << std::endl;
+  }
+  REQUIRE(true == ret);
+  REQUIRE(1 == shapes.size());
+  REQUIRE(3 == materials.size());
+  REQUIRE(0 == materials[0].name.compare("default"));
+  REQUIRE(0 == materials[1].name.compare("bm2"));
+  REQUIRE(0 == materials[2].name.compare("bm3"));
+  REQUIRE(true == materials[0].ambient_texopt.clamp);
+  REQUIRE(0.1 == Approx(materials[0].diffuse_texopt.origin_offset[0]));
+  REQUIRE(0.0 == Approx(materials[0].diffuse_texopt.origin_offset[1]));
+  REQUIRE(0.0 == Approx(materials[0].diffuse_texopt.origin_offset[2]));
+  REQUIRE(0.1 == Approx(materials[0].specular_texopt.scale[0]));
+  REQUIRE(0.2 == Approx(materials[0].specular_texopt.scale[1]));
+  REQUIRE(1.0 == Approx(materials[0].specular_texopt.scale[2]));
+  REQUIRE(0.1 == Approx(materials[0].specular_highlight_texopt.turbulence[0]));
+  REQUIRE(0.2 == Approx(materials[0].specular_highlight_texopt.turbulence[1]));
+  REQUIRE(0.3 == Approx(materials[0].specular_highlight_texopt.turbulence[2]));
+  REQUIRE(3.0 == Approx(materials[0].bump_texopt.bump_multiplier));
+
+  REQUIRE(0.1 == Approx(materials[1].specular_highlight_texopt.brightness));
+  REQUIRE(0.3 == Approx(materials[1].specular_highlight_texopt.contrast));
+  REQUIRE('r' == materials[1].bump_texopt.imfchan);
+
+  REQUIRE(tinyobj::TEXTURE_TYPE_SPHERE == materials[2].diffuse_texopt.type);
+  REQUIRE(tinyobj::TEXTURE_TYPE_CUBE_TOP == materials[2].specular_texopt.type);
+  REQUIRE(tinyobj::TEXTURE_TYPE_CUBE_BOTTOM == materials[2].specular_highlight_texopt.type);
+  REQUIRE(tinyobj::TEXTURE_TYPE_CUBE_LEFT == materials[2].ambient_texopt.type);
+  REQUIRE(tinyobj::TEXTURE_TYPE_CUBE_RIGHT == materials[2].alpha_texopt.type);
+  REQUIRE(tinyobj::TEXTURE_TYPE_CUBE_FRONT == materials[2].bump_texopt.type);
+  REQUIRE(tinyobj::TEXTURE_TYPE_CUBE_BACK == materials[2].displacement_texopt.type);
+}
+
 #if 0
 int
 main(

tiny_obj_loader.h

@@ -23,6 +23,10 @@ THE SOFTWARE.
 */
 
 //
+// 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.
 //
 
@@ -41,6 +45,82 @@ THE SOFTWARE.
 
 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;
 
@@ -65,6 +145,14 @@ typedef struct {
   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
@@ -74,12 +162,22 @@ typedef struct {
   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;
 } material_t;
 
@@ -91,7 +189,7 @@ typedef struct {
   std::vector<std::string> stringValues;
 } tag_t;
 
-// Index struct to support differnt indices for vtx/normal/texcoord.
+// Index struct to support different indices for vtx/normal/texcoord.
 // -1 means not used.
 typedef struct {
   int vertex_index;
@@ -179,6 +277,19 @@ class MaterialFileReader : public MaterialReader {
   std::string m_mtlBasePath;
 };
 
+class MaterialStreamReader : public MaterialReader {
+ public:
+  explicit MaterialStreamReader(std::istream &inStream)
+      : m_inStream(inStream) {}
+  virtual ~MaterialStreamReader() {}
+  virtual bool operator()(const std::string &matId,
+                          std::vector<material_t> *materials,
+                          std::map<std::string, int> *matMap, std::string *err);
+
+ private:
+  std::istream &m_inStream;
+};
+
 /// Loads .obj from a file.
 /// 'attrib', 'shapes' and 'materials' will be filled with parsed shape data
 /// 'shapes' will be filled with parsed shape data
@@ -209,7 +320,7 @@ bool LoadObjWithCallback(std::istream &inStream, const callback_t &callback,
 /// Returns warning and error message into `err`
 bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
              std::vector<material_t> *materials, std::string *err,
-             std::istream *inStream, MaterialReader *readMatFn,
+             std::istream *inStream, MaterialReader *readMatFn = NULL,
              bool triangulate = true);
 
 /// Loads materials into std::map
@@ -404,8 +515,14 @@ static bool tryParseDouble(const char *s, const char *s_end, double *result) {
     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) * pow(10.0, -read);
+      mantissa += static_cast<int>(*curr - 0x30) *
+                  (read < lut_entries ? pow_lut[read] : pow(10.0, -read));
       read++;
       curr++;
       end_not_reached = (curr != s_end);
@@ -446,7 +563,8 @@ static bool tryParseDouble(const char *s, const char *s_end, double *result) {
 
 assemble:
   *result =
-      (sign == '+' ? 1 : -1) * ldexp(mantissa * pow(5.0, exponent), exponent);
+      (sign == '+' ? 1 : -1) *
+      (exponent ? ldexp(mantissa * pow(5.0, exponent), exponent) : mantissa);
   return true;
 fail:
   return false;
@@ -462,24 +580,72 @@ static inline float parseFloat(const char **token, double default_value = 0.0) {
   return f;
 }
 
-static inline void parseFloat2(float *x, float *y, const char **token) {
-  (*x) = parseFloat(token);
-  (*y) = parseFloat(token);
+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) {
-  (*x) = parseFloat(token);
-  (*y) = parseFloat(token);
-  (*z) = parseFloat(token);
+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) {
-  (*x) = parseFloat(token);
-  (*y) = parseFloat(token);
-  (*z) = parseFloat(token);
-  (*w) = parseFloat(token, 1.0);
+                          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) {
@@ -572,6 +738,102 @@ static vertex_index parseRawTriple(const char **token) {
   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 = "";
@@ -678,9 +940,8 @@ void LoadMtl(std::map<std::string, int> *material_map,
   material_t material;
   InitMaterial(&material);
 
-  while (inStream->peek() != -1) {
   std::string linebuf;
-
+  while (inStream->peek() != -1) {
     safeGetline(*inStream, linebuf);
 
     // Trim trailing whitespace.
@@ -878,35 +1139,54 @@ void LoadMtl(std::map<std::string, int> *material_map,
     // ambient texture
     if ((0 == strncmp(token, "map_Ka", 6)) && IS_SPACE(token[6])) {
       token += 7;
-      material.ambient_texname = token;
+      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;
-      material.diffuse_texname = token;
+      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;
-      material.specular_texname = token;
+      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;
-      material.specular_highlight_texname = token;
+      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;
-      material.bump_texname = token;
+      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;
     }
 
@@ -914,55 +1194,63 @@ void LoadMtl(std::map<std::string, int> *material_map,
     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;
+      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;
-      material.displacement_texname = token;
+      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;
-      material.roughness_texname = token;
+      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;
-      material.metallic_texname = token;
+      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;
-      material.sheen_texname = token;
+      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;
-      material.emissive_texname = token;
+      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;
-      material.normal_texname = token;
+      ParseTextureNameAndOption(
+          &(material.normal_texname), &(material.normal_texopt), token,
+          /* is_bump */ false);  // @fixme { is_bump will be true? }
       continue;
     }
 
@@ -1010,6 +1298,23 @@ bool MaterialFileReader::operator()(const std::string &matId,
   return true;
 }
 
+bool MaterialStreamReader::operator()(const std::string &matId,
+                                      std::vector<material_t> *materials,
+                                      std::map<std::string, int> *matMap,
+                                      std::string *err) {
+  (void)matId;
+  LoadMtl(matMap, materials, &m_inStream);
+  if (!m_inStream) {
+    std::stringstream ss;
+    ss << "WARN: Material stream in error state."
+       << " Created a default material.";
+    if (err) {
+      (*err) += ss.str();
+    }
+  }
+  return true;
+}
+
 bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
              std::vector<material_t> *materials, std::string *err,
              const char *filename, const char *mtl_basepath,
@@ -1042,7 +1347,7 @@ bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
 
 bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
              std::vector<material_t> *materials, std::string *err,
-             std::istream *inStream, MaterialReader *readMatFn,
+             std::istream *inStream, MaterialReader *readMatFn /*= NULL*/,
              bool triangulate) {
   std::stringstream errss;
 
@@ -1059,8 +1364,8 @@ bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
 
   shape_t shape;
 
-  while (inStream->peek() != -1) {
   std::string linebuf;
+  while (inStream->peek() != -1) {
     safeGetline(*inStream, linebuf);
 
     // Trim newline '\r\n' or '\n'
@@ -1161,7 +1466,9 @@ bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
       }
 
       if (newMaterialId != material) {
-        // Create per-face 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();
@@ -1173,6 +1480,7 @@ bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
 
     // load mtl
     if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) {
+      if (readMatFn) {
         char namebuf[TINYOBJ_SSCANF_BUFFER_SIZE];
         token += 7;
 #ifdef _MSC_VER
@@ -1191,6 +1499,7 @@ bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
           faceGroup.clear();  // for safety
           return false;
         }
+      }
 
       continue;
     }
@@ -1307,7 +1616,11 @@ bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
 
   bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name,
                                     triangulate);
-  if (ret) {
+  // 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