| /* |
| The MIT License (MIT) |
| |
| Copyright (c) 2012-2017 Syoyo Fujita and many contributors. |
| |
| Permission is hereby granted, free of charge, to any person obtaining a copy |
| of this software and associated documentation files (the "Software"), to deal |
| in the Software without restriction, including without limitation the rights |
| to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| copies of the Software, and to permit persons to whom the Software is |
| furnished to do so, subject to the following conditions: |
| |
| The above copyright notice and this permission notice shall be included in |
| all copies or substantial portions of the Software. |
| |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| THE SOFTWARE. |
| */ |
| |
| // |
| // version 1.1.0 : Support parsing vertex color(#144) |
| // version 1.0.8 : Fix parsing `g` tag just after `usemtl`(#138) |
| // version 1.0.7 : Support multiple tex options(#126) |
| // version 1.0.6 : Add TINYOBJLOADER_USE_DOUBLE option(#124) |
| // version 1.0.5 : Ignore `Tr` when `d` exists in MTL(#43) |
| // version 1.0.4 : Support multiple filenames for 'mtllib'(#112) |
| // 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. |
| // |
| |
| // |
| // Use this in *one* .cc |
| // #define TINYOBJLOADER_IMPLEMENTATION |
| // #include "tiny_obj_loader.h" |
| // |
| |
| #ifndef TINY_OBJ_LOADER_H_ |
| #define TINY_OBJ_LOADER_H_ |
| |
| #include <map> |
| #include <string> |
| #include <vector> |
| |
| 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 real_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 |
| |
| #ifdef TINYOBJLOADER_USE_DOUBLE |
| //#pragma message "using double" |
| typedef double real_t; |
| #else |
| //#pragma message "using float" |
| typedef float real_t; |
| #endif |
| |
| 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) |
| real_t sharpness; // -boost (default 1.0?) |
| real_t brightness; // base_value in -mm option (default 0) |
| real_t contrast; // gain_value in -mm option (default 1) |
| real_t origin_offset[3]; // -o u [v [w]] (default 0 0 0) |
| real_t scale[3]; // -s u [v [w]] (default 1 1 1) |
| real_t 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) |
| real_t bump_multiplier; // -bm (for bump maps only, default 1.0) |
| } texture_option_t; |
| |
| typedef struct { |
| std::string name; |
| |
| real_t ambient[3]; |
| real_t diffuse[3]; |
| real_t specular[3]; |
| real_t transmittance[3]; |
| real_t emission[3]; |
| real_t shininess; |
| real_t ior; // index of refraction |
| real_t dissolve; // 1 == opaque; 0 == fully transparent |
| // illumination model (see http://www.fileformat.info/format/material/) |
| int illum; |
| |
| int dummy; // Suppress padding warning. |
| |
| std::string ambient_texname; // map_Ka |
| std::string diffuse_texname; // map_Kd |
| std::string specular_texname; // map_Ks |
| std::string specular_highlight_texname; // map_Ns |
| std::string bump_texname; // map_bump, map_Bump, bump |
| std::string displacement_texname; // disp |
| std::string alpha_texname; // map_d |
| std::string reflection_texname; // refl |
| |
| 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; |
| texture_option_t reflection_texopt; |
| |
| // PBR extension |
| // http://exocortex.com/blog/extending_wavefront_mtl_to_support_pbr |
| real_t roughness; // [0, 1] default 0 |
| real_t metallic; // [0, 1] default 0 |
| real_t sheen; // [0, 1] default 0 |
| real_t clearcoat_thickness; // [0, 1] default 0 |
| real_t clearcoat_roughness; // [0, 1] default 0 |
| real_t anisotropy; // aniso. [0, 1] default 0 |
| real_t anisotropy_rotation; // anisor. [0, 1] default 0 |
| real_t pad0; |
| 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; |
| |
| typedef struct { |
| std::string name; |
| |
| std::vector<int> intValues; |
| std::vector<real_t> floatValues; |
| std::vector<std::string> stringValues; |
| } tag_t; |
| |
| // Index struct to support different indices for vtx/normal/texcoord. |
| // -1 means not used. |
| typedef struct { |
| int vertex_index; |
| int normal_index; |
| int texcoord_index; |
| } index_t; |
| |
| typedef struct { |
| std::vector<index_t> indices; |
| std::vector<unsigned char> num_face_vertices; // The number of vertices per |
| // face. 3 = polygon, 4 = quad, |
| // ... Up to 255. |
| std::vector<int> material_ids; // per-face material ID |
| std::vector<tag_t> tags; // SubD tag |
| } mesh_t; |
| |
| typedef struct { |
| std::string name; |
| mesh_t mesh; |
| } shape_t; |
| |
| // Vertex attributes |
| typedef struct { |
| std::vector<real_t> vertices; // 'v' |
| std::vector<real_t> normals; // 'vn' |
| std::vector<real_t> texcoords; // 'vt' |
| std::vector<real_t> colors; // extension: vertex colors |
| } attrib_t; |
| |
| typedef struct callback_t_ { |
| // W is optional and set to 1 if there is no `w` item in `v` line |
| void (*vertex_cb)(void *user_data, real_t x, real_t y, real_t z, real_t w); |
| void (*normal_cb)(void *user_data, real_t x, real_t y, real_t z); |
| |
| // y and z are optional and set to 0 if there is no `y` and/or `z` item(s) in |
| // `vt` line. |
| void (*texcoord_cb)(void *user_data, real_t x, real_t y, real_t z); |
| |
| // called per 'f' line. num_indices is the number of face indices(e.g. 3 for |
| // triangle, 4 for quad) |
| // 0 will be passed for undefined index in index_t members. |
| void (*index_cb)(void *user_data, index_t *indices, int num_indices); |
| // `name` material name, `material_id` = the array index of material_t[]. -1 |
| // if |
| // a material not found in .mtl |
| void (*usemtl_cb)(void *user_data, const char *name, int material_id); |
| // `materials` = parsed material data. |
| void (*mtllib_cb)(void *user_data, const material_t *materials, |
| int num_materials); |
| // There may be multiple group names |
| void (*group_cb)(void *user_data, const char **names, int num_names); |
| void (*object_cb)(void *user_data, const char *name); |
| |
| callback_t_() |
| : vertex_cb(NULL), |
| normal_cb(NULL), |
| texcoord_cb(NULL), |
| index_cb(NULL), |
| usemtl_cb(NULL), |
| mtllib_cb(NULL), |
| group_cb(NULL), |
| object_cb(NULL) {} |
| } callback_t; |
| |
| class MaterialReader { |
| public: |
| MaterialReader() {} |
| virtual ~MaterialReader(); |
| |
| virtual bool operator()(const std::string &matId, |
| std::vector<material_t> *materials, |
| std::map<std::string, int> *matMap, |
| std::string *err) = 0; |
| }; |
| |
| class MaterialFileReader : public MaterialReader { |
| public: |
| explicit MaterialFileReader(const std::string &mtl_basedir) |
| : m_mtlBaseDir(mtl_basedir) {} |
| virtual ~MaterialFileReader() {} |
| virtual bool operator()(const std::string &matId, |
| std::vector<material_t> *materials, |
| std::map<std::string, int> *matMap, std::string *err); |
| |
| private: |
| std::string m_mtlBaseDir; |
| }; |
| |
| class MaterialStreamReader : public MaterialReader { |
| public: |
| explicit MaterialStreamReader(std::istream &inStream) |
| : m_inStream(inStream) {} |
| virtual ~MaterialStreamReader() {} |
| virtual bool operator()(const std::string &matId, |
| std::vector<material_t> *materials, |
| std::map<std::string, int> *matMap, std::string *err); |
| |
| private: |
| std::istream &m_inStream; |
| }; |
| |
| /// Loads .obj from a file. |
| /// 'attrib', 'shapes' and 'materials' will be filled with parsed shape data |
| /// 'shapes' will be filled with parsed shape data |
| /// Returns true when loading .obj become success. |
| /// Returns warning and error message into `err` |
| /// 'mtl_basedir' is optional, and used for base directory for .mtl file. |
| /// In default(`NULL'), .mtl file is searched from an application's working |
| /// directory. |
| /// 'triangulate' is optional, and used whether triangulate polygon face in .obj |
| /// or not. |
| bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes, |
| std::vector<material_t> *materials, std::string *err, |
| const char *filename, const char *mtl_basedir = NULL, |
| bool triangulate = true); |
| |
| /// Loads .obj from a file with custom user callback. |
| /// .mtl is loaded as usual and parsed material_t data will be passed to |
| /// `callback.mtllib_cb`. |
| /// Returns true when loading .obj/.mtl become success. |
| /// Returns warning and error message into `err` |
| /// See `examples/callback_api/` for how to use this function. |
| bool LoadObjWithCallback(std::istream &inStream, const callback_t &callback, |
| void *user_data = NULL, |
| MaterialReader *readMatFn = NULL, |
| std::string *err = NULL); |
| |
| /// Loads object from a std::istream, uses GetMtlIStreamFn to retrieve |
| /// std::istream for materials. |
| /// Returns true when loading .obj become success. |
| /// Returns warning and error message into `err` |
| bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes, |
| std::vector<material_t> *materials, std::string *err, |
| std::istream *inStream, MaterialReader *readMatFn = NULL, |
| bool triangulate = true); |
| |
| /// Loads materials into std::map |
| void LoadMtl(std::map<std::string, int> *material_map, |
| std::vector<material_t> *materials, std::istream *inStream, |
| std::string *warning); |
| |
| } // namespace tinyobj |
| |
| #endif // TINY_OBJ_LOADER_H_ |
| |
| #ifdef TINYOBJLOADER_IMPLEMENTATION |
| #include <cassert> |
| #include <cctype> |
| #include <cmath> |
| #include <cstddef> |
| #include <cstdlib> |
| #include <cstring> |
| #include <utility> |
| |
| #include <fstream> |
| #include <sstream> |
| |
| namespace tinyobj { |
| |
| MaterialReader::~MaterialReader() {} |
| |
| struct vertex_index { |
| int v_idx, vt_idx, vn_idx; |
| vertex_index() : v_idx(-1), vt_idx(-1), vn_idx(-1) {} |
| 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) {} |
| }; |
| |
| struct tag_sizes { |
| tag_sizes() : num_ints(0), num_reals(0), num_strings(0) {} |
| int num_ints; |
| int num_reals; |
| int num_strings; |
| }; |
| |
| struct obj_shape { |
| std::vector<real_t> v; |
| std::vector<real_t> vn; |
| std::vector<real_t> vt; |
| }; |
| |
| // See |
| // http://stackoverflow.com/questions/6089231/getting-std-ifstream-to-handle-lf-cr-and-crlf |
| static 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(); |
| |
| if (se) { |
| 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 += static_cast<char>(c); |
| } |
| } |
| } |
| |
| return is; |
| } |
| |
| #define IS_SPACE(x) (((x) == ' ') || ((x) == '\t')) |
| #define IS_DIGIT(x) \ |
| (static_cast<unsigned int>((x) - '0') < static_cast<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 bool fixIndex(int idx, int n, int *ret) { |
| if (!ret) { |
| return false; |
| } |
| |
| if (idx > 0) { |
| (*ret) = idx - 1; |
| return true; |
| } |
| |
| if (idx == 0) { |
| // zero is not allowed according to the spec. |
| return false; |
| } |
| |
| if (idx < 0) { |
| (*ret) = n + idx; // negative value = relative |
| return true; |
| } |
| |
| return false; // never reach here. |
| } |
| |
| static inline std::string parseString(const char **token) { |
| std::string s; |
| (*token) += strspn((*token), " \t"); |
| size_t e = strcspn((*token), " \t\r"); |
| s = std::string((*token), &(*token)[e]); |
| (*token) += e; |
| return s; |
| } |
| |
| static inline int parseInt(const char **token) { |
| (*token) += strspn((*token), " \t"); |
| int i = atoi((*token)); |
| (*token) += strcspn((*token), " \t\r"); |
| return i; |
| } |
| |
| // Tries to parse a floating point number located at s. |
| // |
| // s_end should be a location in the string where reading should absolutely |
| // stop. For example at the end of the string, to prevent buffer overflows. |
| // |
| // Parses the following EBNF grammar: |
| // sign = "+" | "-" ; |
| // END = ? anything not in digit ? |
| // digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ; |
| // integer = [sign] , digit , {digit} ; |
| // decimal = integer , ["." , integer] ; |
| // float = ( decimal , END ) | ( decimal , ("E" | "e") , integer , END ) ; |
| // |
| // Valid strings are for example: |
| // -0 +3.1417e+2 -0.0E-3 1.0324 -1.41 11e2 |
| // |
| // If the parsing is a success, result is set to the parsed value and true |
| // is returned. |
| // |
| // The function is greedy and will parse until any of the following happens: |
| // - a non-conforming character is encountered. |
| // - s_end is reached. |
| // |
| // The following situations triggers a failure: |
| // - s >= s_end. |
| // - parse failure. |
| // |
| static bool tryParseDouble(const char *s, const char *s_end, double *result) { |
| if (s >= s_end) { |
| return false; |
| } |
| |
| double mantissa = 0.0; |
| // This exponent is base 2 rather than 10. |
| // However the exponent we parse is supposed to be one of ten, |
| // thus we must take care to convert the exponent/and or the |
| // mantissa to a * 2^E, where a is the mantissa and E is the |
| // exponent. |
| // To get the final double we will use ldexp, it requires the |
| // exponent to be in base 2. |
| int exponent = 0; |
| |
| // NOTE: THESE MUST BE DECLARED HERE SINCE WE ARE NOT ALLOWED |
| // TO JUMP OVER DEFINITIONS. |
| char sign = '+'; |
| char exp_sign = '+'; |
| char const *curr = s; |
| |
| // How many characters were read in a loop. |
| int read = 0; |
| // Tells whether a loop terminated due to reaching s_end. |
| bool end_not_reached = false; |
| |
| /* |
| BEGIN PARSING. |
| */ |
| |
| // Find out what sign we've got. |
| if (*curr == '+' || *curr == '-') { |
| sign = *curr; |
| curr++; |
| } else if (IS_DIGIT(*curr)) { /* Pass through. */ |
| } else { |
| goto fail; |
| } |
| |
| // Read the integer part. |
| end_not_reached = (curr != s_end); |
| while (end_not_reached && IS_DIGIT(*curr)) { |
| mantissa *= 10; |
| mantissa += static_cast<int>(*curr - 0x30); |
| curr++; |
| read++; |
| end_not_reached = (curr != s_end); |
| } |
| |
| // We must make sure we actually got something. |
| if (read == 0) goto fail; |
| // We allow numbers of form "#", "###" etc. |
| if (!end_not_reached) goto assemble; |
| |
| // Read the decimal part. |
| if (*curr == '.') { |
| curr++; |
| 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) * |
| (read < lut_entries ? pow_lut[read] : std::pow(10.0, -read)); |
| read++; |
| curr++; |
| end_not_reached = (curr != s_end); |
| } |
| } else if (*curr == 'e' || *curr == 'E') { |
| } else { |
| goto assemble; |
| } |
| |
| if (!end_not_reached) goto assemble; |
| |
| // Read the exponent part. |
| if (*curr == 'e' || *curr == 'E') { |
| curr++; |
| // Figure out if a sign is present and if it is. |
| end_not_reached = (curr != s_end); |
| if (end_not_reached && (*curr == '+' || *curr == '-')) { |
| exp_sign = *curr; |
| curr++; |
| } else if (IS_DIGIT(*curr)) { /* Pass through. */ |
| } else { |
| // Empty E is not allowed. |
| goto fail; |
| } |
| |
| read = 0; |
| end_not_reached = (curr != s_end); |
| while (end_not_reached && IS_DIGIT(*curr)) { |
| exponent *= 10; |
| exponent += static_cast<int>(*curr - 0x30); |
| curr++; |
| read++; |
| end_not_reached = (curr != s_end); |
| } |
| exponent *= (exp_sign == '+' ? 1 : -1); |
| if (read == 0) goto fail; |
| } |
| |
| assemble: |
| *result = (sign == '+' ? 1 : -1) * |
| (exponent ? std::ldexp(mantissa * std::pow(5.0, exponent), exponent) |
| : mantissa); |
| return true; |
| fail: |
| return false; |
| } |
| |
| static inline real_t parseReal(const char **token, double default_value = 0.0) { |
| (*token) += strspn((*token), " \t"); |
| const char *end = (*token) + strcspn((*token), " \t\r"); |
| double val = default_value; |
| tryParseDouble((*token), end, &val); |
| real_t f = static_cast<real_t>(val); |
| (*token) = end; |
| return f; |
| } |
| |
| static inline bool parseReal(const char **token, real_t *out) { |
| (*token) += strspn((*token), " \t"); |
| const char *end = (*token) + strcspn((*token), " \t\r"); |
| double val; |
| bool ret = tryParseDouble((*token), end, &val); |
| if (ret) { |
| real_t f = static_cast<real_t>(val); |
| (*out) = f; |
| } |
| (*token) = end; |
| return ret; |
| } |
| |
| static inline void parseReal2(real_t *x, real_t *y, const char **token, |
| const double default_x = 0.0, |
| const double default_y = 0.0) { |
| (*x) = parseReal(token, default_x); |
| (*y) = parseReal(token, default_y); |
| } |
| |
| static inline void parseReal3(real_t *x, real_t *y, real_t *z, |
| const char **token, const double default_x = 0.0, |
| const double default_y = 0.0, |
| const double default_z = 0.0) { |
| (*x) = parseReal(token, default_x); |
| (*y) = parseReal(token, default_y); |
| (*z) = parseReal(token, default_z); |
| } |
| |
| static inline void parseV(real_t *x, real_t *y, real_t *z, real_t *w, |
| 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) = parseReal(token, default_x); |
| (*y) = parseReal(token, default_y); |
| (*z) = parseReal(token, default_z); |
| (*w) = parseReal(token, default_w); |
| } |
| |
| // Extension: parse vertex with colors(6 items) |
| static inline bool parseVertexWithColor(real_t *x, real_t *y, real_t *z, real_t *r, |
| real_t *g, real_t *b, |
| const char **token, const double default_x = 0.0, |
| const double default_y = 0.0, |
| const double default_z = 0.0) { |
| (*x) = parseReal(token, default_x); |
| (*y) = parseReal(token, default_y); |
| (*z) = parseReal(token, default_z); |
| |
| (*r) = parseReal(token, 1.0); |
| (*g) = parseReal(token, 1.0); |
| (*b) = parseReal(token, 1.0); |
| |
| return true; |
| } |
| |
| 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) { |
| tag_sizes ts; |
| |
| (*token) += strspn((*token), " \t"); |
| ts.num_ints = atoi((*token)); |
| (*token) += strcspn((*token), "/ \t\r"); |
| if ((*token)[0] != '/') { |
| return ts; |
| } |
| |
| (*token)++; // Skip '/' |
| |
| (*token) += strspn((*token), " \t"); |
| ts.num_reals = atoi((*token)); |
| (*token) += strcspn((*token), "/ \t\r"); |
| if ((*token)[0] != '/') { |
| return ts; |
| } |
| (*token)++; // Skip '/' |
| |
| ts.num_strings = parseInt(token); |
| |
| return ts; |
| } |
| |
| // Parse triples with index offsets: i, i/j/k, i//k, i/j |
| static bool parseTriple(const char **token, int vsize, int vnsize, int vtsize, |
| vertex_index *ret) { |
| if (!ret) { |
| return false; |
| } |
| |
| vertex_index vi(-1); |
| |
| if (!fixIndex(atoi((*token)), vsize, &(vi.v_idx))) { |
| return false; |
| } |
| |
| (*token) += strcspn((*token), "/ \t\r"); |
| if ((*token)[0] != '/') { |
| (*ret) = vi; |
| return true; |
| } |
| (*token)++; |
| |
| // i//k |
| if ((*token)[0] == '/') { |
| (*token)++; |
| if (!fixIndex(atoi((*token)), vnsize, &(vi.vn_idx))) { |
| return false; |
| } |
| (*token) += strcspn((*token), "/ \t\r"); |
| (*ret) = vi; |
| return true; |
| } |
| |
| // i/j/k or i/j |
| if (!fixIndex(atoi((*token)), vtsize, &(vi.vt_idx))) { |
| return false; |
| } |
| |
| (*token) += strcspn((*token), "/ \t\r"); |
| if ((*token)[0] != '/') { |
| (*ret) = vi; |
| return true; |
| } |
| |
| // i/j/k |
| (*token)++; // skip '/' |
| if (!fixIndex(atoi((*token)), vnsize, &(vi.vn_idx))) { |
| return false; |
| } |
| (*token) += strcspn((*token), "/ \t\r"); |
| |
| (*ret) = vi; |
| |
| return true; |
| } |
| |
| // Parse raw triples: i, i/j/k, i//k, i/j |
| static vertex_index parseRawTriple(const char **token) { |
| vertex_index vi(static_cast<int>(0)); // 0 is an invalid index in OBJ |
| |
| vi.v_idx = atoi((*token)); |
| (*token) += strcspn((*token), "/ \t\r"); |
| if ((*token)[0] != '/') { |
| return vi; |
| } |
| (*token)++; |
| |
| // i//k |
| if ((*token)[0] == '/') { |
| (*token)++; |
| vi.vn_idx = atoi((*token)); |
| (*token) += strcspn((*token), "/ \t\r"); |
| return vi; |
| } |
| |
| // i/j/k or i/j |
| vi.vt_idx = atoi((*token)); |
| (*token) += strcspn((*token), "/ \t\r"); |
| if ((*token)[0] != '/') { |
| return vi; |
| } |
| |
| // i/j/k |
| (*token)++; // skip '/' |
| vi.vn_idx = atoi((*token)); |
| (*token) += strcspn((*token), "/ \t\r"); |
| 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))) { |
| token += strspn(token, " \t"); // skip space |
| 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 = parseReal(&token, 1.0); |
| } else if ((0 == strncmp(token, "-bm", 3)) && IS_SPACE((token[3]))) { |
| token += 4; |
| texopt->bump_multiplier = parseReal(&token, 1.0); |
| } else if ((0 == strncmp(token, "-o", 2)) && IS_SPACE((token[2]))) { |
| token += 3; |
| parseReal3(&(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; |
| parseReal3(&(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; |
| parseReal3(&(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; |
| parseReal2(&(texopt->brightness), &(texopt->contrast), &token, 0.0, 1.0); |
| } else { |
| // Assume texture filename |
| #if 0 |
| 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 |
| #else |
| // Read filename until line end to parse filename containing whitespace |
| // TODO(syoyo): Support parsing texture option flag after the filename. |
| texture_name = std::string(token); |
| token += texture_name.length(); |
| #endif |
| |
| 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 = ""; |
| material->diffuse_texname = ""; |
| material->specular_texname = ""; |
| material->specular_highlight_texname = ""; |
| material->bump_texname = ""; |
| material->displacement_texname = ""; |
| material->reflection_texname = ""; |
| material->alpha_texname = ""; |
| for (int i = 0; i < 3; i++) { |
| material->ambient[i] = 0.f; |
| material->diffuse[i] = 0.f; |
| material->specular[i] = 0.f; |
| material->transmittance[i] = 0.f; |
| material->emission[i] = 0.f; |
| } |
| material->illum = 0; |
| material->dissolve = 1.f; |
| material->shininess = 1.f; |
| material->ior = 1.f; |
| |
| material->roughness = 0.f; |
| material->metallic = 0.f; |
| material->sheen = 0.f; |
| material->clearcoat_thickness = 0.f; |
| material->clearcoat_roughness = 0.f; |
| material->anisotropy_rotation = 0.f; |
| material->anisotropy = 0.f; |
| material->roughness_texname = ""; |
| material->metallic_texname = ""; |
| material->sheen_texname = ""; |
| material->emissive_texname = ""; |
| material->normal_texname = ""; |
| |
| material->unknown_parameter.clear(); |
| } |
| |
| static bool exportFaceGroupToShape( |
| shape_t *shape, const std::vector<std::vector<vertex_index> > &faceGroup, |
| const std::vector<tag_t> &tags, const int material_id, |
| const std::string &name, bool triangulate) { |
| if (faceGroup.empty()) { |
| return false; |
| } |
| |
| // Flatten vertices and indices |
| for (size_t i = 0; i < faceGroup.size(); i++) { |
| const std::vector<vertex_index> &face = faceGroup[i]; |
| |
| vertex_index i0 = face[0]; |
| vertex_index i1(-1); |
| vertex_index i2 = face[1]; |
| |
| size_t npolys = face.size(); |
| |
| if (triangulate) { |
| // Polygon -> triangle fan conversion |
| for (size_t k = 2; k < npolys; k++) { |
| i1 = i2; |
| i2 = face[k]; |
| |
| index_t idx0, idx1, idx2; |
| idx0.vertex_index = i0.v_idx; |
| idx0.normal_index = i0.vn_idx; |
| idx0.texcoord_index = i0.vt_idx; |
| idx1.vertex_index = i1.v_idx; |
| idx1.normal_index = i1.vn_idx; |
| idx1.texcoord_index = i1.vt_idx; |
| idx2.vertex_index = i2.v_idx; |
| idx2.normal_index = i2.vn_idx; |
| idx2.texcoord_index = i2.vt_idx; |
| |
| shape->mesh.indices.push_back(idx0); |
| shape->mesh.indices.push_back(idx1); |
| shape->mesh.indices.push_back(idx2); |
| |
| shape->mesh.num_face_vertices.push_back(3); |
| shape->mesh.material_ids.push_back(material_id); |
| } |
| } else { |
| for (size_t k = 0; k < npolys; k++) { |
| index_t idx; |
| idx.vertex_index = face[k].v_idx; |
| idx.normal_index = face[k].vn_idx; |
| idx.texcoord_index = face[k].vt_idx; |
| shape->mesh.indices.push_back(idx); |
| } |
| |
| shape->mesh.num_face_vertices.push_back( |
| static_cast<unsigned char>(npolys)); |
| shape->mesh.material_ids.push_back(material_id); // per face |
| } |
| } |
| |
| shape->name = name; |
| shape->mesh.tags = tags; |
| |
| return true; |
| } |
| |
| // Split a string with specified delimiter character. |
| // http://stackoverflow.com/questions/236129/split-a-string-in-c |
| static void SplitString(const std::string &s, char delim, |
| std::vector<std::string> &elems) { |
| std::stringstream ss; |
| ss.str(s); |
| std::string item; |
| while (std::getline(ss, item, delim)) { |
| elems.push_back(item); |
| } |
| } |
| |
| void LoadMtl(std::map<std::string, int> *material_map, |
| std::vector<material_t> *materials, std::istream *inStream, |
| std::string *warning) { |
| // Create a default material anyway. |
| material_t material; |
| InitMaterial(&material); |
| |
| // Issue 43. `d` wins against `Tr` since `Tr` is not in the MTL specification. |
| bool has_d = false; |
| bool has_tr = false; |
| |
| std::stringstream ss; |
| |
| std::string linebuf; |
| while (inStream->peek() != -1) { |
| safeGetline(*inStream, linebuf); |
| |
| // 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) { |
| if (linebuf[linebuf.size() - 1] == '\n') |
| linebuf.erase(linebuf.size() - 1); |
| } |
| if (linebuf.size() > 0) { |
| if (linebuf[linebuf.size() - 1] == '\r') |
| linebuf.erase(linebuf.size() - 1); |
| } |
| |
| // Skip if empty line. |
| if (linebuf.empty()) { |
| continue; |
| } |
| |
| // Skip leading space. |
| const char *token = linebuf.c_str(); |
| token += strspn(token, " \t"); |
| |
| assert(token); |
| if (token[0] == '\0') continue; // empty line |
| |
| if (token[0] == '#') continue; // comment line |
| |
| // new mtl |
| if ((0 == strncmp(token, "newmtl", 6)) && IS_SPACE((token[6]))) { |
| // flush previous material. |
| if (!material.name.empty()) { |
| material_map->insert(std::pair<std::string, int>( |
| material.name, static_cast<int>(materials->size()))); |
| materials->push_back(material); |
| } |
| |
| // initial temporary material |
| InitMaterial(&material); |
| |
| has_d = false; |
| has_tr = false; |
| |
| // set new mtl name |
| token += 7; |
| { |
| std::stringstream sstr; |
| sstr << token; |
| material.name = sstr.str(); |
| } |
| continue; |
| } |
| |
| // ambient |
| if (token[0] == 'K' && token[1] == 'a' && IS_SPACE((token[2]))) { |
| token += 2; |
| real_t r, g, b; |
| parseReal3(&r, &g, &b, &token); |
| material.ambient[0] = r; |
| material.ambient[1] = g; |
| material.ambient[2] = b; |
| continue; |
| } |
| |
| // diffuse |
| if (token[0] == 'K' && token[1] == 'd' && IS_SPACE((token[2]))) { |
| token += 2; |
| real_t r, g, b; |
| parseReal3(&r, &g, &b, &token); |
| material.diffuse[0] = r; |
| material.diffuse[1] = g; |
| material.diffuse[2] = b; |
| continue; |
| } |
| |
| // specular |
| if (token[0] == 'K' && token[1] == 's' && IS_SPACE((token[2]))) { |
| token += 2; |
| real_t r, g, b; |
| parseReal3(&r, &g, &b, &token); |
| material.specular[0] = r; |
| material.specular[1] = g; |
| material.specular[2] = b; |
| continue; |
| } |
| |
| // transmittance |
| if ((token[0] == 'K' && token[1] == 't' && IS_SPACE((token[2]))) || |
| (token[0] == 'T' && token[1] == 'f' && IS_SPACE((token[2])))) { |
| token += 2; |
| real_t r, g, b; |
| parseReal3(&r, &g, &b, &token); |
| material.transmittance[0] = r; |
| material.transmittance[1] = g; |
| material.transmittance[2] = b; |
| continue; |
| } |
| |
| // ior(index of refraction) |
| if (token[0] == 'N' && token[1] == 'i' && IS_SPACE((token[2]))) { |
| token += 2; |
| material.ior = parseReal(&token); |
| continue; |
| } |
| |
| // emission |
| if (token[0] == 'K' && token[1] == 'e' && IS_SPACE(token[2])) { |
| token += 2; |
| real_t r, g, b; |
| parseReal3(&r, &g, &b, &token); |
| material.emission[0] = r; |
| material.emission[1] = g; |
| material.emission[2] = b; |
| continue; |
| } |
| |
| // shininess |
| if (token[0] == 'N' && token[1] == 's' && IS_SPACE(token[2])) { |
| token += 2; |
| material.shininess = parseReal(&token); |
| continue; |
| } |
| |
| // illum model |
| if (0 == strncmp(token, "illum", 5) && IS_SPACE(token[5])) { |
| token += 6; |
| material.illum = parseInt(&token); |
| continue; |
| } |
| |
| // dissolve |
| if ((token[0] == 'd' && IS_SPACE(token[1]))) { |
| token += 1; |
| material.dissolve = parseReal(&token); |
| |
| if (has_tr) { |
| ss << "WARN: Both `d` and `Tr` parameters defined for \"" |
| << material.name << "\". Use the value of `d` for dissolve." |
| << std::endl; |
| } |
| has_d = true; |
| continue; |
| } |
| if (token[0] == 'T' && token[1] == 'r' && IS_SPACE(token[2])) { |
| token += 2; |
| if (has_d) { |
| // `d` wins. Ignore `Tr` value. |
| ss << "WARN: Both `d` and `Tr` parameters defined for \"" |
| << material.name << "\". Use the value of `d` for dissolve." |
| << std::endl; |
| } else { |
| // We invert value of Tr(assume Tr is in range [0, 1]) |
| // NOTE: Interpretation of Tr is application(exporter) dependent. For |
| // some application(e.g. 3ds max obj exporter), Tr = d(Issue 43) |
| material.dissolve = 1.0f - parseReal(&token); |
| } |
| has_tr = true; |
| continue; |
| } |
| |
| // PBR: roughness |
| if (token[0] == 'P' && token[1] == 'r' && IS_SPACE(token[2])) { |
| token += 2; |
| material.roughness = parseReal(&token); |
| continue; |
| } |
| |
| // PBR: metallic |
| if (token[0] == 'P' && token[1] == 'm' && IS_SPACE(token[2])) { |
| token += 2; |
| material.metallic = parseReal(&token); |
| continue; |
| } |
| |
| // PBR: sheen |
| if (token[0] == 'P' && token[1] == 's' && IS_SPACE(token[2])) { |
| token += 2; |
| material.sheen = parseReal(&token); |
| continue; |
| } |
| |
| // PBR: clearcoat thickness |
| if (token[0] == 'P' && token[1] == 'c' && IS_SPACE(token[2])) { |
| token += 2; |
| material.clearcoat_thickness = parseReal(&token); |
| continue; |
| } |
| |
| // PBR: clearcoat roughness |
| if ((0 == strncmp(token, "Pcr", 3)) && IS_SPACE(token[3])) { |
| token += 4; |
| material.clearcoat_roughness = parseReal(&token); |
| continue; |
| } |
| |
| // PBR: anisotropy |
| if ((0 == strncmp(token, "aniso", 5)) && IS_SPACE(token[5])) { |
| token += 6; |
| material.anisotropy = parseReal(&token); |
| continue; |
| } |
| |
| // PBR: anisotropy rotation |
| if ((0 == strncmp(token, "anisor", 6)) && IS_SPACE(token[6])) { |
| token += 7; |
| material.anisotropy_rotation = parseReal(&token); |
| continue; |
| } |
| |
| // ambient texture |
| if ((0 == strncmp(token, "map_Ka", 6)) && IS_SPACE(token[6])) { |
| token += 7; |
| 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; |
| 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; |
| 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; |
| 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; |
| ParseTextureNameAndOption(&(material.bump_texname), |
| &(material.bump_texopt), token, |
| /* is_bump */ true); |
| continue; |
| } |
| |
| // bump texture |
| if ((0 == strncmp(token, "map_Bump", 8)) && IS_SPACE(token[8])) { |
| token += 9; |
| 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; |
| } |
| |
| // alpha texture |
| if ((0 == strncmp(token, "map_d", 5)) && IS_SPACE(token[5])) { |
| token += 6; |
| material.alpha_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; |
| ParseTextureNameAndOption(&(material.displacement_texname), |
| &(material.displacement_texopt), token, |
| /* is_bump */ false); |
| continue; |
| } |
| |
| // reflection map |
| if ((0 == strncmp(token, "refl", 4)) && IS_SPACE(token[4])) { |
| token += 5; |
| ParseTextureNameAndOption(&(material.reflection_texname), |
| &(material.reflection_texopt), token, |
| /* is_bump */ false); |
| continue; |
| } |
| |
| // PBR: roughness texture |
| if ((0 == strncmp(token, "map_Pr", 6)) && IS_SPACE(token[6])) { |
| token += 7; |
| 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; |
| 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; |
| 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; |
| 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; |
| ParseTextureNameAndOption( |
| &(material.normal_texname), &(material.normal_texopt), token, |
| /* is_bump */ false); // @fixme { is_bump will be true? } |
| continue; |
| } |
| |
| // unknown parameter |
| const char *_space = strchr(token, ' '); |
| if (!_space) { |
| _space = strchr(token, '\t'); |
| } |
| if (_space) { |
| std::ptrdiff_t len = _space - token; |
| std::string key(token, static_cast<size_t>(len)); |
| std::string value = _space + 1; |
| material.unknown_parameter.insert( |
| std::pair<std::string, std::string>(key, value)); |
| } |
| } |
| // flush last material. |
| material_map->insert(std::pair<std::string, int>( |
| material.name, static_cast<int>(materials->size()))); |
| materials->push_back(material); |
| |
| if (warning) { |
| (*warning) = ss.str(); |
| } |
| } |
| |
| bool MaterialFileReader::operator()(const std::string &matId, |
| std::vector<material_t> *materials, |
| std::map<std::string, int> *matMap, |
| std::string *err) { |
| std::string filepath; |
| |
| if (!m_mtlBaseDir.empty()) { |
| filepath = std::string(m_mtlBaseDir) + matId; |
| } else { |
| filepath = matId; |
| } |
| |
| std::ifstream matIStream(filepath.c_str()); |
| if (!matIStream) { |
| std::stringstream ss; |
| ss << "WARN: Material file [ " << filepath << " ] not found." << std::endl; |
| if (err) { |
| (*err) += ss.str(); |
| } |
| return false; |
| } |
| |
| std::string warning; |
| LoadMtl(matMap, materials, &matIStream, &warning); |
| |
| if (!warning.empty()) { |
| if (err) { |
| (*err) += warning; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool MaterialStreamReader::operator()(const std::string &matId, |
| std::vector<material_t> *materials, |
| std::map<std::string, int> *matMap, |
| std::string *err) { |
| (void)matId; |
| if (!m_inStream) { |
| std::stringstream ss; |
| ss << "WARN: Material stream in error state. " << std::endl; |
| if (err) { |
| (*err) += ss.str(); |
| } |
| return false; |
| } |
| |
| std::string warning; |
| LoadMtl(matMap, materials, &m_inStream, &warning); |
| |
| if (!warning.empty()) { |
| if (err) { |
| (*err) += warning; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes, |
| std::vector<material_t> *materials, std::string *err, |
| const char *filename, const char *mtl_basedir, bool trianglulate) { |
| attrib->vertices.clear(); |
| attrib->normals.clear(); |
| attrib->texcoords.clear(); |
| attrib->colors.clear(); |
| shapes->clear(); |
| |
| std::stringstream errss; |
| |
| std::ifstream ifs(filename); |
| if (!ifs) { |
| errss << "Cannot open file [" << filename << "]" << std::endl; |
| if (err) { |
| (*err) = errss.str(); |
| } |
| return false; |
| } |
| |
| std::string baseDir; |
| if (mtl_basedir) { |
| baseDir = mtl_basedir; |
| } |
| MaterialFileReader matFileReader(baseDir); |
| |
| return LoadObj(attrib, shapes, materials, err, &ifs, &matFileReader, |
| trianglulate); |
| } |
| |
| bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes, |
| std::vector<material_t> *materials, std::string *err, |
| std::istream *inStream, MaterialReader *readMatFn /*= NULL*/, |
| bool triangulate) { |
| std::stringstream errss; |
| |
| std::vector<real_t> v; |
| std::vector<real_t> vn; |
| std::vector<real_t> vt; |
| std::vector<real_t> vc; |
| std::vector<tag_t> tags; |
| std::vector<std::vector<vertex_index> > faceGroup; |
| std::string name; |
| |
| // material |
| std::map<std::string, int> material_map; |
| int material = -1; |
| |
| shape_t shape; |
| |
| std::string linebuf; |
| while (inStream->peek() != -1) { |
| safeGetline(*inStream, linebuf); |
| |
| // Trim newline '\r\n' or '\n' |
| if (linebuf.size() > 0) { |
| if (linebuf[linebuf.size() - 1] == '\n') |
| linebuf.erase(linebuf.size() - 1); |
| } |
| if (linebuf.size() > 0) { |
| if (linebuf[linebuf.size() - 1] == '\r') |
| linebuf.erase(linebuf.size() - 1); |
| } |
| |
| // Skip if empty line. |
| if (linebuf.empty()) { |
| continue; |
| } |
| |
| // Skip leading space. |
| const char *token = linebuf.c_str(); |
| token += strspn(token, " \t"); |
| |
| assert(token); |
| if (token[0] == '\0') continue; // empty line |
| |
| if (token[0] == '#') continue; // comment line |
| |
| // vertex |
| if (token[0] == 'v' && IS_SPACE((token[1]))) { |
| token += 2; |
| real_t x, y, z; |
| real_t r, g, b; |
| parseVertexWithColor(&x, &y, &z, &r, &g, &b, &token); |
| v.push_back(x); |
| v.push_back(y); |
| v.push_back(z); |
| |
| vc.push_back(r); |
| vc.push_back(g); |
| vc.push_back(b); |
| continue; |
| } |
| |
| // normal |
| if (token[0] == 'v' && token[1] == 'n' && IS_SPACE((token[2]))) { |
| token += 3; |
| real_t x, y, z; |
| parseReal3(&x, &y, &z, &token); |
| vn.push_back(x); |
| vn.push_back(y); |
| vn.push_back(z); |
| continue; |
| } |
| |
| // texcoord |
| if (token[0] == 'v' && token[1] == 't' && IS_SPACE((token[2]))) { |
| token += 3; |
| real_t x, y; |
| parseReal2(&x, &y, &token); |
| vt.push_back(x); |
| vt.push_back(y); |
| continue; |
| } |
| |
| // face |
| if (token[0] == 'f' && IS_SPACE((token[1]))) { |
| token += 2; |
| token += strspn(token, " \t"); |
| |
| std::vector<vertex_index> face; |
| face.reserve(3); |
| |
| while (!IS_NEW_LINE(token[0])) { |
| vertex_index vi; |
| if (!parseTriple(&token, static_cast<int>(v.size() / 3), |
| static_cast<int>(vn.size() / 3), |
| static_cast<int>(vt.size() / 2), &vi)) { |
| if (err) { |
| (*err) = "Failed parse `f' line(e.g. zero value for face index).\n"; |
| } |
| return false; |
| } |
| |
| face.push_back(vi); |
| size_t n = strspn(token, " \t\r"); |
| token += n; |
| } |
| |
| // replace with emplace_back + std::move on C++11 |
| faceGroup.push_back(std::vector<vertex_index>()); |
| faceGroup[faceGroup.size() - 1].swap(face); |
| |
| continue; |
| } |
| |
| // use mtl |
| if ((0 == strncmp(token, "usemtl", 6)) && IS_SPACE((token[6]))) { |
| token += 7; |
| std::stringstream ss; |
| ss << token; |
| std::string namebuf = ss.str(); |
| |
| int newMaterialId = -1; |
| if (material_map.find(namebuf) != material_map.end()) { |
| newMaterialId = material_map[namebuf]; |
| } else { |
| // { error!! material not found } |
| } |
| |
| if (newMaterialId != material) { |
| // Create per-face material. Thus we don't add `shape` to `shapes` at |
| // this time. |
| // just clear `faceGroup` after `exportFaceGroupToShape()` call. |
| exportFaceGroupToShape(&shape, faceGroup, tags, material, name, |
| triangulate); |
| faceGroup.clear(); |
| material = newMaterialId; |
| } |
| |
| continue; |
| } |
| |
| // load mtl |
| if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) { |
| if (readMatFn) { |
| token += 7; |
| |
| std::vector<std::string> filenames; |
| SplitString(std::string(token), ' ', filenames); |
| |
| if (filenames.empty()) { |
| if (err) { |
| (*err) += |
| "WARN: Looks like empty filename for mtllib. Use default " |
| "material. \n"; |
| } |
| } else { |
| bool found = false; |
| for (size_t s = 0; s < filenames.size(); s++) { |
| std::string err_mtl; |
| bool ok = (*readMatFn)(filenames[s].c_str(), materials, |
| &material_map, &err_mtl); |
| if (err && (!err_mtl.empty())) { |
| (*err) += err_mtl; // This should be warn message. |
| } |
| |
| if (ok) { |
| found = true; |
| break; |
| } |
| } |
| |
| if (!found) { |
| if (err) { |
| (*err) += |
| "WARN: Failed to load material file(s). Use default " |
| "material.\n"; |
| } |
| } |
| } |
| } |
| |
| continue; |
| } |
| |
| // group name |
| if (token[0] == 'g' && IS_SPACE((token[1]))) { |
| // flush previous face group. |
| bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name, |
| triangulate); |
| (void)ret; // return value not used. |
| |
| if (shape.mesh.indices.size() > 0) { |
| shapes->push_back(shape); |
| } |
| |
| shape = shape_t(); |
| |
| // material = -1; |
| faceGroup.clear(); |
| |
| std::vector<std::string> names; |
| names.reserve(2); |
| |
| while (!IS_NEW_LINE(token[0])) { |
| std::string str = parseString(&token); |
| names.push_back(str); |
| token += strspn(token, " \t\r"); // skip tag |
| } |
| |
| assert(names.size() > 0); |
| |
| // names[0] must be 'g', so skip the 0th element. |
| if (names.size() > 1) { |
| name = names[1]; |
| } else { |
| name = ""; |
| } |
| |
| continue; |
| } |
| |
| // object name |
| if (token[0] == 'o' && IS_SPACE((token[1]))) { |
| // flush previous face group. |
| bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name, |
| triangulate); |
| if (ret) { |
| shapes->push_back(shape); |
| } |
| |
| // material = -1; |
| faceGroup.clear(); |
| shape = shape_t(); |
| |
| // @todo { multiple object name? } |
| token += 2; |
| std::stringstream ss; |
| ss << token; |
| name = ss.str(); |
| |
| continue; |
| } |
| |
| if (token[0] == 't' && IS_SPACE(token[1])) { |
| tag_t tag; |
| |
| token += 2; |
| |
| tag.name = parseString(&token); |
| |
| tag_sizes ts = parseTagTriple(&token); |
| |
| tag.intValues.resize(static_cast<size_t>(ts.num_ints)); |
| |
| for (size_t i = 0; i < static_cast<size_t>(ts.num_ints); ++i) { |
| tag.intValues[i] = parseInt(&token); |
| } |
| |
| tag.floatValues.resize(static_cast<size_t>(ts.num_reals)); |
| for (size_t i = 0; i < static_cast<size_t>(ts.num_reals); ++i) { |
| tag.floatValues[i] = parseReal(&token); |
| } |
| |
| tag.stringValues.resize(static_cast<size_t>(ts.num_strings)); |
| for (size_t i = 0; i < static_cast<size_t>(ts.num_strings); ++i) { |
| tag.stringValues[i] = parseString(&token); |
| } |
| |
| tags.push_back(tag); |
| } |
| |
| // Ignore unknown command. |
| } |
| |
| bool ret = exportFaceGroupToShape(&shape, faceGroup, tags, material, name, |
| triangulate); |
| // exportFaceGroupToShape return false when `usemtl` is called in the last |
| // line. |
| // we also add `shape` to `shapes` when `shape.mesh` has already some |
| // faces(indices) |
| if (ret || shape.mesh.indices.size()) { |
| shapes->push_back(shape); |
| } |
| faceGroup.clear(); // for safety |
| |
| if (err) { |
| (*err) += errss.str(); |
| } |
| |
| attrib->vertices.swap(v); |
| attrib->normals.swap(vn); |
| attrib->texcoords.swap(vt); |
| attrib->colors.swap(vc); |
| |
| return true; |
| } |
| |
| bool LoadObjWithCallback(std::istream &inStream, const callback_t &callback, |
| void *user_data /*= NULL*/, |
| MaterialReader *readMatFn /*= NULL*/, |
| std::string *err /*= NULL*/) { |
| std::stringstream errss; |
| |
| // material |
| std::map<std::string, int> material_map; |
| int material_id = -1; // -1 = invalid |
| |
| std::vector<index_t> indices; |
| std::vector<material_t> materials; |
| std::vector<std::string> names; |
| names.reserve(2); |
| std::string name; |
| std::vector<const char *> names_out; |
| |
| std::string linebuf; |
| while (inStream.peek() != -1) { |
| safeGetline(inStream, linebuf); |
| |
| // Trim newline '\r\n' or '\n' |
| if (linebuf.size() > 0) { |
| if (linebuf[linebuf.size() - 1] == '\n') |
| linebuf.erase(linebuf.size() - 1); |
| } |
| if (linebuf.size() > 0) { |
| if (linebuf[linebuf.size() - 1] == '\r') |
| linebuf.erase(linebuf.size() - 1); |
| } |
| |
| // Skip if empty line. |
| if (linebuf.empty()) { |
| continue; |
| } |
| |
| // Skip leading space. |
| const char *token = linebuf.c_str(); |
| token += strspn(token, " \t"); |
| |
| assert(token); |
| if (token[0] == '\0') continue; // empty line |
| |
| if (token[0] == '#') continue; // comment line |
| |
| // vertex |
| if (token[0] == 'v' && IS_SPACE((token[1]))) { |
| token += 2; |
| // TODO(syoyo): Support parsing vertex color extension. |
| real_t x, y, z, w; // w is optional. default = 1.0 |
| parseV(&x, &y, &z, &w, &token); |
| if (callback.vertex_cb) { |
| callback.vertex_cb(user_data, x, y, z, w); |
| } |
| continue; |
| } |
| |
| // normal |
| if (token[0] == 'v' && token[1] == 'n' && IS_SPACE((token[2]))) { |
| token += 3; |
| real_t x, y, z; |
| parseReal3(&x, &y, &z, &token); |
| if (callback.normal_cb) { |
| callback.normal_cb(user_data, x, y, z); |
| } |
| continue; |
| } |
| |
| // texcoord |
| if (token[0] == 'v' && token[1] == 't' && IS_SPACE((token[2]))) { |
| token += 3; |
| real_t x, y, z; // y and z are optional. default = 0.0 |
| parseReal3(&x, &y, &z, &token); |
| if (callback.texcoord_cb) { |
| callback.texcoord_cb(user_data, x, y, z); |
| } |
| continue; |
| } |
| |
| // face |
| if (token[0] == 'f' && IS_SPACE((token[1]))) { |
| token += 2; |
| token += strspn(token, " \t"); |
| |
| indices.clear(); |
| while (!IS_NEW_LINE(token[0])) { |
| vertex_index vi = parseRawTriple(&token); |
| |
| index_t idx; |
| idx.vertex_index = vi.v_idx; |
| idx.normal_index = vi.vn_idx; |
| idx.texcoord_index = vi.vt_idx; |
| |
| indices.push_back(idx); |
| size_t n = strspn(token, " \t\r"); |
| token += n; |
| } |
| |
| if (callback.index_cb && indices.size() > 0) { |
| callback.index_cb(user_data, &indices.at(0), |
| static_cast<int>(indices.size())); |
| } |
| |
| continue; |
| } |
| |
| // use mtl |
| if ((0 == strncmp(token, "usemtl", 6)) && IS_SPACE((token[6]))) { |
| token += 7; |
| std::stringstream ss; |
| ss << token; |
| std::string namebuf = ss.str(); |
| |
| int newMaterialId = -1; |
| if (material_map.find(namebuf) != material_map.end()) { |
| newMaterialId = material_map[namebuf]; |
| } else { |
| // { error!! material not found } |
| } |
| |
| if (newMaterialId != material_id) { |
| material_id = newMaterialId; |
| } |
| |
| if (callback.usemtl_cb) { |
| callback.usemtl_cb(user_data, namebuf.c_str(), material_id); |
| } |
| |
| continue; |
| } |
| |
| // load mtl |
| if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) { |
| if (readMatFn) { |
| token += 7; |
| |
| std::vector<std::string> filenames; |
| SplitString(std::string(token), ' ', filenames); |
| |
| if (filenames.empty()) { |
| if (err) { |
| (*err) += |
| "WARN: Looks like empty filename for mtllib. Use default " |
| "material. \n"; |
| } |
| } else { |
| bool found = false; |
| for (size_t s = 0; s < filenames.size(); s++) { |
| std::string err_mtl; |
| bool ok = (*readMatFn)(filenames[s].c_str(), &materials, |
| &material_map, &err_mtl); |
| if (err && (!err_mtl.empty())) { |
| (*err) += err_mtl; // This should be warn message. |
| } |
| |
| if (ok) { |
| found = true; |
| break; |
| } |
| } |
| |
| if (!found) { |
| if (err) { |
| (*err) += |
| "WARN: Failed to load material file(s). Use default " |
| "material.\n"; |
| } |
| } else { |
| if (callback.mtllib_cb) { |
| callback.mtllib_cb(user_data, &materials.at(0), |
| static_cast<int>(materials.size())); |
| } |
| } |
| } |
| } |
| |
| continue; |
| } |
| |
| // group name |
| if (token[0] == 'g' && IS_SPACE((token[1]))) { |
| names.clear(); |
| |
| while (!IS_NEW_LINE(token[0])) { |
| std::string str = parseString(&token); |
| names.push_back(str); |
| token += strspn(token, " \t\r"); // skip tag |
| } |
| |
| assert(names.size() > 0); |
| |
| // names[0] must be 'g', so skip the 0th element. |
| if (names.size() > 1) { |
| name = names[1]; |
| } else { |
| name.clear(); |
| } |
| |
| if (callback.group_cb) { |
| if (names.size() > 1) { |
| // create const char* array. |
| names_out.resize(names.size() - 1); |
| for (size_t j = 0; j < names_out.size(); j++) { |
| names_out[j] = names[j + 1].c_str(); |
| } |
| callback.group_cb(user_data, &names_out.at(0), |
| static_cast<int>(names_out.size())); |
| |
| } else { |
| callback.group_cb(user_data, NULL, 0); |
| } |
| } |
| |
| continue; |
| } |
| |
| // object name |
| if (token[0] == 'o' && IS_SPACE((token[1]))) { |
| // @todo { multiple object name? } |
| token += 2; |
| |
| std::stringstream ss; |
| ss << token; |
| std::string object_name = ss.str(); |
| |
| if (callback.object_cb) { |
| callback.object_cb(user_data, object_name.c_str()); |
| } |
| |
| continue; |
| } |
| |
| #if 0 // @todo |
| if (token[0] == 't' && IS_SPACE(token[1])) { |
| tag_t tag; |
| |
| token += 2; |
| std::stringstream ss; |
| ss << token; |
| tag.name = ss.str(); |
| |
| token += tag.name.size() + 1; |
| |
| tag_sizes ts = parseTagTriple(&token); |
| |
| tag.intValues.resize(static_cast<size_t>(ts.num_ints)); |
| |
| for (size_t i = 0; i < static_cast<size_t>(ts.num_ints); ++i) { |
| tag.intValues[i] = atoi(token); |
| token += strcspn(token, "/ \t\r") + 1; |
| } |
| |
| tag.floatValues.resize(static_cast<size_t>(ts.num_reals)); |
| for (size_t i = 0; i < static_cast<size_t>(ts.num_reals); ++i) { |
| tag.floatValues[i] = parseReal(&token); |
| token += strcspn(token, "/ \t\r") + 1; |
| } |
| |
| tag.stringValues.resize(static_cast<size_t>(ts.num_strings)); |
| for (size_t i = 0; i < static_cast<size_t>(ts.num_strings); ++i) { |
| std::stringstream ss; |
| ss << token; |
| tag.stringValues[i] = ss.str(); |
| token += tag.stringValues[i].size() + 1; |
| } |
| |
| tags.push_back(tag); |
| } |
| #endif |
| |
| // Ignore unknown command. |
| } |
| |
| if (err) { |
| (*err) += errss.str(); |
| } |
| |
| return true; |
| } |
| } // namespace tinyobj |
| |
| #endif |