obj-loader.cc

#include "obj-loader.h"
#include "../../nanort.h"  // for float3

#define TINYOBJLOADER_IMPLEMENTATION
#include "tiny_obj_loader.h"

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Weverything"
#endif

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

#ifdef __clang__
#pragma clang diagnostic pop
#endif

#include <iostream>

#ifdef NANOSG_USE_CXX11
#include <unordered_map>
#else
#include <map>
#endif

#define USE_TEX_CACHE 1

namespace example {

typedef nanort::real3<float> float3;

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wexit-time-destructors"
#pragma clang diagnostic ignored "-Wglobal-constructors"
#endif

// TODO(LTE): Remove global static definition.
#ifdef NANOSG_USE_CXX11
static std::unordered_map<std::string, int> hashed_tex;
#else
static std::map<std::string, int> hashed_tex;
#endif

#ifdef __clang__
#pragma clang diagnostic pop
#endif

inline void CalcNormal(float3 &N, float3 v0, float3 v1, float3 v2) {
  float3 v10 = v1 - v0;
  float3 v20 = v2 - v0;

  N = vcross(v10, v20);
  N = vnormalize(N);
}

static std::string GetBaseDir(const std::string &filepath) {
  if (filepath.find_last_of("/\\") != std::string::npos)
    return filepath.substr(0, filepath.find_last_of("/\\"));
  return "";
}

static int LoadTexture(const std::string &filename,
                       std::vector<Texture> *textures) {
  int idx;

  if (filename.empty()) return -1;

  std::cout << "  Loading texture : " << filename << std::endl;
  Texture texture;

  // tigra: find in cache. get index
  if (USE_TEX_CACHE) {
    if (hashed_tex.find(filename) != hashed_tex.end()) {
      puts("from cache");
      return hashed_tex[filename];
    }
  }

  int w, h, n;
  unsigned char *data = stbi_load(filename.c_str(), &w, &h, &n, 0);
  if (data) {
    texture.width = w;
    texture.height = h;
    texture.components = n;

    size_t n_elem = size_t(w * h * n);
    texture.image = new unsigned char[n_elem];
    for (size_t i = 0; i < n_elem; i++) {
      texture.image[i] = data[i];
    }

    free(data);

    textures->push_back(texture);

    idx = int(textures->size()) - 1;

    // tigra: store index to cache
    if (USE_TEX_CACHE) {
      hashed_tex[filename] = idx;
    }

    return idx;
  }

  std::cout << "  Failed to load : " << filename << std::endl;
  return -1;
}

static void ComputeBoundingBoxOfMesh(float bmin[3], float bmax[3],
                                     const example::Mesh<float> &mesh) {
  bmin[0] = bmin[1] = bmin[2] = std::numeric_limits<float>::max();
  bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits<float>::max();

  for (size_t i = 0; i < mesh.vertices.size() / 3; i++) {
    bmin[0] = std::min(bmin[0], mesh.vertices[3 * i + 0]);
    bmin[1] = std::min(bmin[1], mesh.vertices[3 * i + 1]);
    bmin[2] = std::min(bmin[1], mesh.vertices[3 * i + 2]);

    bmax[0] = std::max(bmax[0], mesh.vertices[3 * i + 0]);
    bmax[1] = std::max(bmax[1], mesh.vertices[3 * i + 1]);
    bmax[2] = std::max(bmax[2], mesh.vertices[3 * i + 2]);
  }
}

bool LoadObj(const std::string &filename, float scale,
             std::vector<Mesh<float> > *meshes,
             std::vector<Material> *out_materials,
             std::vector<Texture> *out_textures) {
  tinyobj::attrib_t attrib;
  std::vector<tinyobj::shape_t> shapes;
  std::vector<tinyobj::material_t> materials;
  std::string warn, err;

  std::string basedir = GetBaseDir(filename) + "/";
  const char *basepath = (basedir.compare("/") == 0) ? NULL : basedir.c_str();

  // auto t_start = std::chrono::system_clock::now();

  bool ret =
      tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, filename.c_str(),
                       basepath, /* triangulate */ true);

  // auto t_end = std::chrono::system_clock::now();
  // std::chrono::duration<double, std::milli> ms = t_end - t_start;

  if (!warn.empty()) {
    std::cout << warn << std::endl;
  }

  if (!err.empty()) {
    std::cerr << err << std::endl;
  }

  if (!ret) {
    return false;
  }

  // std::cout << "[LoadOBJ] Parse time : " << ms.count() << " [msecs]"
  //          << std::endl;

  std::cout << "[LoadOBJ] # of shapes in .obj : " << shapes.size() << std::endl;
  std::cout << "[LoadOBJ] # of materials in .obj : " << materials.size()
            << std::endl;

  {
    size_t total_num_vertices = 0;
    size_t total_num_faces = 0;

    total_num_vertices = attrib.vertices.size() / 3;
    std::cout << "  vertices : " << attrib.vertices.size() / 3 << std::endl;

    for (size_t i = 0; i < shapes.size(); i++) {
      std::cout << "  shape[" << i << "].name : " << shapes[i].name
                << std::endl;
      std::cout << "  shape[" << i
                << "].indices : " << shapes[i].mesh.indices.size() << std::endl;
      assert((shapes[i].mesh.indices.size() % 3) == 0);

      total_num_faces += shapes[i].mesh.indices.size() / 3;

      // tigra: empty name convert to _id
      if (shapes[i].name.length() == 0) {
#ifdef NANOSG_USE_CXX11
        shapes[i].name = "_" + std::to_string(i);
#else
        std::stringstream ss;
        ss << i;
        shapes[i].name = "_" + ss.str();
#endif
        std::cout << "  EMPTY shape[" << i << "].name, new : " << shapes[i].name
                  << std::endl;
      }
    }
    std::cout << "[LoadOBJ] # of faces: " << total_num_faces << std::endl;
    std::cout << "[LoadOBJ] # of vertices: " << total_num_vertices << std::endl;
  }

  // TODO(LTE): Implement tangents and binormals

  for (size_t i = 0; i < shapes.size(); i++) {
    Mesh<float> mesh(/* stride */ sizeof(float) * 3);

    mesh.name = shapes[i].name;

    const size_t num_faces = shapes[i].mesh.indices.size() / 3;
    mesh.faces.resize(num_faces * 3);
    mesh.material_ids.resize(num_faces);
    mesh.facevarying_normals.resize(num_faces * 3 * 3);
    mesh.facevarying_uvs.resize(num_faces * 3 * 2);
    mesh.vertices.resize(num_faces * 3 * 3);

    for (size_t f = 0; f < shapes[i].mesh.indices.size() / 3; f++) {
      // reorder vertices. may create duplicated vertices.
      size_t f0 = size_t(shapes[i].mesh.indices[3 * f + 0].vertex_index);
      size_t f1 = size_t(shapes[i].mesh.indices[3 * f + 1].vertex_index);
      size_t f2 = size_t(shapes[i].mesh.indices[3 * f + 2].vertex_index);

      mesh.vertices[9 * f + 0] = scale * attrib.vertices[3 * f0 + 0];
      mesh.vertices[9 * f + 1] = scale * attrib.vertices[3 * f0 + 1];
      mesh.vertices[9 * f + 2] = scale * attrib.vertices[3 * f0 + 2];

      mesh.vertices[9 * f + 3] = scale * attrib.vertices[3 * f1 + 0];
      mesh.vertices[9 * f + 4] = scale * attrib.vertices[3 * f1 + 1];
      mesh.vertices[9 * f + 5] = scale * attrib.vertices[3 * f1 + 2];

      mesh.vertices[9 * f + 6] = scale * attrib.vertices[3 * f2 + 0];
      mesh.vertices[9 * f + 7] = scale * attrib.vertices[3 * f2 + 1];
      mesh.vertices[9 * f + 8] = scale * attrib.vertices[3 * f2 + 2];

      mesh.faces[3 * f + 0] = static_cast<unsigned int>(3 * f + 0);
      mesh.faces[3 * f + 1] = static_cast<unsigned int>(3 * f + 1);
      mesh.faces[3 * f + 2] = static_cast<unsigned int>(3 * f + 2);

      mesh.material_ids[f] =
          static_cast<unsigned int>(shapes[i].mesh.material_ids[f]);
    }

    if (attrib.normals.size() > 0) {
      for (size_t f = 0; f < shapes[i].mesh.indices.size() / 3; f++) {
        size_t f0, f1, f2;

        f0 = size_t(shapes[i].mesh.indices[3 * f + 0].normal_index);
        f1 = size_t(shapes[i].mesh.indices[3 * f + 1].normal_index);
        f2 = size_t(shapes[i].mesh.indices[3 * f + 2].normal_index);

        if (f0 > 0 && f1 > 0 && f2 > 0) {
          float n0[3], n1[3], n2[3];

          n0[0] = attrib.normals[3 * f0 + 0];
          n0[1] = attrib.normals[3 * f0 + 1];
          n0[2] = attrib.normals[3 * f0 + 2];

          n1[0] = attrib.normals[3 * f1 + 0];
          n1[1] = attrib.normals[3 * f1 + 1];
          n1[2] = attrib.normals[3 * f1 + 2];

          n2[0] = attrib.normals[3 * f2 + 0];
          n2[1] = attrib.normals[3 * f2 + 1];
          n2[2] = attrib.normals[3 * f2 + 2];

          mesh.facevarying_normals[3 * (3 * f + 0) + 0] = n0[0];
          mesh.facevarying_normals[3 * (3 * f + 0) + 1] = n0[1];
          mesh.facevarying_normals[3 * (3 * f + 0) + 2] = n0[2];

          mesh.facevarying_normals[3 * (3 * f + 1) + 0] = n1[0];
          mesh.facevarying_normals[3 * (3 * f + 1) + 1] = n1[1];
          mesh.facevarying_normals[3 * (3 * f + 1) + 2] = n1[2];

          mesh.facevarying_normals[3 * (3 * f + 2) + 0] = n2[0];
          mesh.facevarying_normals[3 * (3 * f + 2) + 1] = n2[1];
          mesh.facevarying_normals[3 * (3 * f + 2) + 2] = n2[2];
        } else {  // face contains invalid normal index. calc geometric normal.
          f0 = size_t(shapes[i].mesh.indices[3 * f + 0].vertex_index);
          f1 = size_t(shapes[i].mesh.indices[3 * f + 1].vertex_index);
          f2 = size_t(shapes[i].mesh.indices[3 * f + 2].vertex_index);

          float3 v0, v1, v2;

          v0[0] = attrib.vertices[3 * f0 + 0];
          v0[1] = attrib.vertices[3 * f0 + 1];
          v0[2] = attrib.vertices[3 * f0 + 2];

          v1[0] = attrib.vertices[3 * f1 + 0];
          v1[1] = attrib.vertices[3 * f1 + 1];
          v1[2] = attrib.vertices[3 * f1 + 2];

          v2[0] = attrib.vertices[3 * f2 + 0];
          v2[1] = attrib.vertices[3 * f2 + 1];
          v2[2] = attrib.vertices[3 * f2 + 2];

          float3 N;
          CalcNormal(N, v0, v1, v2);

          mesh.facevarying_normals[3 * (3 * f + 0) + 0] = N[0];
          mesh.facevarying_normals[3 * (3 * f + 0) + 1] = N[1];
          mesh.facevarying_normals[3 * (3 * f + 0) + 2] = N[2];

          mesh.facevarying_normals[3 * (3 * f + 1) + 0] = N[0];
          mesh.facevarying_normals[3 * (3 * f + 1) + 1] = N[1];
          mesh.facevarying_normals[3 * (3 * f + 1) + 2] = N[2];

          mesh.facevarying_normals[3 * (3 * f + 2) + 0] = N[0];
          mesh.facevarying_normals[3 * (3 * f + 2) + 1] = N[1];
          mesh.facevarying_normals[3 * (3 * f + 2) + 2] = N[2];
        }
      }
    } else {
      // calc geometric normal
      for (size_t f = 0; f < shapes[i].mesh.indices.size() / 3; f++) {
        size_t f0, f1, f2;

        f0 = size_t(shapes[i].mesh.indices[3 * f + 0].vertex_index);
        f1 = size_t(shapes[i].mesh.indices[3 * f + 1].vertex_index);
        f2 = size_t(shapes[i].mesh.indices[3 * f + 2].vertex_index);

        float3 v0, v1, v2;

        v0[0] = attrib.vertices[3 * f0 + 0];
        v0[1] = attrib.vertices[3 * f0 + 1];
        v0[2] = attrib.vertices[3 * f0 + 2];

        v1[0] = attrib.vertices[3 * f1 + 0];
        v1[1] = attrib.vertices[3 * f1 + 1];
        v1[2] = attrib.vertices[3 * f1 + 2];

        v2[0] = attrib.vertices[3 * f2 + 0];
        v2[1] = attrib.vertices[3 * f2 + 1];
        v2[2] = attrib.vertices[3 * f2 + 2];

        float3 N;
        CalcNormal(N, v0, v1, v2);

        mesh.facevarying_normals[3 * (3 * f + 0) + 0] = N[0];
        mesh.facevarying_normals[3 * (3 * f + 0) + 1] = N[1];
        mesh.facevarying_normals[3 * (3 * f + 0) + 2] = N[2];

        mesh.facevarying_normals[3 * (3 * f + 1) + 0] = N[0];
        mesh.facevarying_normals[3 * (3 * f + 1) + 1] = N[1];
        mesh.facevarying_normals[3 * (3 * f + 1) + 2] = N[2];

        mesh.facevarying_normals[3 * (3 * f + 2) + 0] = N[0];
        mesh.facevarying_normals[3 * (3 * f + 2) + 1] = N[1];
        mesh.facevarying_normals[3 * (3 * f + 2) + 2] = N[2];
      }
    }

    if (attrib.texcoords.size() > 0) {
      for (size_t f = 0; f < shapes[i].mesh.indices.size() / 3; f++) {
        size_t f0, f1, f2;

        f0 = size_t(shapes[i].mesh.indices[3 * f + 0].texcoord_index);
        f1 = size_t(shapes[i].mesh.indices[3 * f + 1].texcoord_index);
        f2 = size_t(shapes[i].mesh.indices[3 * f + 2].texcoord_index);

        if (f0 > 0 && f1 > 0 && f2 > 0) {
          float3 n0, n1, n2;

          n0[0] = attrib.texcoords[2 * f0 + 0];
          n0[1] = attrib.texcoords[2 * f0 + 1];

          n1[0] = attrib.texcoords[2 * f1 + 0];
          n1[1] = attrib.texcoords[2 * f1 + 1];

          n2[0] = attrib.texcoords[2 * f2 + 0];
          n2[1] = attrib.texcoords[2 * f2 + 1];

          mesh.facevarying_uvs[2 * (3 * f + 0) + 0] = n0[0];
          mesh.facevarying_uvs[2 * (3 * f + 0) + 1] = n0[1];

          mesh.facevarying_uvs[2 * (3 * f + 1) + 0] = n1[0];
          mesh.facevarying_uvs[2 * (3 * f + 1) + 1] = n1[1];

          mesh.facevarying_uvs[2 * (3 * f + 2) + 0] = n2[0];
          mesh.facevarying_uvs[2 * (3 * f + 2) + 1] = n2[1];
        }
      }
    }

    // Compute pivot translation and add offset to the vertices.
    float bmin[3], bmax[3];
    ComputeBoundingBoxOfMesh(bmin, bmax, mesh);

    float bcenter[3];
    bcenter[0] = 0.5f * (bmax[0] - bmin[0]) + bmin[0];
    bcenter[1] = 0.5f * (bmax[1] - bmin[1]) + bmin[1];
    bcenter[2] = 0.5f * (bmax[2] - bmin[2]) + bmin[2];

    for (size_t v = 0; v < mesh.vertices.size() / 3; v++) {
      mesh.vertices[3 * v + 0] -= bcenter[0];
      mesh.vertices[3 * v + 1] -= bcenter[1];
      mesh.vertices[3 * v + 2] -= bcenter[2];
    }

    mesh.pivot_xform[0][0] = 1.0f;
    mesh.pivot_xform[0][1] = 0.0f;
    mesh.pivot_xform[0][2] = 0.0f;
    mesh.pivot_xform[0][3] = 0.0f;

    mesh.pivot_xform[1][0] = 0.0f;
    mesh.pivot_xform[1][1] = 1.0f;
    mesh.pivot_xform[1][2] = 0.0f;
    mesh.pivot_xform[1][3] = 0.0f;

    mesh.pivot_xform[2][0] = 0.0f;
    mesh.pivot_xform[2][1] = 0.0f;
    mesh.pivot_xform[2][2] = 1.0f;
    mesh.pivot_xform[2][3] = 0.0f;

    mesh.pivot_xform[3][0] = bcenter[0];
    mesh.pivot_xform[3][1] = bcenter[1];
    mesh.pivot_xform[3][2] = bcenter[2];
    mesh.pivot_xform[3][3] = 1.0f;

    meshes->push_back(mesh);
  }

  // material_t -> Material and Texture
  out_materials->resize(materials.size());
  out_textures->resize(0);
  for (size_t i = 0; i < materials.size(); i++) {
    (*out_materials)[i].diffuse[0] = materials[i].diffuse[0];
    (*out_materials)[i].diffuse[1] = materials[i].diffuse[1];
    (*out_materials)[i].diffuse[2] = materials[i].diffuse[2];
    (*out_materials)[i].specular[0] = materials[i].specular[0];
    (*out_materials)[i].specular[1] = materials[i].specular[1];
    (*out_materials)[i].specular[2] = materials[i].specular[2];

    (*out_materials)[i].id = int(i);

    // map_Kd
    (*out_materials)[i].diffuse_texid =
        LoadTexture(materials[i].diffuse_texname, out_textures);
    // map_Ks
    (*out_materials)[i].specular_texid =
        LoadTexture(materials[i].specular_texname, out_textures);
  }

  return true;
}

}  // namespace example