Add more support for parsing texture options.

Add more unit testing for texture options.

examples/viewer/viewer.cc

@@ -209,6 +209,9 @@ 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++) {
@@ -248,11 +251,6 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3],
 
   {
     for (size_t s = 0; s < shapes.size(); s++) {
-      size_t current_material_id = 0;
-      if (shapes[s].mesh.material_ids.size() > 0 && shapes[s].mesh.material_ids.size() > s) {
-          // Base case
-          current_material_id = shapes[s].mesh.material_ids[s];
-      }
       DrawObject o;
       std::vector<float> vb;  // pos(3float), normal(3float), color(3float)
       for (size_t f = 0; f < shapes[s].mesh.indices.size() / 3; f++) {
@@ -260,12 +258,16 @@ 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];
         
-        current_material_id = shapes[s].mesh.material_ids[f];
+        int current_material_id = shapes[s].mesh.material_ids[f];
 
-        if (current_material_id >= materials.size()) {
-            std::cerr << "Invalid material index: " << current_material_id << std::endl;
+        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];
@@ -364,7 +366,15 @@ bool LoadObjAndConvert(float bmin[3], float bmax[3],
 
       o.vb = 0;
       o.numTriangles = 0;
-      o.material_id = current_material_id;
+
+      // 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);

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;
+}
+

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

tests/tester.cc

@@ -488,6 +488,48 @@ TEST_CASE("usemtl_at_last_line", "[Issue104]") {
   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,9 @@ 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.
 //
@@ -42,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;
 
@@ -66,21 +145,39 @@ 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
-  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 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;
 } material_t;
 
@@ -418,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);
@@ -460,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;
@@ -476,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) {
@@ -586,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 = "";
@@ -692,9 +940,8 @@ void LoadMtl(std::map<std::string, int> *material_map,
   material_t material;
   InitMaterial(&material);
 
+  std::string linebuf;
   while (inStream->peek() != -1) {
-    std::string linebuf;
-
     safeGetline(*inStream, linebuf);
 
     // Trim trailing whitespace.
@@ -892,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;
     }
 
@@ -928,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;
     }
 
@@ -1028,6 +1302,7 @@ 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;
@@ -1072,8 +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 /*= NULL*/,
+             std::istream *inStream, MaterialReader *readMatFn /*= NULL*/,
              bool triangulate) {
   std::stringstream errss;
 
@@ -1090,8 +1364,8 @@ bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
 
   shape_t shape;
 
+  std::string linebuf;
   while (inStream->peek() != -1) {
-    std::string linebuf;
     safeGetline(*inStream, linebuf);
 
     // Trim newline '\r\n' or '\n'