// 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) {}

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;

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;

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;

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) {}

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;

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.

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;

/*

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

(*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;

(*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;

const double default_x = 0.0,

const double default_y = 0.0) {

(*x) = parseReal(token, default_x);

(*y) = parseReal(token, default_y);

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

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

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;

(*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;

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;

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;

vertex_index_t *ret) {

if (!ret) {

return false;

}

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

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

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 = static_cast<real_t>(1.0);

texopt->clamp = false;

texopt->blendu = true;

texopt->blendv = true;

texopt->sharpness = static_cast<real_t>(1.0);

texopt->brightness = static_cast<real_t>(0.0);

texopt->contrast = static_cast<real_t>(1.0);

texopt->origin_offset[0] = static_cast<real_t>(0.0);

texopt->origin_offset[1] = static_cast<real_t>(0.0);

texopt->origin_offset[2] = static_cast<real_t>(0.0);

texopt->scale[0] = static_cast<real_t>(1.0);

texopt->scale[1] = static_cast<real_t>(1.0);

texopt->scale[2] = static_cast<real_t>(1.0);

texopt->turbulence[0] = static_cast<real_t>(0.0);

texopt->turbulence[1] = static_cast<real_t>(0.0);

texopt->turbulence[2] = static_cast<real_t>(0.0);

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;

}

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] = static_cast<real_t>(0.0);

material->diffuse[i] = static_cast<real_t>(0.0);

material->specular[i] = static_cast<real_t>(0.0);

material->transmittance[i] = static_cast<real_t>(0.0);

material->emission[i] = static_cast<real_t>(0.0);

}

material->illum = 0;

material->dissolve = static_cast<real_t>(1.0);

material->shininess = static_cast<real_t>(1.0);

material->ior = static_cast<real_t>(1.0);

material->roughness = static_cast<real_t>(0.0);

material->metallic = static_cast<real_t>(0.0);

material->sheen = static_cast<real_t>(0.0);

material->clearcoat_thickness = static_cast<real_t>(0.0);

material->clearcoat_roughness = static_cast<real_t>(0.0);

material->anisotropy_rotation = static_cast<real_t>(0.0);

material->anisotropy = static_cast<real_t>(0.0);

material->roughness_texname = "";

material->metallic_texname = "";

material->sheen_texname = "";

material->emissive_texname = "";

material->normal_texname = "";

material->unknown_parameter.clear();