Merge pull request #80 from Vazquinhos/master

Fixing errors normal generation no triangulation. Remove warnings. Coding Style.

README.md

@@ -21,6 +21,7 @@ Tiny but powerful single file wavefront obj loader written in C++. No dependency
 What's new
 ----------
 
+* Mar 13, 2016 : Introduce `load_flag_t` and flat normal calculation flag! Thanks Vazquinhos!
 * Jan 29, 2016 : Support n-polygon(no triangulation) and OpenSubdiv crease tag! Thanks dboogert!
 * Nov 26, 2015 : Now single-header only!.
 * Nov 08, 2015 : Improved API.
@@ -163,8 +164,8 @@ std::vector<tinyobj::shape_t> shapes;
 std::vector<tinyobj::material_t> materials;
   
 std::string err;
-bool triangulate = false;
+int flags = 1; // see load_flags_t enum for more information.
-bool ret = tinyobj::LoadObj(shapes, materials, err, inputfile.c_str(), triangulate);
+bool ret = tinyobj::LoadObj(shapes, materials, err, inputfile.c_str(), flags);
   
 if (!err.empty()) { // `err` may contain warning message.
   std::cerr << err << std::endl;
@@ -180,7 +181,7 @@ for (size_t i = 0; i < shapes.size(); i++) {
   for (size_t n = 0; n < shapes[i].mesh.num_vertices.size(); n++) {
     int ngon = shapes[i].mesh.num_vertices[n];
     for (size_t f = 0; f < ngon; f++) {
-      unsigend int v = shapes[i].mesh.indices[indexOffset + f];
+      unsigned int v = shapes[i].mesh.indices[indexOffset + f];
       printf("  face[%ld] v[%ld] = (%f, %f, %f)\n", n,
         shapes[i].mesh.positions[3*v+0],
         shapes[i].mesh.positions[3*v+1],

test.cc

@@ -124,7 +124,7 @@ static bool
 TestLoadObj(
   const char* filename,
   const char* basepath = NULL,
-  bool triangulate = true)
+  unsigned int flags = 1 )
 {
   std::cout << "Loading " << filename << std::endl;
 
@@ -132,7 +132,7 @@ TestLoadObj(
   std::vector<tinyobj::material_t> materials;
 
   std::string err;
-  bool ret = tinyobj::LoadObj(shapes, materials, err, filename, basepath, triangulate);
+  bool ret = tinyobj::LoadObj(shapes, materials, err, filename, basepath, flags);
 
   if (!err.empty()) {
     std::cerr << err << std::endl;
@@ -143,7 +143,8 @@ TestLoadObj(
     return false;
   }
 
-  PrintInfo(shapes, materials, triangulate);
+  bool triangulate( ( flags & tinyobj::triangulation ) == tinyobj::triangulation );
+  PrintInfo(shapes, materials, triangulate );
 
   return true;
 }
@@ -271,7 +272,7 @@ main(
     //assert(true == TestLoadObj("cornell_box.obj"));
     //assert(true == TestLoadObj("cube.obj"));
     assert(true == TestStreamLoadObj());
-    assert(true == TestLoadObj("catmark_torus_creases0.obj", NULL, false));
+    assert(true == TestLoadObj("catmark_torus_creases0.obj", NULL,  0));
   }
 
   return 0;

tiny_obj_loader.h

@@ -1,10 +1,11 @@
 //
-// Copyright 2012-2015, Syoyo Fujita.
+// Copyright 2012-2016, Syoyo Fujita.
 //
 // Licensed under 2-clause BSD license.
 //
 
 //
+// version 0.9.22: Introduce `load_flags_t`.
 // version 0.9.20: Fixes creating per-face material using `usemtl`(#68)
 // version 0.9.17: Support n-polygon and crease tag(OpenSubdiv extension)
 // version 0.9.16: Make tinyobjloader header-only
@@ -38,12 +39,13 @@
 //   #include "tiny_obj_loader.h"
 //
 
-#ifndef TINY_OBJ_LOADER_H
+#ifndef TINY_OBJ_LOADER_H_
-#define TINY_OBJ_LOADER_H
+#define TINY_OBJ_LOADER_H_
 
 #include <string>
 #include <vector>
 #include <map>
+#include <cmath>
 
 namespace tinyobj {
 
@@ -97,6 +99,69 @@ 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
+  // Some nice stuff here
+} load_flags_t;
+
+class float3
+{
+public:
+  float3()
+    : x( 0.0f )
+    , y( 0.0f )
+    , z( 0.0f )
+  {
+  }
+
+  float3(float coord_x, float coord_y, float coord_z)
+    : x( coord_x )
+    , y( coord_y )
+    , z( coord_z )
+  {
+  }
+
+  float3(const float3& from, const float3& to)
+  {
+    coord[0] = to.coord[0] - from.coord[0];
+    coord[1] = to.coord[1] - from.coord[1];
+    coord[2] = to.coord[2] - from.coord[2];
+  }
+
+  float3 crossproduct ( const float3 & vec )
+  {
+    float a = y * vec.z - z * vec.y ;
+    float b = z * vec.x - x * vec.z ;
+    float c = x * vec.y - y * vec.x ;
+    return float3( a , b , c );
+  }
+
+  void normalize()
+  {
+    const float length = std::sqrt( ( coord[0] * coord[0] ) +
+                                               ( coord[1] * coord[1] ) +
+                                               ( coord[2] * coord[2] ) );
+    if( length != 1 )
+    {
+      coord[0] = (coord[0] / length);
+      coord[1] = (coord[1] / length);
+      coord[2] = (coord[2] / length);
+    }
+  }
+
+private:
+  union
+  {
+    float coord[3];
+    struct
+    {
+      float x,y,z;
+    };
+  };
+};
+
 class MaterialReader {
 public:
   MaterialReader() {}
@@ -127,13 +192,12 @@ private:
 /// Returns true when loading .obj become success.
 /// Returns warning and error message into `err`
 /// 'mtl_basepath' is optional, and used for base path for .mtl file.
-/// 'triangulate' is optional, and used whether triangulate polygon face in .obj
+/// 'optional flags
-/// or not.
 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,
-             bool triangulate = true);
+             unsigned int flags = 1 );
 
 /// Loads object from a std::istream, uses GetMtlIStreamFn to retrieve
 /// std::istream for materials.
@@ -143,7 +207,7 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
              std::vector<material_t> &materials, // [output]
              std::string &err,                   // [output]
              std::istream &inStream, MaterialReader &readMatFn,
-             bool triangulate = true);
+             unsigned int flags = 1);
 
 /// Loads materials into std::map
 void LoadMtl(std::map<std::string, int> &material_map, // [output]
@@ -159,9 +223,6 @@ void LoadMtl(std::map<std::string, int> &material_map, // [output]
 #include <cstddef>
 #include <cctype>
 
-#include <string>
-#include <vector>
-#include <map>
 #include <fstream>
 #include <sstream>
 
@@ -175,8 +236,8 @@ MaterialReader::~MaterialReader() {}
 
 struct vertex_index {
   int v_idx, vt_idx, vn_idx;
-  vertex_index() {}
+  vertex_index() : v_idx(-1), vt_idx(-1), vn_idx(-1) {}
-  vertex_index(int idx) : v_idx(idx), vt_idx(idx), vn_idx(idx) {}
+  explicit vertex_index(int idx) : v_idx(idx), vt_idx(idx), vn_idx(idx) {}
   vertex_index(int vidx, int vtidx, int vnidx)
       : v_idx(vidx), vt_idx(vtidx), vn_idx(vnidx) {}
 };
@@ -519,11 +580,14 @@ 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, bool triangulate) {
+    bool clearCache, unsigned int flags, std::string& err ) {
   if (faceGroup.empty()) {
     return false;
   }
 
+  bool triangulate( ( flags & triangulation ) == triangulation );
+  bool normals_calculation( ( flags & calculate_normals ) == calculate_normals );
+
   // Flatten vertices and indices
   for (size_t i = 0; i < faceGroup.size(); i++) {
     const std::vector<vertex_index> &face = faceGroup[i];
@@ -574,6 +638,34 @@ 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));
+
+			  float3 v12(v1, v2);
+			  float3 v13(v1, v3);
+
+			  float3 normal = v12.crossproduct(v13);
+			  normal.normalize();
+
+			  memcpy(&shape.mesh.normals[shape.mesh.indices[iIndices] * 3], &normal, sizeof(float3));
+			  memcpy(&shape.mesh.normals[shape.mesh.indices[iIndices + 1] * 3], &normal, sizeof(float3));
+			  memcpy(&shape.mesh.normals[shape.mesh.indices[iIndices + 2] * 3], &normal, sizeof(float3));
+		  }
+	  } else {
+
+		  std::stringstream ss;
+		  ss << "WARN: The shape " << name << " does not have a topology of triangles, therfore the normals calculation could not be performed. Select the tinyobj::triangulation flag for this object." << std::endl;
+		  err += ss.str();
+	  }
+  }
+
   shape.name = name;
   shape.mesh.tags.swap(tags);
 
@@ -837,7 +929,7 @@ bool MaterialFileReader::operator()(const std::string &matId,
 bool LoadObj(std::vector<shape_t> &shapes,       // [output]
              std::vector<material_t> &materials, // [output]
              std::string &err, const char *filename, const char *mtl_basepath,
-             bool trianglulate) {
+             unsigned int flags) {
 
   shapes.clear();
 
@@ -856,13 +948,14 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
   }
   MaterialFileReader matFileReader(basePath);
 
-  return LoadObj(shapes, materials, err, ifs, matFileReader, trianglulate);
+  return LoadObj(shapes, materials, err, ifs, matFileReader, flags);
 }
 
 bool LoadObj(std::vector<shape_t> &shapes,       // [output]
              std::vector<material_t> &materials, // [output]
              std::string &err, std::istream &inStream,
-             MaterialReader &readMatFn, bool triangulate) {
+             MaterialReader &readMatFn, unsigned int flags) {
+
   std::stringstream errss;
 
   std::vector<float> v;
@@ -989,7 +1082,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, triangulate);
+                               material, name, true, flags, err );
         faceGroup.clear();
         material = newMaterialId;
       }
@@ -1025,7 +1118,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, triangulate);
+                                 material, name, true, flags, err );
       if (ret) {
         shapes.push_back(shape);
       }
@@ -1062,7 +1155,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, triangulate);
+                                 material, name, true, flags, err );
       if (ret) {
         shapes.push_back(shape);
       }
@@ -1089,7 +1182,11 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
 
       char namebuf[4096];
       token += 2;
+#ifdef _MSC_VER
+      sscanf_s(token, "%s", namebuf, (unsigned)_countof(namebuf));
+#else
       sscanf(token, "%s", namebuf);
+#endif
       tag.name = std::string(namebuf);
 
       token += tag.name.size() + 1;
@@ -1113,7 +1210,11 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
       for (size_t i = 0; i < static_cast<size_t>(ts.num_strings); ++i) {
         char stringValueBuffer[4096];
 
+#ifdef _MSC_VER
+        sscanf_s(token, "%s", stringValueBuffer, (unsigned)_countof(stringValueBuffer));
+#else
         sscanf(token, "%s", stringValueBuffer);
+#endif
         tag.stringValues[i] = stringValueBuffer;
         token += tag.stringValues[i].size() + 1;
       }
@@ -1125,13 +1226,14 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
   }
 
   bool ret = exportFaceGroupToShape(shape, vertexCache, v, vn, vt, faceGroup,
-                                    tags, material, name, true, triangulate);
+                                    tags, material, name, true, flags, err );
   if (ret) {
     shapes.push_back(shape);
   }
   faceGroup.clear(); // for safety
 
   err += errss.str();
+
   return true;
 }
 
@@ -1139,4 +1241,4 @@ bool LoadObj(std::vector<shape_t> &shapes,       // [output]
 
 #endif
 
-#endif // TINY_OBJ_LOADER_H
+#endif // TINY_OBJ_LOADER_H_