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 (No default value in the spec.

// We'll use -1)

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)

// extension

std::string colorspace; // Explicitly specify color space of stored texel

// value. Usually `sRGB` or `linear` (default empty).

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. For ambient or ambient occlusion.

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;

#ifdef TINY_OBJ_LOADER_PYTHON_BINDING

// For pybind11

std::array<double, 3> GetDiffuse() {

std::array<double, 3> values;

values[0] = double(diffuse[0]);

values[1] = double(diffuse[1]);

values[2] = double(diffuse[2]);

return values;

}

std::array<double, 3> GetSpecular() {

std::array<double, 3> values;

values[0] = double(specular[0]);

values[1] = double(specular[1]);

values[2] = double(specular[2]);

return values;

}

std::array<double, 3> GetTransmittance() {

std::array<double, 3> values;

values[0] = double(transmittance[0]);

values[1] = double(transmittance[1]);

values[2] = double(transmittance[2]);

return values;

}

std::array<double, 3> GetEmission() {

std::array<double, 3> values;

values[0] = double(emission[0]);

values[1] = double(emission[1]);

values[2] = double(emission[2]);

return values;

}

std::array<double, 3> GetAmbient() {

std::array<double, 3> values;

values[0] = double(ambient[0]);

values[1] = double(ambient[1]);

values[2] = double(ambient[2]);

return values;

}

void SetDiffuse(std::array<double, 3> &a) {

diffuse[0] = real_t(a[0]);

diffuse[1] = real_t(a[1]);

diffuse[2] = real_t(a[2]);

}

void SetAmbient(std::array<double, 3> &a) {

ambient[0] = real_t(a[0]);

ambient[1] = real_t(a[1]);

ambient[2] = real_t(a[2]);

}

void SetSpecular(std::array<double, 3> &a) {

specular[0] = real_t(a[0]);

specular[1] = real_t(a[1]);

specular[2] = real_t(a[2]);

}

void SetTransmittance(std::array<double, 3> &a) {

transmittance[0] = real_t(a[0]);

transmittance[1] = real_t(a[1]);

transmittance[2] = real_t(a[2]);

}

std::string GetCustomParameter(const std::string &key) {

std::map<std::string, std::string>::const_iterator it =

unknown_parameter.find(key);

if (it != unknown_parameter.end()) {

return it->second;

}

return std::string();

}

#endif

std::string name;

std::vector<int> intValues;

std::vector<real_t> floatValues;

std::vector<std::string> stringValues;

int vertex_id; // Corresponding vertex index in `attrib_t::vertices`.

// Compared to `index_t`, this index must be positive and

// start with 0(does not allow relative indexing)

std::vector<joint_and_weight_t> weightValues;

int vertex_index;

int normal_index;

int texcoord_index;

std::vector<index_t> indices;

std::vector<unsigned int>

num_face_vertices; // The number of vertices per

// face. 3 = triangle, 4 = quad, ...

std::vector<int> material_ids; // per-face material ID

std::vector<unsigned int> smoothing_group_ids; // per-face smoothing group

// ID(0 = off. positive value

// = group id)

std::vector<tag_t> tags; // SubD tag

// Linear flattened indices.

std::vector<index_t> indices; // indices for vertices(poly lines)

std::vector<int> num_line_vertices; // The number of vertices per line.

std::string name;

mesh_t mesh;

lines_t lines;

points_t points;

std::vector<real_t> vertices; // 'v'(xyz)

// For backward compatibility, we store vertex weight in separate array.

std::vector<real_t> vertex_weights; // 'v'(w)

std::vector<real_t> normals; // 'vn'

std::vector<real_t> texcoords; // 'vt'(uv)

// For backward compatibility, we store texture coordinate 'w' in separate

// array.

std::vector<real_t> texcoord_ws; // 'vt'(w)

std::vector<real_t> colors; // extension: vertex colors

//

// TinyObj extension.

//

// NOTE(syoyo): array index is based on the appearance order.

// To get a corresponding skin weight for a specific vertex id `vid`,

// Need to reconstruct a look up table: `skin_weight_t::vertex_id` == `vid`

// (e.g. using std::map, std::unordered_map)

std::vector<skin_weight_t> skin_weights;

attrib_t() {}

//

// For pybind11

//

const std::vector<real_t> &GetVertices() const { return vertices; }

const std::vector<real_t> &GetVertexWeights() const { return vertex_weights; }

// 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 (*vertex_color_cb)(void *user_data, real_t x, real_t y, real_t z,

real_t r, real_t g, real_t b, bool has_color);

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),

vertex_color_cb(NULL),

normal_cb(NULL),

texcoord_cb(NULL),

index_cb(NULL),

usemtl_cb(NULL),

mtllib_cb(NULL),

group_cb(NULL),

object_cb(NULL) {}

public:

MaterialReader() {}

virtual ~MaterialReader();

virtual bool operator()(const std::string &matId,

std::vector<material_t> *materials,

std::map<std::string, int> *matMap, std::string *warn,

std::string *err) = 0;

public:

// Path could contain separator(';' in Windows, ':' in Posix)

explicit MaterialFileReader(const std::string &mtl_basedir)

: m_mtlBaseDir(mtl_basedir) {}

virtual ~MaterialFileReader() TINYOBJ_OVERRIDE {}

virtual bool operator()(const std::string &matId,

std::vector<material_t> *materials,

std::map<std::string, int> *matMap, std::string *warn,

std::string *err) TINYOBJ_OVERRIDE;

private:

std::string m_mtlBaseDir;

public:

explicit MaterialStreamReader(std::istream &inStream)

: m_inStream(inStream) {}

virtual ~MaterialStreamReader() TINYOBJ_OVERRIDE {}

virtual bool operator()(const std::string &matId,

std::vector<material_t> *materials,

std::map<std::string, int> *matMap, std::string *warn,

std::string *err) TINYOBJ_OVERRIDE;

private:

std::istream &m_inStream;

bool triangulate; // triangulate polygon?

// Currently not used.

// "simple" or empty: Create triangle fan

// "earcut": Use the algorithm based on Ear clipping

std::string triangulation_method;

/// Parse vertex color.

/// If vertex color is not present, its filled with default value.

/// false = no vertex color

/// This will increase memory of parsed .obj

bool vertex_color;

///

/// Search path to .mtl file.

/// Default = "" = search from the same directory of .obj file.

/// Valid only when loading .obj from a file.

///

std::string mtl_search_path;

ObjReaderConfig()

: triangulate(true), triangulation_method("simple"), vertex_color(true) {}

public:

ObjReader() : valid_(false) {}

///

/// Load .obj and .mtl from a file.

///

/// @param[in] filename wavefront .obj filename

/// @param[in] config Reader configuration

///

bool ParseFromFile(const std::string &filename,

const ObjReaderConfig &config = ObjReaderConfig());

///

/// Parse .obj from a text string.

/// Need to supply .mtl text string by `mtl_text`.

/// This function ignores `mtllib` line in .obj text.

///

/// @param[in] obj_text wavefront .obj filename

/// @param[in] mtl_text wavefront .mtl filename

/// @param[in] config Reader configuration

///

bool ParseFromString(const std::string &obj_text, const std::string &mtl_text,

const ObjReaderConfig &config = ObjReaderConfig());

///

/// .obj was loaded or parsed correctly.

///

bool Valid() const { return valid_; }

const attrib_t &GetAttrib() const { return attrib_; }

const std::vector<shape_t> &GetShapes() const { return shapes_; }

const std::vector<material_t> &GetMaterials() const { return materials_; }

///

/// Warning message(may be filled after `Load` or `Parse`)

///

const std::string &Warning() const { return warning_; }

///

/// Error message(filled when `Load` or `Parse` failed)

///

const std::string &Error() const { return error_; }

private:

bool valid_;

attrib_t attrib_;

std::vector<shape_t> shapes_;

std::vector<material_t> materials_;

std::string warning_;

std::string error_;

int v_idx, vt_idx, vn_idx;

vertex_index_t() : v_idx(-1), vt_idx(-1), vn_idx(-1) {}

explicit vertex_index_t(int idx) : v_idx(idx), vt_idx(idx), vn_idx(idx) {}

vertex_index_t(int vidx, int vtidx, int vnidx)

: v_idx(vidx), vt_idx(vtidx), vn_idx(vnidx) {}

unsigned int

smoothing_group_id; // smoothing group id. 0 = smoothing groupd is off.

int pad_;

std::vector<vertex_index_t> vertex_indices; // face vertex indices.

face_t() : smoothing_group_id(0), pad_(0) {}

// l v1/vt1 v2/vt2 ...

// In the specification, line primitrive does not have normal index, but

// TinyObjLoader allow it

std::vector<vertex_index_t> vertex_indices;

// p v1 v2 ...

// In the specification, point primitrive does not have normal index and

// texture coord index, but TinyObjLoader allow it.

std::vector<vertex_index_t> vertex_indices;

tag_sizes() : num_ints(0), num_reals(0), num_strings(0) {}

int num_ints;

int num_reals;

int num_strings;

std::vector<real_t> v;

std::vector<real_t> vn;

std::vector<real_t> vt;

std::vector<face_t> faceGroup;

std::vector<__line_t> lineGroup;

std::vector<__points_t> pointsGroup;

void clear() {

faceGroup.clear();

lineGroup.clear();

pointsGroup.clear();

}

bool IsEmpty() const {

return faceGroup.empty() && lineGroup.empty() && pointsGroup.empty();

}

// TODO(syoyo): bspline, surface, ...

std::stringstream ss;

ss << t;

return ss.str();

// UTF-8 BOM = 0xEF,0xBB,0xBF

if (input.size() >= 3 &&

static_cast<unsigned char>(input[0]) == 0xEF &&

static_cast<unsigned char>(input[1]) == 0xBB &&

static_cast<unsigned char>(input[2]) == 0xBF) {

return input.substr(3); // Skip BOM

}

return input;

const warning_context &context) {

if (!ret) {

return false;

}

if (idx > 0) {

(*ret) = idx - 1;

return true;

}

if (idx == 0) {

// zero is not allowed according to the spec.

if (context.warn) {

(*context.warn) +=

"A zero value index found (will have a value of -1 for normal and "

"tex indices. Line " +

toString(context.line_number) + ").\n";

}

(*ret) = idx - 1;

return allow_zero;

}

if (idx < 0) {

(*ret) = n + idx; // negative value = relative

if ((*ret) < 0) {

return false; // invalid relative index

}

return true;

}

return false; // never reach here.

std::string s;

(*token) += strspn((*token), " \t");

size_t e = strcspn((*token), " \t\r");

s = std::string((*token), &(*token)[e]);

(*token) += e;

return s;

(*token) += strspn((*token), " \t");

int i = atoi((*token));

(*token) += strcspn((*token), " \t\r");

return i;

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;

bool leading_decimal_dots = false;

/*

// Find out what sign we've got.

if (*curr == '+' || *curr == '-') {

sign = *curr;

curr++;

if ((curr != s_end) && (*curr == '.')) {

// accept. Somethig like `.7e+2`, `-.5234`

leading_decimal_dots = true;

}

} else if (IS_DIGIT(*curr)) { /* Pass through. */

} else if (*curr == '.') {

// accept. Somethig like `.7e+2`, `-.5234`

leading_decimal_dots = true;

} else {

goto fail;

}

// Read the integer part.

end_not_reached = (curr != s_end);

if (!leading_decimal_dots) {

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++;