| // | |
| // g++ loader_example.cc | |
| // | |
| #define TINYOBJLOADER_IMPLEMENTATION | |
| #include "tiny_obj_loader.h" | |
| #include <cassert> | |
| #include <cstdio> | |
| #include <cstdlib> | |
| #include <fstream> | |
| #include <iostream> | |
| #include <sstream> | |
| #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 | |
| 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 static_cast<time_t>(tv[1].tv_sec - tv[0].tv_sec); } | |
| time_t msec() { | |
| return this->sec() * 1000 + | |
| static_cast<time_t>((tv[1].tv_usec - tv[0].tv_usec) / 1000); | |
| } | |
| time_t usec() { | |
| return this->sec() * 1000000 + | |
| static_cast<time_t>(tv[1].tv_usec - tv[0].tv_usec); | |
| } | |
| time_t current() { | |
| struct timeval t; | |
| gettimeofday(&t, NULL); | |
| return static_cast<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 tinyobj::attrib_t& attrib, | |
| const std::vector<tinyobj::shape_t>& shapes, | |
| const std::vector<tinyobj::material_t>& materials) { | |
| std::cout << "# of vertices : " << (attrib.vertices.size() / 3) << std::endl; | |
| std::cout << "# of normals : " << (attrib.normals.size() / 3) << std::endl; | |
| std::cout << "# of texcoords : " << (attrib.texcoords.size() / 2) | |
| << std::endl; | |
| std::cout << "# of shapes : " << shapes.size() << std::endl; | |
| std::cout << "# of materials : " << materials.size() << std::endl; | |
| for (size_t v = 0; v < attrib.vertices.size() / 3; v++) { | |
| printf(" v[%ld] = (%f, %f, %f)\n", static_cast<long>(v), | |
| static_cast<const double>(attrib.vertices[3 * v + 0]), | |
| static_cast<const double>(attrib.vertices[3 * v + 1]), | |
| static_cast<const double>(attrib.vertices[3 * v + 2])); | |
| } | |
| for (size_t v = 0; v < attrib.normals.size() / 3; v++) { | |
| printf(" n[%ld] = (%f, %f, %f)\n", static_cast<long>(v), | |
| static_cast<const double>(attrib.normals[3 * v + 0]), | |
| static_cast<const double>(attrib.normals[3 * v + 1]), | |
| static_cast<const double>(attrib.normals[3 * v + 2])); | |
| } | |
| for (size_t v = 0; v < attrib.texcoords.size() / 2; v++) { | |
| printf(" uv[%ld] = (%f, %f)\n", static_cast<long>(v), | |
| static_cast<const double>(attrib.texcoords[2 * v + 0]), | |
| static_cast<const double>(attrib.texcoords[2 * v + 1])); | |
| } | |
| // For each shape | |
| for (size_t i = 0; i < shapes.size(); i++) { | |
| printf("shape[%ld].name = %s\n", static_cast<long>(i), | |
| shapes[i].name.c_str()); | |
| printf("Size of shape[%ld].indices: %lu\n", static_cast<long>(i), | |
| static_cast<unsigned long>(shapes[i].mesh.indices.size())); | |
| size_t index_offset = 0; | |
| assert(shapes[i].mesh.num_face_vertices.size() == | |
| shapes[i].mesh.material_ids.size()); | |
| printf("shape[%ld].num_faces: %lu\n", static_cast<long>(i), | |
| static_cast<unsigned long>(shapes[i].mesh.num_face_vertices.size())); | |
| // For each face | |
| for (size_t f = 0; f < shapes[i].mesh.num_face_vertices.size(); f++) { | |
| size_t fnum = shapes[i].mesh.num_face_vertices[f]; | |
| printf(" face[%ld].fnum = %ld\n", static_cast<long>(f), | |
| static_cast<unsigned long>(fnum)); | |
| // For each vertex in the face | |
| for (size_t v = 0; v < fnum; v++) { | |
| tinyobj::index_t idx = shapes[i].mesh.indices[index_offset + v]; | |
| printf(" face[%ld].v[%ld].idx = %d/%d/%d\n", static_cast<long>(f), | |
| static_cast<long>(v), idx.vertex_index, idx.normal_index, | |
| idx.texcoord_index); | |
| } | |
| printf(" face[%ld].material_id = %d\n", static_cast<long>(f), | |
| shapes[i].mesh.material_ids[f]); | |
| index_offset += fnum; | |
| } | |
| printf("shape[%ld].num_tags: %lu\n", static_cast<long>(i), | |
| static_cast<unsigned long>(shapes[i].mesh.tags.size())); | |
| for (size_t t = 0; t < shapes[i].mesh.tags.size(); t++) { | |
| printf(" tag[%ld] = %s ", static_cast<long>(t), | |
| shapes[i].mesh.tags[t].name.c_str()); | |
| printf(" ints: ["); | |
| for (size_t j = 0; j < shapes[i].mesh.tags[t].intValues.size(); ++j) { | |
| printf("%ld", static_cast<long>(shapes[i].mesh.tags[t].intValues[j])); | |
| if (j < (shapes[i].mesh.tags[t].intValues.size() - 1)) { | |
| printf(", "); | |
| } | |
| } | |
| printf("]"); | |
| printf(" floats: ["); | |
| for (size_t j = 0; j < shapes[i].mesh.tags[t].floatValues.size(); ++j) { | |
| printf("%f", static_cast<const double>( | |
| shapes[i].mesh.tags[t].floatValues[j])); | |
| if (j < (shapes[i].mesh.tags[t].floatValues.size() - 1)) { | |
| printf(", "); | |
| } | |
| } | |
| printf("]"); | |
| printf(" strings: ["); | |
| for (size_t j = 0; j < shapes[i].mesh.tags[t].stringValues.size(); ++j) { | |
| printf("%s", shapes[i].mesh.tags[t].stringValues[j].c_str()); | |
| if (j < (shapes[i].mesh.tags[t].stringValues.size() - 1)) { | |
| printf(", "); | |
| } | |
| } | |
| printf("]"); | |
| printf("\n"); | |
| } | |
| } | |
| for (size_t i = 0; i < materials.size(); i++) { | |
| printf("material[%ld].name = %s\n", static_cast<long>(i), | |
| materials[i].name.c_str()); | |
| printf(" material.Ka = (%f, %f ,%f)\n", | |
| static_cast<const double>(materials[i].ambient[0]), | |
| static_cast<const double>(materials[i].ambient[1]), | |
| static_cast<const double>(materials[i].ambient[2])); | |
| printf(" material.Kd = (%f, %f ,%f)\n", | |
| static_cast<const double>(materials[i].diffuse[0]), | |
| static_cast<const double>(materials[i].diffuse[1]), | |
| static_cast<const double>(materials[i].diffuse[2])); | |
| printf(" material.Ks = (%f, %f ,%f)\n", | |
| static_cast<const double>(materials[i].specular[0]), | |
| static_cast<const double>(materials[i].specular[1]), | |
| static_cast<const double>(materials[i].specular[2])); | |
| printf(" material.Tr = (%f, %f ,%f)\n", | |
| static_cast<const double>(materials[i].transmittance[0]), | |
| static_cast<const double>(materials[i].transmittance[1]), | |
| static_cast<const double>(materials[i].transmittance[2])); | |
| printf(" material.Ke = (%f, %f ,%f)\n", | |
| static_cast<const double>(materials[i].emission[0]), | |
| static_cast<const double>(materials[i].emission[1]), | |
| static_cast<const double>(materials[i].emission[2])); | |
| printf(" material.Ns = %f\n", | |
| static_cast<const double>(materials[i].shininess)); | |
| printf(" material.Ni = %f\n", static_cast<const double>(materials[i].ior)); | |
| printf(" material.dissolve = %f\n", | |
| static_cast<const double>(materials[i].dissolve)); | |
| printf(" material.illum = %d\n", materials[i].illum); | |
| printf(" material.map_Ka = %s\n", materials[i].ambient_texname.c_str()); | |
| printf(" material.map_Kd = %s\n", materials[i].diffuse_texname.c_str()); | |
| printf(" material.map_Ks = %s\n", materials[i].specular_texname.c_str()); | |
| 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", 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()); | |
| printf(" material.map_Ps = %s\n", materials[i].sheen_texname.c_str()); | |
| printf(" material.norm = %s\n", materials[i].normal_texname.c_str()); | |
| std::map<std::string, std::string>::const_iterator it( | |
| materials[i].unknown_parameter.begin()); | |
| std::map<std::string, std::string>::const_iterator itEnd( | |
| materials[i].unknown_parameter.end()); | |
| for (; it != itEnd; it++) { | |
| printf(" material.%s = %s\n", it->first.c_str(), it->second.c_str()); | |
| } | |
| printf("\n"); | |
| } | |
| } | |
| static bool TestLoadObj(const char* filename, const char* basepath = NULL, | |
| bool triangulate = true) { | |
| std::cout << "Loading " << filename << std::endl; | |
| tinyobj::attrib_t attrib; | |
| std::vector<tinyobj::shape_t> shapes; | |
| std::vector<tinyobj::material_t> materials; | |
| timerutil t; | |
| t.start(); | |
| std::string err; | |
| bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, filename, | |
| basepath, triangulate); | |
| t.end(); | |
| printf("Parsing time: %lu [msecs]\n", t.msec()); | |
| if (!err.empty()) { | |
| std::cerr << err << std::endl; | |
| } | |
| if (!ret) { | |
| printf("Failed to load/parse .obj.\n"); | |
| return false; | |
| } | |
| PrintInfo(attrib, shapes, materials); | |
| return true; | |
| } | |
| static bool TestStreamLoadObj() { | |
| std::cout << "Stream Loading " << std::endl; | |
| std::stringstream objStream; | |
| objStream << "mtllib cube.mtl\n" | |
| "\n" | |
| "v 0.000000 2.000000 2.000000\n" | |
| "v 0.000000 0.000000 2.000000\n" | |
| "v 2.000000 0.000000 2.000000\n" | |
| "v 2.000000 2.000000 2.000000\n" | |
| "v 0.000000 2.000000 0.000000\n" | |
| "v 0.000000 0.000000 0.000000\n" | |
| "v 2.000000 0.000000 0.000000\n" | |
| "v 2.000000 2.000000 0.000000\n" | |
| "# 8 vertices\n" | |
| "\n" | |
| "g front cube\n" | |
| "usemtl white\n" | |
| "f 1 2 3 4\n" | |
| "g back cube\n" | |
| "# expects white material\n" | |
| "f 8 7 6 5\n" | |
| "g right cube\n" | |
| "usemtl red\n" | |
| "f 4 3 7 8\n" | |
| "g top cube\n" | |
| "usemtl white\n" | |
| "f 5 1 4 8\n" | |
| "g left cube\n" | |
| "usemtl green\n" | |
| "f 5 6 2 1\n" | |
| "g bottom cube\n" | |
| "usemtl white\n" | |
| "f 2 6 7 3\n" | |
| "# 6 elements"; | |
| std::string matStream( | |
| "newmtl white\n" | |
| "Ka 0 0 0\n" | |
| "Kd 1 1 1\n" | |
| "Ks 0 0 0\n" | |
| "\n" | |
| "newmtl red\n" | |
| "Ka 0 0 0\n" | |
| "Kd 1 0 0\n" | |
| "Ks 0 0 0\n" | |
| "\n" | |
| "newmtl green\n" | |
| "Ka 0 0 0\n" | |
| "Kd 0 1 0\n" | |
| "Ks 0 0 0\n" | |
| "\n" | |
| "newmtl blue\n" | |
| "Ka 0 0 0\n" | |
| "Kd 0 0 1\n" | |
| "Ks 0 0 0\n" | |
| "\n" | |
| "newmtl light\n" | |
| "Ka 20 20 20\n" | |
| "Kd 1 1 1\n" | |
| "Ks 0 0 0"); | |
| using namespace tinyobj; | |
| class MaterialStringStreamReader : public MaterialReader { | |
| public: | |
| MaterialStringStreamReader(const std::string& matSStream) | |
| : m_matSStream(matSStream) {} | |
| virtual ~MaterialStringStreamReader() {} | |
| virtual bool operator()(const std::string& matId, | |
| std::vector<material_t>* materials, | |
| std::map<std::string, int>* matMap, | |
| std::string* err) { | |
| (void)matId; | |
| std::string warning; | |
| LoadMtl(matMap, materials, &m_matSStream, &warning); | |
| if (!warning.empty()) { | |
| if (err) { | |
| (*err) += warning; | |
| } | |
| } | |
| return true; | |
| } | |
| private: | |
| std::stringstream m_matSStream; | |
| }; | |
| MaterialStringStreamReader matSSReader(matStream); | |
| 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, &objStream, | |
| &matSSReader); | |
| if (!err.empty()) { | |
| std::cerr << err << std::endl; | |
| } | |
| if (!ret) { | |
| return false; | |
| } | |
| PrintInfo(attrib, shapes, materials); | |
| return true; | |
| } | |
| int main(int argc, char** argv) { | |
| if (argc > 1) { | |
| const char* basepath = "models/"; | |
| if (argc > 2) { | |
| basepath = argv[2]; | |
| } | |
| assert(true == TestLoadObj(argv[1], basepath)); | |
| } else { | |
| // assert(true == TestLoadObj("cornell_box.obj")); | |
| // assert(true == TestLoadObj("cube.obj")); | |
| assert(true == TestStreamLoadObj()); | |
| assert(true == | |
| TestLoadObj("models/catmark_torus_creases0.obj", "models/", false)); | |
| } | |
| return 0; | |
| } |