Merge pull request #136 from KaoCC/v0.9.x

remove the keyword `register' for C++17

README.md

@@ -17,6 +17,12 @@ Tiny but powerful single file wavefront obj loader written in C++. No dependency
 
 `tinyobjloader` is good for embedding .obj loader to your (global illumination) renderer ;-)
 
+Notice!
+-------
+
+`master` branch will be replaced with `develop` branch in the near future: https://github.com/syoyo/tinyobjloader/tree/develop
+`develop` branch has more better support and clean API interface for loading .obj and also it has optimized multi-threaded parser(probably 10x faster than `master`). If you are new to use `TinyObjLoader`, I highly recommend to use `develop` branch.
+
 
 What's new
 ----------
@@ -61,6 +67,12 @@ TinyObjLoader is successfully used in ...
 * pbrt-v3 https://github.com/mmp/pbrt-v3
 * cocos2d-x https://github.com/cocos2d/cocos2d-x/
 * Android Vulkan demo https://github.com/SaschaWillems/Vulkan
+* voxelizer https://github.com/karimnaaji/voxelizer
+* Probulator https://github.com/kayru/Probulator
+* OptiX Prime baking https://github.com/nvpro-samples/optix_prime_baking
+* 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
 * Your project here!
 
 Features

test.cc

@@ -8,6 +8,90 @@
 #include <sstream>
 #include <fstream>
 
+#ifdef _WIN32
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <windows.h>
+#include <mmsystem.h>
+#ifdef __cplusplus
+}
+#endif
+#pragma comment(lib, "winmm.lib")
+#else
+#if defined(__unix__) || defined(__APPLE__)
+#include <sys/time.h>
+#else
+#include <ctime>
+#endif
+#endif
+
+// not thread-safe 
+class timerutil {
+public:
+#ifdef _WIN32
+  typedef DWORD time_t;
+
+  timerutil() { ::timeBeginPeriod(1); }
+  ~timerutil() { ::timeEndPeriod(1); }
+
+  void start() { t_[0] = ::timeGetTime(); }
+  void end() { t_[1] = ::timeGetTime(); }
+
+  time_t sec() { return (time_t)((t_[1] - t_[0]) / 1000); }
+  time_t msec() { return (time_t)((t_[1] - t_[0])); }
+  time_t usec() { return (time_t)((t_[1] - t_[0]) * 1000); }
+  time_t current() { return ::timeGetTime(); }
+
+#else
+#if defined(__unix__) || defined(__APPLE__)
+  typedef unsigned long int time_t;
+
+  void start() { gettimeofday(tv + 0, &tz); }
+  void end() { gettimeofday(tv + 1, &tz); }
+
+  time_t sec() { return (time_t)(tv[1].tv_sec - tv[0].tv_sec); }
+  time_t msec() {
+    return this->sec() * 1000 +
+           (time_t)((tv[1].tv_usec - tv[0].tv_usec) / 1000);
+  }
+  time_t usec() {
+    return this->sec() * 1000000 + (time_t)(tv[1].tv_usec - tv[0].tv_usec);
+  }
+  time_t current() {
+    struct timeval t;
+    gettimeofday(&t, NULL);
+    return (time_t)(t.tv_sec * 1000 + t.tv_usec);
+  }
+
+#else // C timer
+  // using namespace std;
+  typedef clock_t time_t;
+
+  void start() { t_[0] = clock(); }
+  void end() { t_[1] = clock(); }
+
+  time_t sec() { return (time_t)((t_[1] - t_[0]) / CLOCKS_PER_SEC); }
+  time_t msec() { return (time_t)((t_[1] - t_[0]) * 1000 / CLOCKS_PER_SEC); }
+  time_t usec() { return (time_t)((t_[1] - t_[0]) * 1000000 / CLOCKS_PER_SEC); }
+  time_t current() { return (time_t)clock(); }
+
+#endif
+#endif
+
+private:
+#ifdef _WIN32
+  DWORD t_[2];
+#else
+#if defined(__unix__) || defined(__APPLE__)
+  struct timeval tv[2];
+  struct timezone tz;
+#else
+  time_t t_[2];
+#endif
+#endif
+};
+
 static void PrintInfo(const std::vector<tinyobj::shape_t>& shapes, const std::vector<tinyobj::material_t>& materials, bool triangulate = true)
 {
   std::cout << "# of shapes    : " << shapes.size() << std::endl;
@@ -131,8 +215,11 @@ TestLoadObj(
   std::vector<tinyobj::shape_t> shapes;
   std::vector<tinyobj::material_t> materials;
 
+  timerutil t;
+  t.start();
   std::string err;
   bool ret = tinyobj::LoadObj(shapes, materials, err, filename, basepath, flags);
+  t.end();
 
   if (!err.empty()) {
     std::cerr << err << std::endl;
@@ -143,6 +230,8 @@ TestLoadObj(
     return false;
   }
 
+  printf("Parse time: %lu [msecs]\n", t.msec());
+
   bool triangulate( ( flags & tinyobj::triangulation ) == tinyobj::triangulation );
   PrintInfo(shapes, materials, triangulate );
 
@@ -213,7 +302,8 @@ std::string matStream(
     "newmtl light\n"
     "Ka 20 20 20\n"
     "Kd 1 1 1\n"
-    "Ks 0 0 0");
+    "Ks 0 0 0\n"
+    "map_Kd tmp.png \n"); // #92(whitespace after filename)
 
     using namespace tinyobj;
     class MaterialStringStreamReader:
@@ -253,6 +343,13 @@ std::string matStream(
   }
 
   PrintInfo(shapes, materials);
+
+  // #92
+  for (size_t i = 0; i < materials.size(); i++) {
+    if (materials[i].name.compare("light") == 0) {
+      assert(materials[i].diffuse_texname.compare("tmp.png") == 0);
+    }
+  }
     
   return true;
 }

tiny_obj_loader.h

@@ -42,10 +42,10 @@
 #ifndef TINY_OBJ_LOADER_H_
 #define TINY_OBJ_LOADER_H_
 
+#include <cmath>
+#include <map>
 #include <string>
 #include <vector>
-#include <map>
-#include <cmath>
 
 namespace tinyobj {
 
@@ -99,52 +99,37 @@ typedef struct {
   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
+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
-{
+class float3 {
 public:
-  float3()
-    : x( 0.0f )
-    , y( 0.0f )
-    , z( 0.0f )
-  {
-  }
+  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 )
-  {
-  }
+      : x(coord_x), y(coord_y), z(coord_z) {}
 
-  float3(const float3& from, const float3& to)
-  {
+  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 );
+  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 )
-    {
+  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);
@@ -152,12 +137,10 @@ public:
   }
 
 private:
-  union
-  {
+  union {
     float coord[3];
-    struct
-    {
-      float x,y,z;
+    struct {
+      float x, y, z;
     };
   };
 };
@@ -197,7 +180,7 @@ 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 );
+             unsigned int flags = 1);
 
 /// Loads object from a std::istream, uses GetMtlIStreamFn to retrieve
 /// std::istream for materials.
@@ -216,12 +199,12 @@ void LoadMtl(std::map<std::string, int> &material_map, // [output]
 }
 
 #ifdef TINYOBJLOADER_IMPLEMENTATION
-#include <cstdlib>
-#include <cstring>
 #include <cassert>
+#include <cctype>
 #include <cmath>
 #include <cstddef>
-#include <cctype>
+#include <cstdlib>
+#include <cstring>
 
 #include <fstream>
 #include <sstream>
@@ -267,9 +250,43 @@ struct obj_shape {
   std::vector<float> vt;
 };
 
-#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') )
+// 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) {
@@ -580,13 +597,13 @@ static bool exportFaceGroupToShape(
     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 ) {
+    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 );
+  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++) {
@@ -639,31 +656,41 @@ static bool exportFaceGroupToShape(
   }
 
   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 (register 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));
+    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 v12(v1, v2);
+        float3 v13(v1, v3);
 
-			  float3 normal = v12.crossproduct(v13);
-			  normal.normalize();
+        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 {
+        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();
-	  }
+      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;
@@ -682,12 +709,14 @@ void LoadMtl(std::map<std::string, int> &material_map,
   material_t material;
   InitMaterial(material);
 
-  size_t maxchars = 8192;          // Alloc enough size.
-  std::vector<char> buf(maxchars); // Alloc enough size.
   while (inStream.peek() != -1) {
-    inStream.getline(&buf[0], static_cast<std::streamsize>(maxchars));
+    std::string linebuf;
+    safeGetline(inStream, linebuf);
 
-    std::string linebuf(&buf[0]);
+    // 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) {
@@ -972,12 +1001,9 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
 
   shape_t shape;
 
-  int maxchars = 8192;                                  // Alloc enough size.
-  std::vector<char> buf(static_cast<size_t>(maxchars)); // Alloc enough size.
   while (inStream.peek() != -1) {
-    inStream.getline(&buf[0], maxchars);
-
-    std::string linebuf(&buf[0]);
+    std::string linebuf;
+    safeGetline(inStream, linebuf);
 
     // Trim newline '\r\n' or '\n'
     if (linebuf.size() > 0) {
@@ -1082,7 +1108,7 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
       if (newMaterialId != material) {
         // Create per-face material
         exportFaceGroupToShape(shape, vertexCache, v, vn, vt, faceGroup, tags,
-                               material, name, true, flags, err );
+                               material, name, true, flags, err);
         faceGroup.clear();
         material = newMaterialId;
       }
@@ -1118,7 +1144,7 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
       // flush previous face group.
       bool ret =
           exportFaceGroupToShape(shape, vertexCache, v, vn, vt, faceGroup, tags,
-                                 material, name, true, flags, err );
+                                 material, name, true, flags, err);
       if (ret) {
         shapes.push_back(shape);
       }
@@ -1155,7 +1181,7 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
       // flush previous face group.
       bool ret =
           exportFaceGroupToShape(shape, vertexCache, v, vn, vt, faceGroup, tags,
-                                 material, name, true, flags, err );
+                                 material, name, true, flags, err);
       if (ret) {
         shapes.push_back(shape);
       }
@@ -1211,7 +1237,8 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
         char stringValueBuffer[4096];
 
 #ifdef _MSC_VER
-        sscanf_s(token, "%s", stringValueBuffer, (unsigned)_countof(stringValueBuffer));
+        sscanf_s(token, "%s", stringValueBuffer,
+                 (unsigned)_countof(stringValueBuffer));
 #else
         sscanf(token, "%s", stringValueBuffer);
 #endif
@@ -1226,7 +1253,7 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
   }
 
   bool ret = exportFaceGroupToShape(shape, vertexCache, v, vn, vt, faceGroup,
-                                    tags, material, name, true, flags, err );
+                                    tags, material, name, true, flags, err);
   if (ret) {
     shapes.push_back(shape);
   }