From 50f4501c86dd7f737bbd26f9facb7acb211bab82 Mon Sep 17 00:00:00 2001 From: Daniel Ledda Date: Sat, 4 Jan 2025 19:19:01 +0100 Subject: [PATCH] update --- src/VoxelSpace.cpp | 3 - src/gfx/Color.cpp | 22 +- src/gfx/Mesh.cpp | 68 +- src/gfx/Mesh.h | 5 +- src/gfx/Shader.cpp | 24 +- src/gfx/Shader.h | 3 +- src/gfx/Texture.cpp | 13 +- src/gfx/Texture.h | 3 +- src/gfx/geometry.h | 1 + src/lib/loaders/tinyobj.h | 4538 +++++++++++++++++++++++++------------ src/main.cpp | 17 +- 11 files changed, 3213 insertions(+), 1484 deletions(-) diff --git a/src/VoxelSpace.cpp b/src/VoxelSpace.cpp index 30a27a8..d479259 100644 --- a/src/VoxelSpace.cpp +++ b/src/VoxelSpace.cpp @@ -1,7 +1,4 @@ #include -#include -#include -#include #include #include "VoxelSpace.h" diff --git a/src/gfx/Color.cpp b/src/gfx/Color.cpp index 73e32ac..cf0cbdd 100644 --- a/src/gfx/Color.cpp +++ b/src/gfx/Color.cpp @@ -2,7 +2,7 @@ #include #include "../lib/djstdlib/core.h" -real32 hue_to_rgb(float p, float q, float t) { +real32 hue_to_rgb(real32 p, real32 q, real32 t) { if (t < 0) { t += 1; } else if (t > 1) { @@ -18,12 +18,12 @@ glm::vec3 hsl_to_hex(real32 h, real32 s, real32 l) { h /= 360; s /= 100; l /= 100; - float r, g, b; + real32 r, g, b; if (s == 0) { r = g = b = l; } else { - auto q = l < 0.5f ? l * (1 + s) : l + s - l * s; - auto p = 2 * l - q; + real32 q = l < 0.5f ? l * (1 + s) : l + s - l * s; + real32 p = 2 * l - q; r = hue_to_rgb(p, q, h + 1.0f / 3); g = hue_to_rgb(p, q, h); b = hue_to_rgb(p, q, h - 1.0f / 3); @@ -32,12 +32,12 @@ glm::vec3 hsl_to_hex(real32 h, real32 s, real32 l) { } glm::vec3 color_from_index(int index) { - auto color_wheel_cycle = floorf(index / 6.0f); - auto darkness_cycle = floorf(index / 12.0f); - auto spacing = (360.0f / 6.0f); - auto offset = color_wheel_cycle == 0 ? 0 : spacing / (color_wheel_cycle + 2); - auto hue = spacing * (index % 6) + offset; - auto saturation = 100.0f; - auto lightness = 1.0f / (2 + darkness_cycle) * 100; + real32 color_wheel_cycle = floorf(index / 6.0f); + real32 darkness_cycle = floorf(index / 12.0f); + real32 spacing = (360.0f / 6.0f); + real32 offset = color_wheel_cycle == 0 ? 0 : spacing / (color_wheel_cycle + 2); + real32 hue = spacing * (index % 6) + offset; + real32 saturation = 100.0f; + real32 lightness = 1.0f / (2 + darkness_cycle) * 100; return hsl_to_hex(hue, saturation, lightness); } diff --git a/src/gfx/Mesh.cpp b/src/gfx/Mesh.cpp index c9f6ab4..ecb4e4e 100644 --- a/src/gfx/Mesh.cpp +++ b/src/gfx/Mesh.cpp @@ -1,23 +1,28 @@ #include +#include #include "Mesh.h" +#define TINYOBJLOADER_IMPLEMENTATION #include "../lib/loaders/tinyobj.h" +#include "../lib/djstdlib/core.h" -auto Mesh::init(const char* obj_file) -> void { - auto reader = tinyobj::ObjReader(); - auto success = reader.ParseFromFile(obj_file); +Mesh createMesh(const char* obj_file) { + Mesh result = {0}; + + tinyobj::ObjReader reader = tinyobj::ObjReader(); + bool success = reader.ParseFromFile(obj_file); std::cout << reader.Error() << std::endl; - auto attrib = reader.GetAttrib(); + const tinyobj::attrib_t attrib = reader.GetAttrib(); - auto indices_t = reader.GetShapes().at(0).mesh.indices; - auto indices = std::vector(indices_t.size()); + std::vector indices_t = reader.GetShapes().at(0).mesh.indices; + std::vector indices = std::vector(indices_t.size()); - auto vertices = std::vector(3*indices_t.size()); - auto normals = std::vector(3*indices_t.size()); - auto texcoords = std::vector(2*indices_t.size()); + std::vector vertices = std::vector(3*indices_t.size()); + std::vector normals = std::vector(3*indices_t.size()); + std::vector texcoords = std::vector(2*indices_t.size()); for (int i = 0; i < indices_t.size(); i++) { - auto vertex_data = indices_t[i]; + tinyobj::index_t vertex_data = indices_t[i]; vertices[3*i] = attrib.vertices[3*vertex_data.vertex_index]; vertices[3*i+1] = attrib.vertices[3*vertex_data.vertex_index + 1]; vertices[3*i+2] = attrib.vertices[3*vertex_data.vertex_index + 2]; @@ -32,54 +37,59 @@ auto Mesh::init(const char* obj_file) -> void { indices[i] = i; } - num_indices = indices_t.size(); - glGenVertexArrays(1, &vao); - glGenBuffers(1, &vbo_xyz); - glGenBuffers(1, &vbo_uv); - glGenBuffers(1, &vbo_norm); + result.num_indices = indices_t.size(); + glGenVertexArrays(1, &result.vao); + glGenBuffers(1, &result.vbo_xyz); + glGenBuffers(1, &result.vbo_uv); + glGenBuffers(1, &result.vbo_norm); //glGenBuffers(1, &ebo); - glBindVertexArray(vao); + glBindVertexArray(result.vao); - glBindBuffer(GL_ARRAY_BUFFER, vbo_xyz); + glBindBuffer(GL_ARRAY_BUFFER, result.vbo_xyz); glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(float), vertices.data(), GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); glEnableVertexAttribArray(0); - glBindBuffer(GL_ARRAY_BUFFER, vbo_uv); + glBindBuffer(GL_ARRAY_BUFFER, result.vbo_uv); glBufferData(GL_ARRAY_BUFFER, texcoords.size() * sizeof(float), texcoords.data(), GL_STATIC_DRAW); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0); glEnableVertexAttribArray(1); - glBindBuffer(GL_ARRAY_BUFFER, vbo_norm); + glBindBuffer(GL_ARRAY_BUFFER, result.vbo_norm); glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(float), normals.data(), GL_STATIC_DRAW); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); glEnableVertexAttribArray(2); //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); //glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW); + return result; } -auto Mesh::init(const LeddaGeometry::Shape* shape) -> void { - num_indices = shape->indices_size; - glGenVertexArrays(1, &vao); - glGenBuffers(1, &vbo_xyz); - glGenBuffers(1, &vbo_uv); - glGenBuffers(1, &ebo); +Mesh createMesh(const Shape* shape) { + Mesh result = {0}; - glBindVertexArray(vao); + result.num_indices = shape->indices_size; + glGenVertexArrays(1, &result.vao); + glGenBuffers(1, &result.vbo_xyz); + glGenBuffers(1, &result.vbo_uv); + glGenBuffers(1, &result.ebo); - glBindBuffer(GL_ARRAY_BUFFER, vbo_xyz); + glBindVertexArray(result.vao); + + glBindBuffer(GL_ARRAY_BUFFER, result.vbo_xyz); glBufferData(GL_ARRAY_BUFFER, shape->xyz_size * sizeof(float), shape->xyz, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); glEnableVertexAttribArray(0); - glBindBuffer(GL_ARRAY_BUFFER, vbo_uv); + glBindBuffer(GL_ARRAY_BUFFER, result.vbo_uv); glBufferData(GL_ARRAY_BUFFER, shape->uv_size * sizeof(float), shape->uv, GL_STATIC_DRAW); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0); glEnableVertexAttribArray(1); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, result.ebo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, shape->indices_size * sizeof(unsigned int), shape->indices, GL_STATIC_DRAW); + + return result; } diff --git a/src/gfx/Mesh.h b/src/gfx/Mesh.h index c8a0c7b..ffc83ad 100644 --- a/src/gfx/Mesh.h +++ b/src/gfx/Mesh.h @@ -11,8 +11,9 @@ struct Mesh { unsigned int vbo_norm; unsigned int ebo; unsigned int num_indices; - void init(const char* obj_file); - void init(const Shape* shape); }; +Mesh createMesh(const char* obj_file); +Mesh createMesh(const Shape* shape); + #endif diff --git a/src/gfx/Shader.cpp b/src/gfx/Shader.cpp index 19c128b..8f374ff 100644 --- a/src/gfx/Shader.cpp +++ b/src/gfx/Shader.cpp @@ -10,7 +10,7 @@ enum ShaderType { vertex=GL_VERTEX_SHADER, }; -uint32 create_shader(const char* file_path, ShaderType shader_type, char* info_log) { +uint32 createGlShader(const char* file_path, ShaderType shader_type, char* info_log) { std::stringstream shader_stream; std::ifstream shader_file; shader_file.open(file_path); @@ -33,20 +33,22 @@ uint32 create_shader(const char* file_path, ShaderType shader_type, char* info_l return vertex_shader; } -void Shader::init(const char* vertex_path, const char* fragment_path) { - char info_log[512] = {0}; - uint32 vertex_shader = create_shader(vertex_path, ShaderType::vertex, info_log); - uint32 fragment_shader = create_shader(fragment_path, ShaderType::fragment, info_log); +Shader createShader(const char* vertex_path, const char* fragment_path) { + Shader result = {0}; - prog_id = glCreateProgram(); - glAttachShader(prog_id, vertex_shader); - glAttachShader(prog_id, fragment_shader); - glLinkProgram(prog_id); + char info_log[512] = {0}; + uint32 vertex_shader = createGlShader(vertex_path, ShaderType::vertex, info_log); + uint32 fragment_shader = createGlShader(fragment_path, ShaderType::fragment, info_log); + + result.prog_id = glCreateProgram(); + glAttachShader(result.prog_id, vertex_shader); + glAttachShader(result.prog_id, fragment_shader); + glLinkProgram(result.prog_id); int success; - glGetProgramiv(prog_id, GL_LINK_STATUS, &success); + glGetProgramiv(result.prog_id, GL_LINK_STATUS, &success); if (!success) { - glGetProgramInfoLog(prog_id, 512, NULL, info_log); + glGetProgramInfoLog(result.prog_id, 512, NULL, info_log); std::cout << "ERROR::SHADER::PROGRAM::LINK_FAILED\n" << info_log << std::endl; } diff --git a/src/gfx/Shader.h b/src/gfx/Shader.h index 2245035..55b6e0c 100644 --- a/src/gfx/Shader.h +++ b/src/gfx/Shader.h @@ -3,7 +3,8 @@ struct Shader { unsigned int prog_id; - void init(const char* vertex_path, const char* fragment_path); }; +Shader createShader(const char* vertex_path, const char* fragment_path); + #endif diff --git a/src/gfx/Texture.cpp b/src/gfx/Texture.cpp index 35412b5..daa2fbc 100644 --- a/src/gfx/Texture.cpp +++ b/src/gfx/Texture.cpp @@ -3,21 +3,24 @@ #include "../lib/loaders/stb_image.h" #include "../lib/glad/glad.h" -void Texture::init(const char* source_path) { - glGenTextures(1, &tex_id); - glBindTexture(GL_TEXTURE_2D, tex_id); +Texture createTexture(const char* source_path) { + Texture result = {0}; + glGenTextures(1, &result.tex_id); + glBindTexture(GL_TEXTURE_2D, result.tex_id); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); int nr_channels; - stbi_uc *data = stbi_load(source_path, &width, &height, &nr_channels, 0); + stbi_uc *data = stbi_load(source_path, &result.width, &result.height, &nr_channels, 0); if (data) { - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, result.width, result.height, 0, GL_RGB, GL_UNSIGNED_BYTE, data); glGenerateMipmap(GL_TEXTURE_2D); } else { std::cout << "Failed to load texture." << std::endl; } stbi_image_free(data); + + return result; } diff --git a/src/gfx/Texture.h b/src/gfx/Texture.h index 2c915c4..df1ce6c 100644 --- a/src/gfx/Texture.h +++ b/src/gfx/Texture.h @@ -5,7 +5,8 @@ struct Texture { unsigned int tex_id; int width; int height; - void init(const char* source_path); }; +Texture createTexture(const char* source_path); + #endif diff --git a/src/gfx/geometry.h b/src/gfx/geometry.h index 0eb5b2d..d18d069 100644 --- a/src/gfx/geometry.h +++ b/src/gfx/geometry.h @@ -11,6 +11,7 @@ struct Shape { float* xyz; size_t xyz_size; }; + extern const Shape TRIANGLE; extern const Shape SQUARE; extern const Shape CUBE; diff --git a/src/lib/loaders/tinyobj.h b/src/lib/loaders/tinyobj.h index cbfa301..3d86b90 100644 --- a/src/lib/loaders/tinyobj.h +++ b/src/lib/loaders/tinyobj.h @@ -1,417 +1,968 @@ /* - The MIT License (MIT) +The MIT License (MIT) - Copyright (c) 2016 - 2019 Syoyo Fujita and many contributors. +Copyright (c) 2012-Present, 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: +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 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. - */ -#ifndef TINOBJ_LOADER_C_H_ -#define TINOBJ_LOADER_C_H_ +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. +*/ -/* @todo { Remove stddef dependency. size_t? } */ -#include +// +// version 2.0.0 : Add new object oriented API. 1.x API is still provided. +// * Support line primitive. +// * Support points primitive. +// * Support multiple search path for .mtl(v1 API). +// * Support vertex weight `vw`(as an tinyobj extension) +// * Support escaped whitespece in mtllib +// * Add robust triangulation using Mapbox earcut(TINYOBJLOADER_USE_MAPBOX_EARCUT). +// version 1.4.0 : Modifed ParseTextureNameAndOption API +// version 1.3.1 : Make ParseTextureNameAndOption API public +// version 1.3.0 : Separate warning and error message(breaking API of LoadObj) +// version 1.2.3 : Added color space extension('-colorspace') to tex opts. +// version 1.2.2 : Parse multiple group names. +// version 1.2.1 : Added initial support for line('l') primitive(PR #178) +// version 1.2.0 : Hardened implementation(#175) +// version 1.1.1 : Support smoothing groups(#162) +// 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. +// -#ifdef __cplusplus -extern "C" { +// +// Use this in *one* .cc +// #define TINYOBJLOADER_IMPLEMENTATION +// #include "tiny_obj_loader.h" +// + +#ifndef TINY_OBJ_LOADER_H_ +#define TINY_OBJ_LOADER_H_ + +#include +#include +#include + +namespace tinyobj { + +// TODO(syoyo): Better C++11 detection for older compiler +#if __cplusplus > 199711L +#define TINYOBJ_OVERRIDE override +#else +#define TINYOBJ_OVERRIDE #endif -typedef struct { - char *name; +#ifdef __clang__ +#pragma clang diagnostic push +#if __has_warning("-Wzero-as-null-pointer-constant") +#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif - float ambient[3]; - float diffuse[3]; - float specular[3]; - float transmittance[3]; - float emission[3]; - float shininess; - float ior; /* index of refraction */ - float dissolve; /* 1 == opaque; 0 == fully transparent */ - /* illumination model (see http://www.fileformat.info/format/material/) */ +#pragma clang diagnostic ignored "-Wpadded" + +#endif + +// 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 +// +// TinyObjLoader extension. +// +// -colorspace SPACE # Color space of the texture. e.g. +// 'sRGB` or 'linear' +// + +#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; + +struct texture_option_t { + 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). +}; + +struct material_t { + 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 pad0; + int dummy; // Suppress padding warning. - char *ambient_texname; /* map_Ka */ - char *diffuse_texname; /* map_Kd */ - char *specular_texname; /* map_Ks */ - char *specular_highlight_texname; /* map_Ns */ - char *bump_texname; /* map_bump, bump */ - char *displacement_texname; /* disp */ - char *alpha_texname; /* map_d */ -} tinyobj_material_t; + 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 -typedef struct { - char *name; /* group name or object name. */ - unsigned int face_offset; - unsigned int length; -} tinyobj_shape_t; + 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; -typedef struct { int v_idx, vt_idx, vn_idx; } tinyobj_vertex_index_t; + // 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. -typedef struct { - unsigned int num_vertices; - unsigned int num_normals; - unsigned int num_texcoords; - unsigned int num_faces; - unsigned int num_face_num_verts; + 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 pad0; + int pad2; - float *vertices; - float *normals; - float *texcoords; - tinyobj_vertex_index_t *faces; - int *face_num_verts; - int *material_ids; -} tinyobj_attrib_t; + std::map unknown_parameter; +#ifdef TINY_OBJ_LOADER_PYTHON_BINDING + // For pybind11 + std::array GetDiffuse() { + std::array values; + values[0] = double(diffuse[0]); + values[1] = double(diffuse[1]); + values[2] = double(diffuse[2]); -#define TINYOBJ_FLAG_TRIANGULATE (1 << 0) + return values; + } -#define TINYOBJ_INVALID_INDEX (0x80000000) + std::array GetSpecular() { + std::array values; + values[0] = double(specular[0]); + values[1] = double(specular[1]); + values[2] = double(specular[2]); -#define TINYOBJ_SUCCESS (0) -#define TINYOBJ_ERROR_EMPTY (-1) -#define TINYOBJ_ERROR_INVALID_PARAMETER (-2) -#define TINYOBJ_ERROR_FILE_OPERATION (-3) + return values; + } -/* Provide a callback that can read text file without any parsing or modification. - * The obj and mtl parser is going to read all the necessary data: - * tinyobj_parse_obj - * tinyobj_parse_mtl_file - * - * @param[in] ctx User provided context. - * @param[in] filename Filename to be loaded. - * @param[in] is_mtl 1 when the callback is invoked for loading .mtl. 0 for .obj - * @param[in] obj_filename .obj filename. Useful when you load .mtl from same location of .obj. When the callback is called to load .obj, `filename` and `obj_filename` are same. - * @param[out] buf Content of loaded file - * @param[out] len Size of content(file) - */ -typedef void (*file_reader_callback)(void *ctx, const char *filename, int is_mtl, const char *obj_filename, char **buf, size_t *len); + std::array GetTransmittance() { + std::array values; + values[0] = double(transmittance[0]); + values[1] = double(transmittance[1]); + values[2] = double(transmittance[2]); -/* Parse wavefront .obj - * @param[out] attrib Attibutes - * @param[out] shapes Array of parsed shapes - * @param[out] num_shapes Array length of `shapes` - * @param[out] materials Array of parsed materials - * @param[out] num_materials Array length of `materials` - * @param[in] file_name File name of .obj - * @param[in] file_reader File reader callback function(to read .obj and .mtl). - * @param[in] ctx Context pointer passed to the file_reader_callback. - * @param[in] flags combination of TINYOBJ_FLAG_*** - * - * Returns TINYOBJ_SUCCESS if things goes well. - * Returns TINYOBJ_ERR_*** when there is an error. - */ -extern int tinyobj_parse_obj(tinyobj_attrib_t *attrib, tinyobj_shape_t **shapes, - size_t *num_shapes, tinyobj_material_t **materials, - size_t *num_materials, const char *file_name, file_reader_callback file_reader, - void *ctx, unsigned int flags); + return values; + } -/* Parse wavefront .mtl - * - * @param[out] materials_out - * @param[out] num_materials_out - * @param[in] filename .mtl filename - * @param[in] filename of .obj filename. could be NULL if you just want to parse .mtl file. - * @param[in] file_reader File reader callback - * @param[in[ ctx Context pointer passed to the file_reader callack. + std::array GetEmission() { + std::array values; + values[0] = double(emission[0]); + values[1] = double(emission[1]); + values[2] = double(emission[2]); - * Returns TINYOBJ_SUCCESS if things goes well. - * Returns TINYOBJ_ERR_*** when there is an error. - */ -extern int tinyobj_parse_mtl_file(tinyobj_material_t **materials_out, - size_t *num_materials_out, - const char *filename, const char *obj_filename, file_reader_callback file_reader, - void *ctx); + return values; + } -extern void tinyobj_attrib_init(tinyobj_attrib_t *attrib); -extern void tinyobj_attrib_free(tinyobj_attrib_t *attrib); -extern void tinyobj_shapes_free(tinyobj_shape_t *shapes, size_t num_shapes); -extern void tinyobj_materials_free(tinyobj_material_t *materials, - size_t num_materials); + std::array GetAmbient() { + std::array values; + values[0] = double(ambient[0]); + values[1] = double(ambient[1]); + values[2] = double(ambient[2]); + + return values; + } + + void SetDiffuse(std::array &a) { + diffuse[0] = real_t(a[0]); + diffuse[1] = real_t(a[1]); + diffuse[2] = real_t(a[2]); + } + + void SetAmbient(std::array &a) { + ambient[0] = real_t(a[0]); + ambient[1] = real_t(a[1]); + ambient[2] = real_t(a[2]); + } + + void SetSpecular(std::array &a) { + specular[0] = real_t(a[0]); + specular[1] = real_t(a[1]); + specular[2] = real_t(a[2]); + } + + void SetTransmittance(std::array &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::const_iterator it = + unknown_parameter.find(key); + + if (it != unknown_parameter.end()) { + return it->second; + } + return std::string(); + } -#ifdef __cplusplus -} #endif +}; -#ifdef TINYOBJ_LOADER_C_IMPLEMENTATION -#include -#include -#include -#include +struct tag_t { + std::string name; -#if defined(TINYOBJ_MALLOC) && defined(TINYOBJ_CALLOC) && defined(TINYOBJ_FREE) && (defined(TINYOBJ_REALLOC) || defined(TINYOBJ_REALLOC_SIZED)) -/* ok */ -#elif !defined(TINYOBJ_MALLOC) && !defined(TINYOBJ_CALLOC) && !defined(TINYOBJ_FREE) && !defined(TINYOBJ_REALLOC) && !defined(TINYOBJ_REALLOC_SIZED) -/* ok */ + std::vector intValues; + std::vector floatValues; + std::vector stringValues; +}; + +struct joint_and_weight_t { + int joint_id; + real_t weight; +}; + +struct skin_weight_t { + 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 weightValues; +}; + +// Index struct to support different indices for vtx/normal/texcoord. +// -1 means not used. +struct index_t { + int vertex_index; + int normal_index; + int texcoord_index; +}; + +struct mesh_t { + std::vector indices; + std::vector + num_face_vertices; // The number of vertices per + // face. 3 = triangle, 4 = quad, + // ... Up to 255 vertices per face. + std::vector material_ids; // per-face material ID + std::vector smoothing_group_ids; // per-face smoothing group + // ID(0 = off. positive value + // = group id) + std::vector tags; // SubD tag +}; + +// struct path_t { +// std::vector indices; // pairs of indices for lines +//}; + +struct lines_t { + // Linear flattened indices. + std::vector indices; // indices for vertices(poly lines) + std::vector num_line_vertices; // The number of vertices per line. +}; + +struct points_t { + std::vector indices; // indices for points +}; + +struct shape_t { + std::string name; + mesh_t mesh; + lines_t lines; + points_t points; +}; + +// Vertex attributes +struct attrib_t { + std::vector vertices; // 'v'(xyz) + + // For backward compatibility, we store vertex weight in separate array. + std::vector vertex_weights; // 'v'(w) + std::vector normals; // 'vn' + std::vector texcoords; // 'vt'(uv) + + // For backward compatibility, we store texture coordinate 'w' in separate + // array. + std::vector texcoord_ws; // 'vt'(w) + std::vector 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_weights; + + attrib_t() {} + + // + // For pybind11 + // + const std::vector &GetVertices() const { return vertices; } + + const std::vector &GetVertexWeights() const { return vertex_weights; } +}; + +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 (*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), + normal_cb(NULL), + texcoord_cb(NULL), + index_cb(NULL), + usemtl_cb(NULL), + mtllib_cb(NULL), + group_cb(NULL), + object_cb(NULL) {} +}; + +class MaterialReader { + public: + MaterialReader() {} + virtual ~MaterialReader(); + + virtual bool operator()(const std::string &matId, + std::vector *materials, + std::map *matMap, std::string *warn, + std::string *err) = 0; +}; + +/// +/// Read .mtl from a file. +/// +class MaterialFileReader : public MaterialReader { + 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 *materials, + std::map *matMap, std::string *warn, + std::string *err) TINYOBJ_OVERRIDE; + + private: + std::string m_mtlBaseDir; +}; + +/// +/// Read .mtl from a stream. +/// +class MaterialStreamReader : public MaterialReader { + public: + explicit MaterialStreamReader(std::istream &inStream) + : m_inStream(inStream) {} + virtual ~MaterialStreamReader() TINYOBJ_OVERRIDE {} + virtual bool operator()(const std::string &matId, + std::vector *materials, + std::map *matMap, std::string *warn, + std::string *err) TINYOBJ_OVERRIDE; + + private: + std::istream &m_inStream; +}; + +// v2 API +struct ObjReaderConfig { + 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) {} +}; + +/// +/// Wavefront .obj reader class(v2 API) +/// +class ObjReader { + 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 &GetShapes() const { return shapes_; } + + const std::vector &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 shapes_; + std::vector materials_; + + std::string warning_; + std::string error_; +}; + +/// ==>>========= Legacy v1 API ============================================= + +/// 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 message into `warn`, 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. +/// Option 'default_vcols_fallback' specifies whether vertex colors should +/// always be defined, even if no colors are given (fallback to white). +bool LoadObj(attrib_t *attrib, std::vector *shapes, + std::vector *materials, std::string *warn, + std::string *err, const char *filename, + const char *mtl_basedir = NULL, bool triangulate = true, + bool default_vcols_fallback = 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 message into `warn`, 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 *warn = NULL, std::string *err = NULL); + +/// Loads object from a std::istream, uses `readMatFn` 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 *shapes, + std::vector *materials, std::string *warn, + std::string *err, std::istream *inStream, + MaterialReader *readMatFn = NULL, bool triangulate = true, + bool default_vcols_fallback = true); + +/// Loads materials into std::map +void LoadMtl(std::map *material_map, + std::vector *materials, std::istream *inStream, + std::string *warning, std::string *err); + +/// +/// Parse texture name and texture option for custom texture parameter through +/// material::unknown_parameter +/// +/// @param[out] texname Parsed texture name +/// @param[out] texopt Parsed texopt +/// @param[in] linebuf Input string +/// +bool ParseTextureNameAndOption(std::string *texname, texture_option_t *texopt, + const char *linebuf); + +/// =<<========== Legacy v1 API ============================================= + +} // namespace tinyobj + +#endif // TINY_OBJ_LOADER_H_ + +#ifdef TINYOBJLOADER_IMPLEMENTATION +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef TINYOBJLOADER_USE_MAPBOX_EARCUT + +#ifdef TINYOBJLOADER_DONOT_INCLUDE_MAPBOX_EARCUT +// Assume earcut.hpp is included outside of tiny_obj_loader.h #else -#error "Must define all or none of TINYOBJ_MALLOC, TINYOBJ_CALLOC, TINYOBJ_FREE, and TINYOBJ_REALLOC (or TINYOBJ_REALLOC_SIZED)." + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Weverything" #endif -#ifndef TINYOBJ_MALLOC -#include -#define TINYOBJ_MALLOC malloc -#define TINYOBJ_REALLOC realloc -#define TINYOBJ_CALLOC calloc -#define TINYOBJ_FREE free +#include +#include "mapbox/earcut.hpp" + +#ifdef __clang__ +#pragma clang diagnostic pop #endif -#ifndef TINYOBJ_REALLOC_SIZED -#define TINYOBJ_REALLOC_SIZED(p,oldsz,newsz) TINYOBJ_REALLOC(p,newsz) #endif -#define TINYOBJ_MAX_FACES_PER_F_LINE (16) -#define TINYOBJ_MAX_FILEPATH (8192) +#endif // TINYOBJLOADER_USE_MAPBOX_EARCUT + +namespace tinyobj { + +MaterialReader::~MaterialReader() {} + +struct vertex_index_t { + 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) {} +}; + +// Internal data structure for face representation +// index + smoothing group. +struct face_t { + unsigned int + smoothing_group_id; // smoothing group id. 0 = smoothing groupd is off. + int pad_; + std::vector vertex_indices; // face vertex indices. + + face_t() : smoothing_group_id(0), pad_(0) {} +}; + +// Internal data structure for line representation +struct __line_t { + // l v1/vt1 v2/vt2 ... + // In the specification, line primitrive does not have normal index, but + // TinyObjLoader allow it + std::vector vertex_indices; +}; + +// Internal data structure for points representation +struct __points_t { + // p v1 v2 ... + // In the specification, point primitrive does not have normal index and + // texture coord index, but TinyObjLoader allow it. + std::vector vertex_indices; +}; + +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 v; + std::vector vn; + std::vector vt; +}; + +// +// Manages group of primitives(face, line, points, ...) +struct PrimGroup { + std::vector 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, ... +}; + +// 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(c); + } + } + } + + return is; +} #define IS_SPACE(x) (((x) == ' ') || ((x) == '\t')) -#define IS_DIGIT(x) ((unsigned int)((x) - '0') < (unsigned int)(10)) +#define IS_DIGIT(x) \ + (static_cast((x) - '0') < static_cast(10)) #define IS_NEW_LINE(x) (((x) == '\r') || ((x) == '\n') || ((x) == '\0')) -static void skip_space(const char **token) { - while ((*token)[0] == ' ' || (*token)[0] == '\t') { - (*token)++; - } +template +static inline std::string toString(const T &t) { + std::stringstream ss; + ss << t; + return ss.str(); } -static void skip_space_and_cr(const char **token) { - while ((*token)[0] == ' ' || (*token)[0] == '\t' || (*token)[0] == '\r') { - (*token)++; - } -} +struct warning_context +{ + std::string *warn; + size_t line_number; +}; -static int until_space(const char *token) { - const char *p = token; - while (p[0] != '\0' && p[0] != ' ' && p[0] != '\t' && p[0] != '\r') { - p++; +// Make index zero-base, and also support relative index. +static inline bool fixIndex(int idx, int n, int *ret, bool allow_zero, const warning_context &context) { + if (!ret) { + return false; } - return (int)(p - token); -} + if (idx > 0) { + (*ret) = idx - 1; + return true; + } -static size_t length_until_newline(const char *token, size_t n) { - size_t len = 0; - - /* Assume token[n-1] = '\0' */ - for (len = 0; len < n - 1; len++) { - if (token[len] == '\n') { - break; - } - if ((token[len] == '\r') && ((len < (n - 2)) && (token[len + 1] != '\n'))) { - break; + 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; } - return len; + if (idx < 0) { + (*ret) = n + idx; // negative value = relative + return true; + } + + return false; // never reach here. } -static size_t length_until_line_feed(const char *token, size_t n) { - size_t len = 0; - - /* Assume token[n-1] = '\0' */ - for (len = 0; len < n; len++) { - if ((token[len] == '\n') || (token[len] == '\r')) { - break; - } - } - - return len; +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; } -/* http://stackoverflow.com/questions/5710091/how-does-atoi-function-in-c-work -*/ -static int my_atoi(const char *c) { - int value = 0; - int sign = 1; - if (*c == '+' || *c == '-') { - if (*c == '-') sign = -1; - c++; - } - while (((*c) >= '0') && ((*c) <= '9')) { /* isdigit(*c) */ - value *= 10; - value += (int)(*c - '0'); - c++; - } - return value * sign; -} - -/* Make index zero-base, and also support relative index. */ -static int fixIndex(int idx, size_t n) { - if (idx > 0) return idx - 1; - if (idx == 0) return 0; - return (int)n + idx; /* negative value = relative */ -} - -/* Parse raw triples: i, i/j/k, i//k, i/j */ -static tinyobj_vertex_index_t parseRawTriple(const char **token) { - tinyobj_vertex_index_t vi; - /* 0x80000000 = -2147483648 = invalid */ - vi.v_idx = (int)(0x80000000); - vi.vn_idx = (int)(0x80000000); - vi.vt_idx = (int)(0x80000000); - - vi.v_idx = my_atoi((*token)); - while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && - (*token)[0] != '\t' && (*token)[0] != '\r') { - (*token)++; - } - if ((*token)[0] != '/') { - return vi; - } - (*token)++; - - /* i//k */ - if ((*token)[0] == '/') { - (*token)++; - vi.vn_idx = my_atoi((*token)); - while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && - (*token)[0] != '\t' && (*token)[0] != '\r') { - (*token)++; - } - return vi; - } - - /* i/j/k or i/j */ - vi.vt_idx = my_atoi((*token)); - while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && - (*token)[0] != '\t' && (*token)[0] != '\r') { - (*token)++; - } - if ((*token)[0] != '/') { - return vi; - } - - /* i/j/k */ - (*token)++; /* skip '/' */ - vi.vn_idx = my_atoi((*token)); - while ((*token)[0] != '\0' && (*token)[0] != '/' && (*token)[0] != ' ' && - (*token)[0] != '\t' && (*token)[0] != '\r') { - (*token)++; - } - return vi; -} - -static int parseInt(const char **token) { - int i = 0; - skip_space(token); - i = my_atoi((*token)); - (*token) += until_space((*token)); +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 int tryParseDouble(const char *s, const char *s_end, double *result) { +// 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. - */ + // 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. - */ + // 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. */ + // How many characters were read in a loop. int read = 0; - /* Tells whether a loop terminated due to reaching s_end. */ - int end_not_reached = 0; + // Tells whether a loop terminated due to reaching s_end. + bool end_not_reached = false; + bool leading_decimal_dots = false; /* - BEGIN PARSING. - */ + BEGIN PARSING. + */ - if (s >= s_end) { - return 0; /* fail */ - } - - /* Find out what sign we've got. */ + // 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. */ + // Read the integer part. end_not_reached = (curr != s_end); - while (end_not_reached && IS_DIGIT(*curr)) { - mantissa *= 10; - mantissa += (int)(*curr - 0x30); - curr++; - read++; - end_not_reached = (curr != s_end); + if (!leading_decimal_dots) { + while (end_not_reached && IS_DIGIT(*curr)) { + mantissa *= 10; + mantissa += static_cast(*curr - 0x30); + curr++; + read++; + end_not_reached = (curr != s_end); + } + + // We must make sure we actually got something. + if (read == 0) goto fail; } - /* We must make sure we actually got something. */ - if (read == 0) goto fail; - /* We allow numbers of form "#", "###" etc. */ + // We allow numbers of form "#", "###" etc. if (!end_not_reached) goto assemble; - /* Read the decimal part. */ + // Read the decimal part. if (*curr == '.') { curr++; read = 1; end_not_reached = (curr != s_end); while (end_not_reached && IS_DIGIT(*curr)) { - /* pow(10.0, -read) */ - double frac_value = 1.0; - int f; - for (f = 0; f < read; f++) { - frac_value *= 0.1; - } - mantissa += (int)(*curr - 0x30) * frac_value; + 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(*curr - 0x30) * + (read < lut_entries ? pow_lut[read] : std::pow(10.0, -read)); read++; curr++; end_not_reached = (curr != s_end); @@ -423,1317 +974,2482 @@ static int tryParseDouble(const char *s, const char *s_end, double *result) { if (!end_not_reached) goto assemble; - /* Read the exponent part. */ + // Read the exponent part. if (*curr == 'e' || *curr == 'E') { curr++; - /* Figure out if a sign is present and if it is. */ + // 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. */ + // Empty E is not allowed. goto fail; } read = 0; end_not_reached = (curr != s_end); while (end_not_reached && IS_DIGIT(*curr)) { + // To avoid annoying MSVC's min/max macro definiton, + // Use hardcoded int max value + if (exponent > (2147483647/10)) { // 2147483647 = std::numeric_limits::max() + // Integer overflow + goto fail; + } exponent *= 10; - exponent += (int)(*curr - 0x30); + exponent += static_cast(*curr - 0x30); curr++; read++; end_not_reached = (curr != s_end); } + exponent *= (exp_sign == '+' ? 1 : -1); if (read == 0) goto fail; } -assemble : - - { - double a = 1.0; /* = pow(5.0, exponent); */ - double b = 1.0; /* = 2.0^exponent */ - int i; - for (i = 0; i < exponent; i++) { - a = a * 5.0; - } - - for (i = 0; i < exponent; i++) { - b = b * 2.0; - } - - if (exp_sign == '-') { - a = 1.0 / a; - b = 1.0 / b; - } - - *result = - /* (sign == '+' ? 1 : -1) * ldexp(mantissa * pow(5.0, exponent), - exponent); */ - (sign == '+' ? 1 : -1) * (mantissa * a * b); - } - - return 1; +assemble: + *result = (sign == '+' ? 1 : -1) * + (exponent ? std::ldexp(mantissa * std::pow(5.0, exponent), exponent) + : mantissa); + return true; fail: - return 0; + return false; } -static float parseFloat(const char **token) { - const char *end; - double val = 0.0; - float f = 0.0f; - skip_space(token); - end = (*token) + until_space((*token)); - val = 0.0; +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); - f = (float)(val); + real_t f = static_cast(val); (*token) = end; return f; } -static void parseFloat2(float *x, float *y, const char **token) { - (*x) = parseFloat(token); - (*y) = parseFloat(token); -} - -static void parseFloat3(float *x, float *y, float *z, const char **token) { - (*x) = parseFloat(token); - (*y) = parseFloat(token); - (*z) = parseFloat(token); -} - -static size_t my_strnlen(const char *s, size_t n) { - const char *p = (char *)memchr(s, 0, n); - return p ? (size_t)(p - s) : n; -} - -static char *my_strdup(const char *s, size_t max_length) { - char *d; - size_t len; - - if (s == NULL) return NULL; - - /* Do not consider CRLF line ending(#19) */ - len = length_until_line_feed(s, max_length); - /* len = strlen(s); */ - - /* trim line ending and append '\0' */ - d = (char *)TINYOBJ_MALLOC(len + 1); /* + '\0' */ - memcpy(d, s, (size_t)(len)); - d[len] = '\0'; - - return d; -} - -static char *my_strndup(const char *s, size_t len) { - char *d; - size_t slen; - - if (s == NULL) return NULL; - if (len == 0) return NULL; - - slen = my_strnlen(s, len); - d = (char *)TINYOBJ_MALLOC(slen + 1); /* + '\0' */ - if (!d) { - return NULL; +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(val); + (*out) = f; } - memcpy(d, s, slen); - d[slen] = '\0'; - - return d; -} - -char *dynamic_fgets(char **buf, size_t *size, FILE *file) { - char *offset; - char *ret; - size_t old_size; - - if (!(ret = fgets(*buf, (int)*size, file))) { - return ret; - } - - if (NULL != strchr(*buf, '\n')) { - return ret; - } - - do { - old_size = *size; - *size *= 2; - *buf = (char*)TINYOBJ_REALLOC_SIZED(*buf, old_size, *size); - offset = &((*buf)[old_size - 1]); - - ret = fgets(offset, (int)(old_size + 1), file); - } while(ret && (NULL == strchr(*buf, '\n'))); - + (*token) = end; return ret; } -static void initMaterial(tinyobj_material_t *material) { - int i; - material->name = NULL; - material->ambient_texname = NULL; - material->diffuse_texname = NULL; - material->specular_texname = NULL; - material->specular_highlight_texname = NULL; - material->bump_texname = NULL; - material->displacement_texname = NULL; - material->alpha_texname = NULL; - for (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; +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); + + const bool found_color = + parseReal(token, r) && parseReal(token, g) && parseReal(token, b); + + if (!found_color) { + (*r) = (*g) = (*b) = 1.0; + } + + return found_color; +} + +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_t *ret, const warning_context &context) { + if (!ret) { + return false; + } + + vertex_index_t vi(-1); + + if (!fixIndex(atoi((*token)), vsize, &vi.v_idx, false, context)) { + 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, true, context)) { + 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, true, context)) { + 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, true, context)) { + 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_t parseRawTriple(const char **token) { + vertex_index_t vi(static_cast(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; +} + +bool ParseTextureNameAndOption(std::string *texname, texture_option_t *texopt, + const char *linebuf) { + // @todo { write more robust lexer and parser. } + bool found_texname = false; + std::string texture_name; + + 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, "-texres", 7)) && IS_SPACE((token[7]))) { + token += 7; + // TODO(syoyo): Check if arg is int type. + texopt->texture_resolution = parseInt(&token); + } 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 if ((0 == strncmp(token, "-colorspace", 11)) && + IS_SPACE((token[11]))) { + token += 12; + texopt->colorspace = parseString(&token); + } 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 InitTexOpt(texture_option_t *texopt, const bool is_bump) { + if (is_bump) { + texopt->imfchan = 'l'; + } else { + texopt->imfchan = 'm'; + } + texopt->bump_multiplier = static_cast(1.0); + texopt->clamp = false; + texopt->blendu = true; + texopt->blendv = true; + texopt->sharpness = static_cast(1.0); + texopt->brightness = static_cast(0.0); + texopt->contrast = static_cast(1.0); + texopt->origin_offset[0] = static_cast(0.0); + texopt->origin_offset[1] = static_cast(0.0); + texopt->origin_offset[2] = static_cast(0.0); + texopt->scale[0] = static_cast(1.0); + texopt->scale[1] = static_cast(1.0); + texopt->scale[2] = static_cast(1.0); + texopt->turbulence[0] = static_cast(0.0); + texopt->turbulence[1] = static_cast(0.0); + texopt->turbulence[2] = static_cast(0.0); + texopt->texture_resolution = -1; + texopt->type = TEXTURE_TYPE_NONE; +} + +static void InitMaterial(material_t *material) { + InitTexOpt(&material->ambient_texopt, /* is_bump */ false); + InitTexOpt(&material->diffuse_texopt, /* is_bump */ false); + InitTexOpt(&material->specular_texopt, /* is_bump */ false); + InitTexOpt(&material->specular_highlight_texopt, /* is_bump */ false); + InitTexOpt(&material->bump_texopt, /* is_bump */ true); + InitTexOpt(&material->displacement_texopt, /* is_bump */ false); + InitTexOpt(&material->alpha_texopt, /* is_bump */ false); + InitTexOpt(&material->reflection_texopt, /* is_bump */ false); + InitTexOpt(&material->roughness_texopt, /* is_bump */ false); + InitTexOpt(&material->metallic_texopt, /* is_bump */ false); + InitTexOpt(&material->sheen_texopt, /* is_bump */ false); + InitTexOpt(&material->emissive_texopt, /* is_bump */ false); + InitTexOpt(&material->normal_texopt, + /* is_bump */ false); // @fixme { is_bump will be true? } + 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(0.0); + material->diffuse[i] = static_cast(0.0); + material->specular[i] = static_cast(0.0); + material->transmittance[i] = static_cast(0.0); + material->emission[i] = static_cast(0.0); } material->illum = 0; - material->dissolve = 1.f; - material->shininess = 1.f; - material->ior = 1.f; + material->dissolve = static_cast(1.0); + material->shininess = static_cast(1.0); + material->ior = static_cast(1.0); + + material->roughness = static_cast(0.0); + material->metallic = static_cast(0.0); + material->sheen = static_cast(0.0); + material->clearcoat_thickness = static_cast(0.0); + material->clearcoat_roughness = static_cast(0.0); + material->anisotropy_rotation = static_cast(0.0); + material->anisotropy = static_cast(0.0); + material->roughness_texname = ""; + material->metallic_texname = ""; + material->sheen_texname = ""; + material->emissive_texname = ""; + material->normal_texname = ""; + + material->unknown_parameter.clear(); } -/* Implementation of string to int hashtable */ - -#define HASH_TABLE_ERROR 1 -#define HASH_TABLE_SUCCESS 0 - -#define HASH_TABLE_DEFAULT_SIZE 10 - -typedef struct hash_table_entry_t -{ - unsigned long hash; - int filled; - int pad0; - long value; - - struct hash_table_entry_t* next; -} hash_table_entry_t; - -typedef struct -{ - unsigned long* hashes; - hash_table_entry_t* entries; - size_t capacity; - size_t n; -} hash_table_t; - -static unsigned long hash_djb2(const unsigned char* str) -{ - unsigned long hash = 5381; - int c; - - while ((c = *str++)) { - hash = ((hash << 5) + hash) + (unsigned long)(c); +// code from https://wrf.ecse.rpi.edu//Research/Short_Notes/pnpoly.html +template +static int pnpoly(int nvert, T *vertx, T *verty, T testx, T testy) { + int i, j, c = 0; + for (i = 0, j = nvert - 1; i < nvert; j = i++) { + if (((verty[i] > testy) != (verty[j] > testy)) && + (testx < + (vertx[j] - vertx[i]) * (testy - verty[i]) / (verty[j] - verty[i]) + + vertx[i])) + c = !c; } - - return hash; + return c; } -static void create_hash_table(size_t start_capacity, hash_table_t* hash_table) -{ - if (start_capacity < 1) - start_capacity = HASH_TABLE_DEFAULT_SIZE; - hash_table->hashes = (unsigned long*) TINYOBJ_MALLOC(start_capacity * sizeof(unsigned long)); - hash_table->entries = (hash_table_entry_t*) TINYOBJ_CALLOC(start_capacity, sizeof(hash_table_entry_t)); - hash_table->capacity = start_capacity; - hash_table->n = 0; +struct TinyObjPoint { + real_t x, y, z; + TinyObjPoint() : x(0), y(0), z(0) {} + TinyObjPoint(real_t x_, real_t y_, real_t z_) : + x(x_), y(y_), z(z_) {} +}; + +inline TinyObjPoint cross(const TinyObjPoint &v1, const TinyObjPoint &v2) { + return TinyObjPoint(v1.y * v2.z - v1.z * v2.y, + v1.z * v2.x - v1.x * v2.z, + v1.x * v2.y - v1.y * v2.x); } -static void destroy_hash_table(hash_table_t* hash_table) -{ - TINYOBJ_FREE(hash_table->entries); - TINYOBJ_FREE(hash_table->hashes); +inline real_t dot(const TinyObjPoint &v1, const TinyObjPoint &v2) { + return (v1.x * v2.x + v1.y * v2.y + v1.z * v2.z); } -/* Insert with quadratic probing */ -static int hash_table_insert_value(unsigned long hash, long value, hash_table_t* hash_table) -{ - /* Insert value */ - size_t start_index = hash % hash_table->capacity; - size_t index = start_index; - hash_table_entry_t* start_entry = hash_table->entries + start_index; - size_t i; - hash_table_entry_t* entry; - - for (i = 1; hash_table->entries[index].filled; i++) - { - if (i >= hash_table->capacity) - return HASH_TABLE_ERROR; - index = (start_index + (i * i)) % hash_table->capacity; - } - - entry = hash_table->entries + index; - entry->hash = hash; - entry->filled = 1; - entry->value = value; - - if (index != start_index) { - /* This is a new entry, but not the start entry, hence we need to add a next pointer to our entry */ - entry->next = start_entry->next; - start_entry->next = entry; - } - - return HASH_TABLE_SUCCESS; +inline real_t GetLength(TinyObjPoint &e) { + return std::sqrt(e.x*e.x + e.y*e.y + e.z*e.z); } -static int hash_table_insert(unsigned long hash, long value, hash_table_t* hash_table) -{ - int ret = hash_table_insert_value(hash, value, hash_table); - if (ret == HASH_TABLE_SUCCESS) - { - hash_table->hashes[hash_table->n] = hash; - hash_table->n++; - } - return ret; +inline TinyObjPoint Normalize(TinyObjPoint e) { + real_t inv_length = real_t(1) / GetLength(e); + return TinyObjPoint(e.x * inv_length, e.y * inv_length, e.z * inv_length ); } -static hash_table_entry_t* hash_table_find(unsigned long hash, hash_table_t* hash_table) -{ - hash_table_entry_t* entry = hash_table->entries + (hash % hash_table->capacity); - while (entry) - { - if (entry->hash == hash && entry->filled) - { - return entry; - } - entry = entry->next; - } - return NULL; + +inline TinyObjPoint WorldToLocal(const TinyObjPoint& a, + const TinyObjPoint& u, + const TinyObjPoint& v, + const TinyObjPoint& w) { + return TinyObjPoint(dot(a,u),dot(a,v),dot(a,w)); } -static void hash_table_maybe_grow(size_t new_n, hash_table_t* hash_table) -{ - size_t new_capacity; - hash_table_t new_hash_table; - size_t i; - if (new_n <= hash_table->capacity) { - return; - } - new_capacity = 2 * ((2 * hash_table->capacity) > new_n ? hash_table->capacity : new_n); - /* Create a new hash table. We're not calling create_hash_table because we want to realloc the hash array */ - new_hash_table.hashes = hash_table->hashes = (unsigned long*) TINYOBJ_REALLOC_SIZED( - (void*) hash_table->hashes, sizeof(unsigned long) * hash_table->capacity, sizeof(unsigned long) * new_capacity); - new_hash_table.entries = (hash_table_entry_t*) TINYOBJ_CALLOC(new_capacity, sizeof(hash_table_entry_t)); - new_hash_table.capacity = new_capacity; - new_hash_table.n = hash_table->n; - - /* Rehash */ - for (i = 0; i < hash_table->capacity; i++) - { - hash_table_entry_t* entry = hash_table_find(hash_table->hashes[i], hash_table); - hash_table_insert_value(hash_table->hashes[i], entry->value, &new_hash_table); +// TODO(syoyo): refactor function. +static bool exportGroupsToShape(shape_t *shape, const PrimGroup &prim_group, + const std::vector &tags, + const int material_id, const std::string &name, + bool triangulate, const std::vector &v, + std::string *warn) { + if (prim_group.IsEmpty()) { + return false; } - TINYOBJ_FREE(hash_table->entries); - (*hash_table) = new_hash_table; -} + shape->name = name; -static int hash_table_exists(const char* name, hash_table_t* hash_table) -{ - return hash_table_find(hash_djb2((const unsigned char*)name), hash_table) != NULL; -} + // polygon + if (!prim_group.faceGroup.empty()) { + // Flatten vertices and indices + for (size_t i = 0; i < prim_group.faceGroup.size(); i++) { + const face_t &face = prim_group.faceGroup[i]; -static void hash_table_set(const char* name, size_t val, hash_table_t* hash_table) -{ - /* Hash name */ - unsigned long hash = hash_djb2((const unsigned char *)name); + size_t npolys = face.vertex_indices.size(); - hash_table_entry_t* entry = hash_table_find(hash, hash_table); - if (entry) - { - entry->value = (long)val; - return; - } - - /* Expand if necessary - * Grow until the element has been added - */ - do - { - hash_table_maybe_grow(hash_table->n + 1, hash_table); - } - while (hash_table_insert(hash, (long)val, hash_table) != HASH_TABLE_SUCCESS); -} - -static long hash_table_get(const char* name, hash_table_t* hash_table) -{ - hash_table_entry_t* ret = hash_table_find(hash_djb2((const unsigned char*)(name)), hash_table); - return ret->value; -} - -static tinyobj_material_t *tinyobj_material_add(tinyobj_material_t *prev, - size_t num_materials, - tinyobj_material_t *new_mat) { - tinyobj_material_t *dst; - size_t num_bytes = sizeof(tinyobj_material_t) * num_materials; - dst = (tinyobj_material_t *)TINYOBJ_REALLOC_SIZED( - prev, num_bytes, num_bytes + sizeof(tinyobj_material_t)); - - dst[num_materials] = (*new_mat); /* Just copy pointer for char* members */ - return dst; -} - -static int is_line_ending(const char *p, size_t i, size_t end_i) { - if (p[i] == '\0') return 1; - if (p[i] == '\n') return 1; /* this includes \r\n */ - if (p[i] == '\r') { - if (((i + 1) < end_i) && (p[i + 1] != '\n')) { /* detect only \r case */ - return 1; - } - } - return 0; -} - -typedef struct { - size_t pos; - size_t len; -} LineInfo; - -/* Find '\n' and create line data. */ -static int get_line_infos(const char *buf, size_t buf_len, LineInfo **line_infos, size_t *num_lines) -{ - size_t i = 0; - size_t end_idx = buf_len; - size_t prev_pos = 0; - size_t line_no = 0; - size_t last_line_ending = 0; - - /* Count # of lines. */ - for (i = 0; i < end_idx; i++) { - if (is_line_ending(buf, i, end_idx)) { - (*num_lines)++; - last_line_ending = i; - } - } - /* The last char from the input may not be a line - * ending character so add an extra line if there - * are more characters after the last line ending - * that was found. */ - if (end_idx - last_line_ending > 0) { - (*num_lines)++; - } - - if (*num_lines == 0) return TINYOBJ_ERROR_EMPTY; - - *line_infos = (LineInfo *)TINYOBJ_MALLOC(sizeof(LineInfo) * (*num_lines)); - - /* Fill line infos. */ - for (i = 0; i < end_idx; i++) { - if (is_line_ending(buf, i, end_idx)) { - (*line_infos)[line_no].pos = prev_pos; - (*line_infos)[line_no].len = i - prev_pos; - prev_pos = i + 1; - line_no++; - } - } - if (end_idx - last_line_ending > 0) { - (*line_infos)[line_no].pos = prev_pos; - (*line_infos)[line_no].len = end_idx - 1 - last_line_ending; - } - - return 0; -} - -static int tinyobj_parse_and_index_mtl_file(tinyobj_material_t **materials_out, - size_t *num_materials_out, - const char *mtl_filename, const char *obj_filename, file_reader_callback file_reader, void *ctx, - hash_table_t* material_table) { - tinyobj_material_t material; - size_t num_materials = 0; - tinyobj_material_t *materials = NULL; - int has_previous_material = 0; - const char *line_end = NULL; - size_t num_lines = 0; - LineInfo *line_infos = NULL; - size_t i = 0; - char *buf = NULL; - size_t len = 0; - - if (materials_out == NULL) { - return TINYOBJ_ERROR_INVALID_PARAMETER; - } - - if (num_materials_out == NULL) { - return TINYOBJ_ERROR_INVALID_PARAMETER; - } - - (*materials_out) = NULL; - (*num_materials_out) = 0; - - file_reader(ctx, mtl_filename, 1, obj_filename, &buf, &len); - if (len < 1) return TINYOBJ_ERROR_INVALID_PARAMETER; - if (buf == NULL) return TINYOBJ_ERROR_INVALID_PARAMETER; - - if (get_line_infos(buf, len, &line_infos, &num_lines) != 0) { - TINYOBJ_FREE(line_infos); - return TINYOBJ_ERROR_EMPTY; - } - - /* Create a default material */ - initMaterial(&material); - - for (i = 0; i < num_lines; i++) { - const char *p = &buf[line_infos[i].pos]; - size_t p_len = line_infos[i].len; - - char linebuf[4096]; - const char *token; - assert(p_len < 4095); - - memcpy(linebuf, p, p_len); - linebuf[p_len] = '\0'; - - token = linebuf; - line_end = token + p_len; - - /* Skip leading space. */ - 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]))) { - char namebuf[4096]; - - /* flush previous material. */ - if (has_previous_material) { - materials = tinyobj_material_add(materials, num_materials, &material); - num_materials++; - } else { - has_previous_material = 1; + if (npolys < 3) { + // Face must have 3+ vertices. + if (warn) { + (*warn) += "Degenerated face found\n."; + } + continue; } - /* initial temporary material */ - initMaterial(&material); + if (triangulate && npolys != 3) { + if (npolys == 4) { + vertex_index_t i0 = face.vertex_indices[0]; + vertex_index_t i1 = face.vertex_indices[1]; + vertex_index_t i2 = face.vertex_indices[2]; + vertex_index_t i3 = face.vertex_indices[3]; - /* set new mtl name */ - token += 7; -#ifdef _MSC_VER - sscanf_s(token, "%s", namebuf, (unsigned)_countof(namebuf)); -#else - sscanf(token, "%s", namebuf); + size_t vi0 = size_t(i0.v_idx); + size_t vi1 = size_t(i1.v_idx); + size_t vi2 = size_t(i2.v_idx); + size_t vi3 = size_t(i3.v_idx); + + if (((3 * vi0 + 2) >= v.size()) || ((3 * vi1 + 2) >= v.size()) || + ((3 * vi2 + 2) >= v.size()) || ((3 * vi3 + 2) >= v.size())) { + // Invalid triangle. + // FIXME(syoyo): Is it ok to simply skip this invalid triangle? + if (warn) { + (*warn) += "Face with invalid vertex index found.\n"; + } + continue; + } + + real_t v0x = v[vi0 * 3 + 0]; + real_t v0y = v[vi0 * 3 + 1]; + real_t v0z = v[vi0 * 3 + 2]; + real_t v1x = v[vi1 * 3 + 0]; + real_t v1y = v[vi1 * 3 + 1]; + real_t v1z = v[vi1 * 3 + 2]; + real_t v2x = v[vi2 * 3 + 0]; + real_t v2y = v[vi2 * 3 + 1]; + real_t v2z = v[vi2 * 3 + 2]; + real_t v3x = v[vi3 * 3 + 0]; + real_t v3y = v[vi3 * 3 + 1]; + real_t v3z = v[vi3 * 3 + 2]; + + // There are two candidates to split the quad into two triangles. + // + // Choose the shortest edge. + // TODO: Is it better to determine the edge to split by calculating + // the area of each triangle? + // + // +---+ + // |\ | + // | \ | + // | \| + // +---+ + // + // +---+ + // | /| + // | / | + // |/ | + // +---+ + + real_t e02x = v2x - v0x; + real_t e02y = v2y - v0y; + real_t e02z = v2z - v0z; + real_t e13x = v3x - v1x; + real_t e13y = v3y - v1y; + real_t e13z = v3z - v1z; + + real_t sqr02 = e02x * e02x + e02y * e02y + e02z * e02z; + real_t sqr13 = e13x * e13x + e13y * e13y + e13z * e13z; + + index_t idx0, idx1, idx2, idx3; + + 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; + idx3.vertex_index = i3.v_idx; + idx3.normal_index = i3.vn_idx; + idx3.texcoord_index = i3.vt_idx; + + if (sqr02 < sqr13) { + // [0, 1, 2], [0, 2, 3] + shape->mesh.indices.push_back(idx0); + shape->mesh.indices.push_back(idx1); + shape->mesh.indices.push_back(idx2); + + shape->mesh.indices.push_back(idx0); + shape->mesh.indices.push_back(idx2); + shape->mesh.indices.push_back(idx3); + } else { + // [0, 1, 3], [1, 2, 3] + shape->mesh.indices.push_back(idx0); + shape->mesh.indices.push_back(idx1); + shape->mesh.indices.push_back(idx3); + + shape->mesh.indices.push_back(idx1); + shape->mesh.indices.push_back(idx2); + shape->mesh.indices.push_back(idx3); + } + + // Two triangle faces + shape->mesh.num_face_vertices.push_back(3); + shape->mesh.num_face_vertices.push_back(3); + + shape->mesh.material_ids.push_back(material_id); + shape->mesh.material_ids.push_back(material_id); + + shape->mesh.smoothing_group_ids.push_back(face.smoothing_group_id); + shape->mesh.smoothing_group_ids.push_back(face.smoothing_group_id); + + } else { +#ifdef TINYOBJLOADER_USE_MAPBOX_EARCUT + vertex_index_t i0 = face.vertex_indices[0]; + vertex_index_t i0_2 = i0; + + // TMW change: Find the normal axis of the polygon using Newell's method + TinyObjPoint n; + for (size_t k = 0; k < npolys; ++k) { + i0 = face.vertex_indices[k % npolys]; + size_t vi0 = size_t(i0.v_idx); + + size_t j = (k + 1) % npolys; + i0_2 = face.vertex_indices[j]; + size_t vi0_2 = size_t(i0_2.v_idx); + + real_t v0x = v[vi0 * 3 + 0]; + real_t v0y = v[vi0 * 3 + 1]; + real_t v0z = v[vi0 * 3 + 2]; + + real_t v0x_2 = v[vi0_2 * 3 + 0]; + real_t v0y_2 = v[vi0_2 * 3 + 1]; + real_t v0z_2 = v[vi0_2 * 3 + 2]; + + const TinyObjPoint point1(v0x,v0y,v0z); + const TinyObjPoint point2(v0x_2,v0y_2,v0z_2); + + TinyObjPoint a(point1.x - point2.x, point1.y - point2.y, point1.z - point2.z); + TinyObjPoint b(point1.x + point2.x, point1.y + point2.y, point1.z + point2.z); + + n.x += (a.y * b.z); + n.y += (a.z * b.x); + n.z += (a.x * b.y); + } + real_t length_n = GetLength(n); + //Check if zero length normal + if(length_n <= 0) { + continue; + } + //Negative is to flip the normal to the correct direction + real_t inv_length = -real_t(1.0) / length_n; + n.x *= inv_length; + n.y *= inv_length; + n.z *= inv_length; + + TinyObjPoint axis_w, axis_v, axis_u; + axis_w = n; + TinyObjPoint a; + if(std::abs(axis_w.x) > real_t(0.9999999)) { + a = TinyObjPoint(0,1,0); + } else { + a = TinyObjPoint(1,0,0); + } + axis_v = Normalize(cross(axis_w, a)); + axis_u = cross(axis_w, axis_v); + using Point = std::array; + + // first polyline define the main polygon. + // following polylines define holes(not used in tinyobj). + std::vector > polygon; + + std::vector polyline; + + //TMW change: Find best normal and project v0x and v0y to those coordinates, instead of + //picking a plane aligned with an axis (which can flip polygons). + + // Fill polygon data(facevarying vertices). + for (size_t k = 0; k < npolys; k++) { + i0 = face.vertex_indices[k]; + size_t vi0 = size_t(i0.v_idx); + + assert(((3 * vi0 + 2) < v.size())); + + real_t v0x = v[vi0 * 3 + 0]; + real_t v0y = v[vi0 * 3 + 1]; + real_t v0z = v[vi0 * 3 + 2]; + + TinyObjPoint polypoint(v0x,v0y,v0z); + TinyObjPoint loc = WorldToLocal(polypoint, axis_u, axis_v, axis_w); + + polyline.push_back({loc.x, loc.y}); + } + + polygon.push_back(polyline); + std::vector indices = mapbox::earcut(polygon); + // => result = 3 * faces, clockwise + + assert(indices.size() % 3 == 0); + + // Reconstruct vertex_index_t + for (size_t k = 0; k < indices.size() / 3; k++) { + { + index_t idx0, idx1, idx2; + idx0.vertex_index = face.vertex_indices[indices[3 * k + 0]].v_idx; + idx0.normal_index = + face.vertex_indices[indices[3 * k + 0]].vn_idx; + idx0.texcoord_index = + face.vertex_indices[indices[3 * k + 0]].vt_idx; + idx1.vertex_index = face.vertex_indices[indices[3 * k + 1]].v_idx; + idx1.normal_index = + face.vertex_indices[indices[3 * k + 1]].vn_idx; + idx1.texcoord_index = + face.vertex_indices[indices[3 * k + 1]].vt_idx; + idx2.vertex_index = face.vertex_indices[indices[3 * k + 2]].v_idx; + idx2.normal_index = + face.vertex_indices[indices[3 * k + 2]].vn_idx; + idx2.texcoord_index = + face.vertex_indices[indices[3 * k + 2]].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); + shape->mesh.smoothing_group_ids.push_back( + face.smoothing_group_id); + } + } + +#else // Built-in ear clipping triangulation + vertex_index_t i0 = face.vertex_indices[0]; + vertex_index_t i1(-1); + vertex_index_t i2 = face.vertex_indices[1]; + + // find the two axes to work in + size_t axes[2] = {1, 2}; + for (size_t k = 0; k < npolys; ++k) { + i0 = face.vertex_indices[(k + 0) % npolys]; + i1 = face.vertex_indices[(k + 1) % npolys]; + i2 = face.vertex_indices[(k + 2) % npolys]; + size_t vi0 = size_t(i0.v_idx); + size_t vi1 = size_t(i1.v_idx); + size_t vi2 = size_t(i2.v_idx); + + if (((3 * vi0 + 2) >= v.size()) || ((3 * vi1 + 2) >= v.size()) || + ((3 * vi2 + 2) >= v.size())) { + // Invalid triangle. + // FIXME(syoyo): Is it ok to simply skip this invalid triangle? + continue; + } + real_t v0x = v[vi0 * 3 + 0]; + real_t v0y = v[vi0 * 3 + 1]; + real_t v0z = v[vi0 * 3 + 2]; + real_t v1x = v[vi1 * 3 + 0]; + real_t v1y = v[vi1 * 3 + 1]; + real_t v1z = v[vi1 * 3 + 2]; + real_t v2x = v[vi2 * 3 + 0]; + real_t v2y = v[vi2 * 3 + 1]; + real_t v2z = v[vi2 * 3 + 2]; + real_t e0x = v1x - v0x; + real_t e0y = v1y - v0y; + real_t e0z = v1z - v0z; + real_t e1x = v2x - v1x; + real_t e1y = v2y - v1y; + real_t e1z = v2z - v1z; + real_t cx = std::fabs(e0y * e1z - e0z * e1y); + real_t cy = std::fabs(e0z * e1x - e0x * e1z); + real_t cz = std::fabs(e0x * e1y - e0y * e1x); + const real_t epsilon = std::numeric_limits::epsilon(); + // std::cout << "cx " << cx << ", cy " << cy << ", cz " << cz << + // "\n"; + if (cx > epsilon || cy > epsilon || cz > epsilon) { + // std::cout << "corner\n"; + // found a corner + if (cx > cy && cx > cz) { + // std::cout << "pattern0\n"; + } else { + // std::cout << "axes[0] = 0\n"; + axes[0] = 0; + if (cz > cx && cz > cy) { + // std::cout << "axes[1] = 1\n"; + axes[1] = 1; + } + } + break; + } + } + + face_t remainingFace = face; // copy + size_t guess_vert = 0; + vertex_index_t ind[3]; + real_t vx[3]; + real_t vy[3]; + + // How many iterations can we do without decreasing the remaining + // vertices. + size_t remainingIterations = face.vertex_indices.size(); + size_t previousRemainingVertices = + remainingFace.vertex_indices.size(); + + while (remainingFace.vertex_indices.size() > 3 && + remainingIterations > 0) { + // std::cout << "remainingIterations " << remainingIterations << + // "\n"; + + npolys = remainingFace.vertex_indices.size(); + if (guess_vert >= npolys) { + guess_vert -= npolys; + } + + if (previousRemainingVertices != npolys) { + // The number of remaining vertices decreased. Reset counters. + previousRemainingVertices = npolys; + remainingIterations = npolys; + } else { + // We didn't consume a vertex on previous iteration, reduce the + // available iterations. + remainingIterations--; + } + + for (size_t k = 0; k < 3; k++) { + ind[k] = remainingFace.vertex_indices[(guess_vert + k) % npolys]; + size_t vi = size_t(ind[k].v_idx); + if (((vi * 3 + axes[0]) >= v.size()) || + ((vi * 3 + axes[1]) >= v.size())) { + // ??? + vx[k] = static_cast(0.0); + vy[k] = static_cast(0.0); + } else { + vx[k] = v[vi * 3 + axes[0]]; + vy[k] = v[vi * 3 + axes[1]]; + } + } + + // + // area is calculated per face + // + real_t e0x = vx[1] - vx[0]; + real_t e0y = vy[1] - vy[0]; + real_t e1x = vx[2] - vx[1]; + real_t e1y = vy[2] - vy[1]; + real_t cross = e0x * e1y - e0y * e1x; + // std::cout << "axes = " << axes[0] << ", " << axes[1] << "\n"; + // std::cout << "e0x, e0y, e1x, e1y " << e0x << ", " << e0y << ", " + // << e1x << ", " << e1y << "\n"; + + real_t area = (vx[0] * vy[1] - vy[0] * vx[1]) * static_cast(0.5); + // std::cout << "cross " << cross << ", area " << area << "\n"; + // if an internal angle + if (cross * area < static_cast(0.0)) { + // std::cout << "internal \n"; + guess_vert += 1; + // std::cout << "guess vert : " << guess_vert << "\n"; + continue; + } + + // check all other verts in case they are inside this triangle + bool overlap = false; + for (size_t otherVert = 3; otherVert < npolys; ++otherVert) { + size_t idx = (guess_vert + otherVert) % npolys; + + if (idx >= remainingFace.vertex_indices.size()) { + // std::cout << "???0\n"; + // ??? + continue; + } + + size_t ovi = size_t(remainingFace.vertex_indices[idx].v_idx); + + if (((ovi * 3 + axes[0]) >= v.size()) || + ((ovi * 3 + axes[1]) >= v.size())) { + // std::cout << "???1\n"; + // ??? + continue; + } + real_t tx = v[ovi * 3 + axes[0]]; + real_t ty = v[ovi * 3 + axes[1]]; + if (pnpoly(3, vx, vy, tx, ty)) { + // std::cout << "overlap\n"; + overlap = true; + break; + } + } + + if (overlap) { + // std::cout << "overlap2\n"; + guess_vert += 1; + continue; + } + + // this triangle is an ear + { + index_t idx0, idx1, idx2; + idx0.vertex_index = ind[0].v_idx; + idx0.normal_index = ind[0].vn_idx; + idx0.texcoord_index = ind[0].vt_idx; + idx1.vertex_index = ind[1].v_idx; + idx1.normal_index = ind[1].vn_idx; + idx1.texcoord_index = ind[1].vt_idx; + idx2.vertex_index = ind[2].v_idx; + idx2.normal_index = ind[2].vn_idx; + idx2.texcoord_index = ind[2].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); + shape->mesh.smoothing_group_ids.push_back( + face.smoothing_group_id); + } + + // remove v1 from the list + size_t removed_vert_index = (guess_vert + 1) % npolys; + while (removed_vert_index + 1 < npolys) { + remainingFace.vertex_indices[removed_vert_index] = + remainingFace.vertex_indices[removed_vert_index + 1]; + removed_vert_index += 1; + } + remainingFace.vertex_indices.pop_back(); + } + + // std::cout << "remainingFace.vi.size = " << + // remainingFace.vertex_indices.size() << "\n"; + if (remainingFace.vertex_indices.size() == 3) { + i0 = remainingFace.vertex_indices[0]; + i1 = remainingFace.vertex_indices[1]; + i2 = remainingFace.vertex_indices[2]; + { + 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); + shape->mesh.smoothing_group_ids.push_back( + face.smoothing_group_id); + } + } #endif - material.name = my_strdup(namebuf, (size_t) (line_end - token)); + } // npolys + } else { + for (size_t k = 0; k < npolys; k++) { + index_t idx; + idx.vertex_index = face.vertex_indices[k].v_idx; + idx.normal_index = face.vertex_indices[k].vn_idx; + idx.texcoord_index = face.vertex_indices[k].vt_idx; + shape->mesh.indices.push_back(idx); + } - /* Add material to material table */ - if (material_table) - hash_table_set(material.name, num_materials, material_table); + shape->mesh.num_face_vertices.push_back( + static_cast(npolys)); + shape->mesh.material_ids.push_back(material_id); // per face + shape->mesh.smoothing_group_ids.push_back( + face.smoothing_group_id); // per face + } + } + shape->mesh.tags = tags; + } + + // line + if (!prim_group.lineGroup.empty()) { + // Flatten indices + for (size_t i = 0; i < prim_group.lineGroup.size(); i++) { + for (size_t j = 0; j < prim_group.lineGroup[i].vertex_indices.size(); + j++) { + const vertex_index_t &vi = prim_group.lineGroup[i].vertex_indices[j]; + + index_t idx; + idx.vertex_index = vi.v_idx; + idx.normal_index = vi.vn_idx; + idx.texcoord_index = vi.vt_idx; + + shape->lines.indices.push_back(idx); + } + + shape->lines.num_line_vertices.push_back( + int(prim_group.lineGroup[i].vertex_indices.size())); + } + } + + // points + if (!prim_group.pointsGroup.empty()) { + // Flatten & convert indices + for (size_t i = 0; i < prim_group.pointsGroup.size(); i++) { + for (size_t j = 0; j < prim_group.pointsGroup[i].vertex_indices.size(); + j++) { + const vertex_index_t &vi = prim_group.pointsGroup[i].vertex_indices[j]; + + index_t idx; + idx.vertex_index = vi.v_idx; + idx.normal_index = vi.vn_idx; + idx.texcoord_index = vi.vt_idx; + + shape->points.indices.push_back(idx); + } + } + } + + return true; +} + +// Split a string with specified delimiter character and escape character. +// https://rosettacode.org/wiki/Tokenize_a_string_with_escaping#C.2B.2B +static void SplitString(const std::string &s, char delim, char escape, + std::vector &elems) { + std::string token; + + bool escaping = false; + for (size_t i = 0; i < s.size(); ++i) { + char ch = s[i]; + if (escaping) { + escaping = false; + } else if (ch == escape) { + escaping = true; + continue; + } else if (ch == delim) { + if (!token.empty()) { + elems.push_back(token); + } + token.clear(); + continue; + } + token += ch; + } + + elems.push_back(token); +} + +static std::string JoinPath(const std::string &dir, + const std::string &filename) { + if (dir.empty()) { + return filename; + } else { + // check '/' + char lastChar = *dir.rbegin(); + if (lastChar != '/') { + return dir + std::string("/") + filename; + } else { + return dir + filename; + } + } +} + +void LoadMtl(std::map *material_map, + std::vector *materials, std::istream *inStream, + std::string *warning, std::string *err) { + (void)err; + + // 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; + + // has_kd is used to set a default diffuse value when map_Kd is present + // and Kd is not. + bool has_kd = false; + + std::stringstream warn_ss; + + size_t line_no = 0; + std::string linebuf; + while (inStream->peek() != -1) { + safeGetline(*inStream, linebuf); + line_no++; + + // 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; } - /* ambient */ + // 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( + material.name, static_cast(materials->size()))); + materials->push_back(material); + } + + // initial temporary material + InitMaterial(&material); + + has_d = false; + has_tr = false; + + // set new mtl name + token += 7; + { + std::string namebuf = parseString(&token); + // TODO: empty name check? + if (namebuf.empty()) { + if (warning) { + (*warning) += "empty material name in `newmtl`\n"; + } + } + material.name = namebuf; + } + continue; + } + + // ambient if (token[0] == 'K' && token[1] == 'a' && IS_SPACE((token[2]))) { - float r, g, b; token += 2; - parseFloat3(&r, &g, &b, &token); + real_t r, g, b; + parseReal3(&r, &g, &b, &token); material.ambient[0] = r; material.ambient[1] = g; material.ambient[2] = b; continue; } - /* diffuse */ + // diffuse if (token[0] == 'K' && token[1] == 'd' && IS_SPACE((token[2]))) { - float r, g, b; token += 2; - parseFloat3(&r, &g, &b, &token); + real_t r, g, b; + parseReal3(&r, &g, &b, &token); material.diffuse[0] = r; material.diffuse[1] = g; material.diffuse[2] = b; + has_kd = true; continue; } - /* specular */ + // specular if (token[0] == 'K' && token[1] == 's' && IS_SPACE((token[2]))) { - float r, g, b; token += 2; - parseFloat3(&r, &g, &b, &token); + 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]))) { - float r, g, b; + // transmittance + if ((token[0] == 'K' && token[1] == 't' && IS_SPACE((token[2]))) || + (token[0] == 'T' && token[1] == 'f' && IS_SPACE((token[2])))) { token += 2; - parseFloat3(&r, &g, &b, &token); + 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) */ + // ior(index of refraction) if (token[0] == 'N' && token[1] == 'i' && IS_SPACE((token[2]))) { token += 2; - material.ior = parseFloat(&token); + material.ior = parseReal(&token); continue; } - /* emission */ + // emission if (token[0] == 'K' && token[1] == 'e' && IS_SPACE(token[2])) { - float r, g, b; token += 2; - parseFloat3(&r, &g, &b, &token); + real_t r, g, b; + parseReal3(&r, &g, &b, &token); material.emission[0] = r; material.emission[1] = g; material.emission[2] = b; continue; } - /* shininess */ + // shininess if (token[0] == 'N' && token[1] == 's' && IS_SPACE(token[2])) { token += 2; - material.shininess = parseFloat(&token); + material.shininess = parseReal(&token); continue; } - /* illum model */ + // illum model if (0 == strncmp(token, "illum", 5) && IS_SPACE(token[5])) { token += 6; material.illum = parseInt(&token); continue; } - /* dissolve */ + // dissolve if ((token[0] == 'd' && IS_SPACE(token[1]))) { token += 1; - material.dissolve = parseFloat(&token); + material.dissolve = parseReal(&token); + + if (has_tr) { + warn_ss << "Both `d` and `Tr` parameters defined for \"" + << material.name + << "\". Use the value of `d` for dissolve (line " << line_no + << " in .mtl.)\n"; + } + has_d = true; continue; } if (token[0] == 'T' && token[1] == 'r' && IS_SPACE(token[2])) { token += 2; - /* Invert value of Tr(assume Tr is in range [0, 1]) */ - material.dissolve = 1.0f - parseFloat(&token); + if (has_d) { + // `d` wins. Ignore `Tr` value. + warn_ss << "Both `d` and `Tr` parameters defined for \"" + << material.name + << "\". Use the value of `d` for dissolve (line " << line_no + << " in .mtl.)\n"; + } 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 = static_cast(1.0) - parseReal(&token); + } + has_tr = true; continue; } - /* ambient texture */ + // 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; - material.ambient_texname = my_strdup(token, (size_t) (line_end - token)); + ParseTextureNameAndOption(&(material.ambient_texname), + &(material.ambient_texopt), token); continue; } - /* diffuse texture */ + // diffuse texture if ((0 == strncmp(token, "map_Kd", 6)) && IS_SPACE(token[6])) { token += 7; - material.diffuse_texname = my_strdup(token, (size_t) (line_end - token)); + ParseTextureNameAndOption(&(material.diffuse_texname), + &(material.diffuse_texopt), token); + + // Set a decent diffuse default value if a diffuse texture is specified + // without a matching Kd value. + if (!has_kd) { + material.diffuse[0] = static_cast(0.6); + material.diffuse[1] = static_cast(0.6); + material.diffuse[2] = static_cast(0.6); + } + continue; } - /* specular texture */ + // specular texture if ((0 == strncmp(token, "map_Ks", 6)) && IS_SPACE(token[6])) { token += 7; - material.specular_texname = my_strdup(token, (size_t) (line_end - token)); + ParseTextureNameAndOption(&(material.specular_texname), + &(material.specular_texopt), token); continue; } - /* specular highlight texture */ + // specular highlight texture if ((0 == strncmp(token, "map_Ns", 6)) && IS_SPACE(token[6])) { token += 7; - material.specular_highlight_texname = my_strdup(token, (size_t) (line_end - token)); + ParseTextureNameAndOption(&(material.specular_highlight_texname), + &(material.specular_highlight_texopt), token); continue; } - /* bump texture */ - if ((0 == strncmp(token, "map_bump", 8)) && IS_SPACE(token[8])) { + // bump texture + if (((0 == strncmp(token, "map_bump", 8)) || + (0 == strncmp(token, "map_Bump", 8))) && + IS_SPACE(token[8])) { token += 9; - material.bump_texname = my_strdup(token, (size_t) (line_end - token)); + ParseTextureNameAndOption(&(material.bump_texname), + &(material.bump_texopt), token); continue; } - /* alpha texture */ - if ((0 == strncmp(token, "map_d", 5)) && IS_SPACE(token[5])) { - token += 6; - material.alpha_texname = my_strdup(token, (size_t) (line_end - token)); - continue; - } - - /* bump texture */ + // bump texture if ((0 == strncmp(token, "bump", 4)) && IS_SPACE(token[4])) { token += 5; - material.bump_texname = my_strdup(token, (size_t) (line_end - token)); + ParseTextureNameAndOption(&(material.bump_texname), + &(material.bump_texopt), token); continue; } - /* displacement texture */ + // 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); + continue; + } + + // displacement texture + if (((0 == strncmp(token, "map_disp", 8)) || + (0 == strncmp(token, "map_Disp", 8))) && + IS_SPACE(token[8])) { + token += 9; + ParseTextureNameAndOption(&(material.displacement_texname), + &(material.displacement_texopt), token); + continue; + } + + // displacement texture if ((0 == strncmp(token, "disp", 4)) && IS_SPACE(token[4])) { token += 5; - material.displacement_texname = my_strdup(token, (size_t) (line_end - token)); + ParseTextureNameAndOption(&(material.displacement_texname), + &(material.displacement_texopt), token); continue; } - /* @todo { unknown parameter } */ + // reflection map + if ((0 == strncmp(token, "refl", 4)) && IS_SPACE(token[4])) { + token += 5; + ParseTextureNameAndOption(&(material.reflection_texname), + &(material.reflection_texopt), token); + 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); + 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); + 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); + 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); + 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); + 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(len)); + std::string value = _space + 1; + material.unknown_parameter.insert( + std::pair(key, value)); + } } + // flush last material. + material_map->insert(std::pair( + material.name, static_cast(materials->size()))); + materials->push_back(material); - TINYOBJ_FREE(line_infos); - - if (material.name) { - /* Flush last material element */ - materials = tinyobj_material_add(materials, num_materials, &material); - num_materials++; + if (warning) { + (*warning) = warn_ss.str(); } - - (*num_materials_out) = num_materials; - (*materials_out) = materials; - - return TINYOBJ_SUCCESS; } -int tinyobj_parse_mtl_file(tinyobj_material_t **materials_out, - size_t *num_materials_out, - const char *mtl_filename, const char *obj_filename, file_reader_callback file_reader, - void *ctx) { - return tinyobj_parse_and_index_mtl_file(materials_out, num_materials_out, mtl_filename, obj_filename, file_reader, ctx, NULL); +bool MaterialFileReader::operator()(const std::string &matId, + std::vector *materials, + std::map *matMap, + std::string *warn, std::string *err) { + if (!m_mtlBaseDir.empty()) { +#ifdef _WIN32 + char sep = ';'; +#else + char sep = ':'; +#endif + + // https://stackoverflow.com/questions/5167625/splitting-a-c-stdstring-using-tokens-e-g + std::vector paths; + std::istringstream f(m_mtlBaseDir); + + std::string s; + while (getline(f, s, sep)) { + paths.push_back(s); + } + + for (size_t i = 0; i < paths.size(); i++) { + std::string filepath = JoinPath(paths[i], matId); + + std::ifstream matIStream(filepath.c_str()); + if (matIStream) { + LoadMtl(matMap, materials, &matIStream, warn, err); + + return true; + } + } + + std::stringstream ss; + ss << "Material file [ " << matId + << " ] not found in a path : " << m_mtlBaseDir << "\n"; + if (warn) { + (*warn) += ss.str(); + } + return false; + + } else { + std::string filepath = matId; + std::ifstream matIStream(filepath.c_str()); + if (matIStream) { + LoadMtl(matMap, materials, &matIStream, warn, err); + + return true; + } + + std::stringstream ss; + ss << "Material file [ " << filepath + << " ] not found in a path : " << m_mtlBaseDir << "\n"; + if (warn) { + (*warn) += ss.str(); + } + + return false; + } } - -typedef enum { - COMMAND_EMPTY, - COMMAND_V, - COMMAND_VN, - COMMAND_VT, - COMMAND_F, - COMMAND_G, - COMMAND_O, - COMMAND_USEMTL, - COMMAND_MTLLIB - -} CommandType; - -typedef struct { - float vx, vy, vz; - float nx, ny, nz; - float tx, ty; - - /* @todo { Use dynamic array } */ - tinyobj_vertex_index_t f[TINYOBJ_MAX_FACES_PER_F_LINE]; - size_t num_f; - - int f_num_verts[TINYOBJ_MAX_FACES_PER_F_LINE]; - size_t num_f_num_verts; - - const char *group_name; - unsigned int group_name_len; - int pad0; - - const char *object_name; - unsigned int object_name_len; - int pad1; - - const char *material_name; - unsigned int material_name_len; - int pad2; - - const char *mtllib_name; - unsigned int mtllib_name_len; - - CommandType type; -} Command; - -static int parseLine(Command *command, const char *p, size_t p_len, - int triangulate) { - char linebuf[4096]; - const char *token; - assert(p_len < 4095); - - memcpy(linebuf, p, p_len); - linebuf[p_len] = '\0'; - - token = linebuf; - - command->type = COMMAND_EMPTY; - - /* Skip leading space. */ - skip_space(&token); - - assert(token); - if (token[0] == '\0') { /* empty line */ - return 0; - } - - if (token[0] == '#') { /* comment line */ - return 0; - } - - /* vertex */ - if (token[0] == 'v' && IS_SPACE((token[1]))) { - float x, y, z; - token += 2; - parseFloat3(&x, &y, &z, &token); - command->vx = x; - command->vy = y; - command->vz = z; - command->type = COMMAND_V; - return 1; - } - - /* normal */ - if (token[0] == 'v' && token[1] == 'n' && IS_SPACE((token[2]))) { - float x, y, z; - token += 3; - parseFloat3(&x, &y, &z, &token); - command->nx = x; - command->ny = y; - command->nz = z; - command->type = COMMAND_VN; - return 1; - } - - /* texcoord */ - if (token[0] == 'v' && token[1] == 't' && IS_SPACE((token[2]))) { - float x, y; - token += 3; - parseFloat2(&x, &y, &token); - command->tx = x; - command->ty = y; - command->type = COMMAND_VT; - return 1; - } - - /* face */ - if (token[0] == 'f' && IS_SPACE((token[1]))) { - size_t num_f = 0; - - tinyobj_vertex_index_t f[TINYOBJ_MAX_FACES_PER_F_LINE]; - token += 2; - skip_space(&token); - - while (!IS_NEW_LINE(token[0])) { - tinyobj_vertex_index_t vi = parseRawTriple(&token); - skip_space_and_cr(&token); - - f[num_f] = vi; - num_f++; +bool MaterialStreamReader::operator()(const std::string &matId, + std::vector *materials, + std::map *matMap, + std::string *warn, std::string *err) { + (void)err; + (void)matId; + if (!m_inStream) { + std::stringstream ss; + ss << "Material stream in error state. \n"; + if (warn) { + (*warn) += ss.str(); } - - command->type = COMMAND_F; - - if (triangulate) { - size_t k; - size_t n = 0; - - tinyobj_vertex_index_t i0 = f[0]; - tinyobj_vertex_index_t i1; - tinyobj_vertex_index_t i2 = f[1]; - - assert(3 * num_f < TINYOBJ_MAX_FACES_PER_F_LINE); - - for (k = 2; k < num_f; k++) { - i1 = i2; - i2 = f[k]; - command->f[3 * n + 0] = i0; - command->f[3 * n + 1] = i1; - command->f[3 * n + 2] = i2; - - command->f_num_verts[n] = 3; - n++; - } - command->num_f = 3 * n; - command->num_f_num_verts = n; - - } else { - size_t k = 0; - assert(num_f < TINYOBJ_MAX_FACES_PER_F_LINE); - for (k = 0; k < num_f; k++) { - command->f[k] = f[k]; - } - - command->num_f = num_f; - command->f_num_verts[0] = (int)num_f; - command->num_f_num_verts = 1; - } - - return 1; + return false; } - /* use mtl */ - if ((0 == strncmp(token, "usemtl", 6)) && IS_SPACE((token[6]))) { - token += 7; + LoadMtl(matMap, materials, &m_inStream, warn, err); - skip_space(&token); - command->material_name = p + (token - linebuf); - command->material_name_len = (unsigned int)length_until_newline( - token, (p_len - (size_t)(token - linebuf)) + 1); - command->type = COMMAND_USEMTL; - - return 1; - } - - /* load mtl */ - if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) { - /* By specification, `mtllib` should be appear only once in .obj */ - token += 7; - - skip_space(&token); - command->mtllib_name = p + (token - linebuf); - command->mtllib_name_len = (unsigned int)length_until_newline( - token, p_len - (size_t)(token - linebuf)) + - 1; - command->type = COMMAND_MTLLIB; - - return 1; - } - - /* group name */ - if (token[0] == 'g' && IS_SPACE((token[1]))) { - /* @todo { multiple group name. } */ - token += 2; - - command->group_name = p + (token - linebuf); - command->group_name_len = (unsigned int)length_until_newline( - token, p_len - (size_t)(token - linebuf)) + - 1; - command->type = COMMAND_G; - - return 1; - } - - /* object name */ - if (token[0] == 'o' && IS_SPACE((token[1]))) { - /* @todo { multiple object name? } */ - token += 2; - - command->object_name = p + (token - linebuf); - command->object_name_len = (unsigned int)length_until_newline( - token, p_len - (size_t)(token - linebuf)) + - 1; - command->type = COMMAND_O; - - return 1; - } - - return 0; + return true; } -static size_t basename_len(const char *filename, size_t filename_length) { - /* Count includes NUL terminator. */ - const char *p = &filename[filename_length - 1]; - size_t count = 1; +bool LoadObj(attrib_t *attrib, std::vector *shapes, + std::vector *materials, std::string *warn, + std::string *err, const char *filename, const char *mtl_basedir, + bool triangulate, bool default_vcols_fallback) { + attrib->vertices.clear(); + attrib->normals.clear(); + attrib->texcoords.clear(); + attrib->colors.clear(); + shapes->clear(); - /* On Windows, the directory delimiter is '\' and both it and '/' is - * reserved by the filesystem. On *nix platforms, only the '/' character - * is reserved, so account for the two cases separately. */ - #if _WIN32 - while (p[-1] != '/' && p[-1] != '\\') { - if (p == filename) { - count = filename_length; - return count; - } - count++; - p--; + std::stringstream errss; + + std::ifstream ifs(filename); + if (!ifs) { + errss << "Cannot open file [" << filename << "]\n"; + if (err) { + (*err) = errss.str(); } - p++; - return count; - #else - while (*(--p) != '/') { - if (p == filename) { - count = filename_length; - return count; - } - count++; - } - return count; - #endif + return false; + } + + std::string baseDir = mtl_basedir ? mtl_basedir : ""; + if (!baseDir.empty()) { +#ifndef _WIN32 + const char dirsep = '/'; +#else + const char dirsep = '\\'; +#endif + if (baseDir[baseDir.length() - 1] != dirsep) baseDir += dirsep; + } + MaterialFileReader matFileReader(baseDir); + + return LoadObj(attrib, shapes, materials, warn, err, &ifs, &matFileReader, + triangulate, default_vcols_fallback); } -static char *generate_mtl_filename(const char *obj_filename, - size_t obj_filename_length, - const char *mtllib_name, - size_t mtllib_name_length) { - /* Create a dynamically-allocated material filename. This allows the material - * and obj files to be separated, however the mtllib name in the OBJ file - * must be a relative path to the material file from the OBJ's directory. - * This does not support the matllib name as an absolute address. */ - char *mtl_filename; - char *p; - size_t mtl_filename_length; - size_t obj_basename_length; +bool LoadObj(attrib_t *attrib, std::vector *shapes, + std::vector *materials, std::string *warn, + std::string *err, std::istream *inStream, + MaterialReader *readMatFn /*= NULL*/, bool triangulate, + bool default_vcols_fallback) { + std::stringstream errss; - /* Calculate required size of mtl_filename and allocate */ - obj_basename_length = basename_len(obj_filename, obj_filename_length); - mtl_filename_length = (obj_filename_length - obj_basename_length) + mtllib_name_length; - mtl_filename = (char *)TINYOBJ_MALLOC(mtl_filename_length); + std::vector v; + std::vector vn; + std::vector vt; + std::vector vc; + std::vector vw; + std::vector tags; + PrimGroup prim_group; + std::string name; - /* Copy over the obj's path */ - memcpy(mtl_filename, obj_filename, (obj_filename_length - obj_basename_length)); + // material + std::set material_filenames; + std::map material_map; + int material = -1; - /* Overwrite the obj basename with the mtllib name, filling the string */ - p = &mtl_filename[mtl_filename_length - mtllib_name_length]; - strcpy(p, mtllib_name); - return mtl_filename; -} + // smoothing group id + unsigned int current_smoothing_id = + 0; // Initial value. 0 means no smoothing. -int tinyobj_parse_obj(tinyobj_attrib_t *attrib, tinyobj_shape_t **shapes, - size_t *num_shapes, tinyobj_material_t **materials_out, - size_t *num_materials_out, const char *obj_filename, - file_reader_callback file_reader, void *ctx, - unsigned int flags) { - LineInfo *line_infos = NULL; - Command *commands = NULL; - size_t num_lines = 0; + int greatest_v_idx = -1; + int greatest_vn_idx = -1; + int greatest_vt_idx = -1; - size_t num_v = 0; - size_t num_vn = 0; - size_t num_vt = 0; - size_t num_f = 0; - size_t num_faces = 0; + shape_t shape; - int mtllib_line_index = -1; + bool found_all_colors = true; - tinyobj_material_t *materials = NULL; - size_t num_materials = 0; + size_t line_num = 0; + std::string linebuf; + while (inStream->peek() != -1) { + safeGetline(*inStream, linebuf); - hash_table_t material_table; + line_num++; - char *buf = NULL; - size_t len = 0; - file_reader(ctx, obj_filename, /* is_mtl */0, obj_filename, &buf, &len); + // 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); + } - if (len < 1) return TINYOBJ_ERROR_INVALID_PARAMETER; - if (attrib == NULL) return TINYOBJ_ERROR_INVALID_PARAMETER; - if (shapes == NULL) return TINYOBJ_ERROR_INVALID_PARAMETER; - if (num_shapes == NULL) return TINYOBJ_ERROR_INVALID_PARAMETER; - if (buf == NULL) return TINYOBJ_ERROR_INVALID_PARAMETER; - if (materials_out == NULL) return TINYOBJ_ERROR_INVALID_PARAMETER; - if (num_materials_out == NULL) return TINYOBJ_ERROR_INVALID_PARAMETER; + // Skip if empty line. + if (linebuf.empty()) { + continue; + } - tinyobj_attrib_init(attrib); + // Skip leading space. + const char *token = linebuf.c_str(); + token += strspn(token, " \t"); - /* 1. create line data */ - if (get_line_infos(buf, len, &line_infos, &num_lines) != 0) { - return TINYOBJ_ERROR_EMPTY; - } + assert(token); + if (token[0] == '\0') continue; // empty line - commands = (Command *)TINYOBJ_MALLOC(sizeof(Command) * num_lines); + if (token[0] == '#') continue; // comment line - create_hash_table(HASH_TABLE_DEFAULT_SIZE, &material_table); + // vertex + if (token[0] == 'v' && IS_SPACE((token[1]))) { + token += 2; + real_t x, y, z; + real_t r, g, b; - /* 2. parse each line */ - { - size_t i = 0; - for (i = 0; i < num_lines; i++) { - int ret = parseLine(&commands[i], &buf[line_infos[i].pos], - line_infos[i].len, flags & TINYOBJ_FLAG_TRIANGULATE); - if (ret) { - if (commands[i].type == COMMAND_V) { - num_v++; - } else if (commands[i].type == COMMAND_VN) { - num_vn++; - } else if (commands[i].type == COMMAND_VT) { - num_vt++; - } else if (commands[i].type == COMMAND_F) { - num_f += commands[i].num_f; - num_faces += commands[i].num_f_num_verts; + found_all_colors &= parseVertexWithColor(&x, &y, &z, &r, &g, &b, &token); + + v.push_back(x); + v.push_back(y); + v.push_back(z); + + if (found_all_colors || default_vcols_fallback) { + 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; + } + + // skin weight. tinyobj extension + if (token[0] == 'v' && token[1] == 'w' && IS_SPACE((token[2]))) { + token += 3; + + // vw ... + // example: + // vw 0 0 0.25 1 0.25 2 0.5 + + // TODO(syoyo): Add syntax check + int vid = 0; + vid = parseInt(&token); + + skin_weight_t sw; + + sw.vertex_id = vid; + + while (!IS_NEW_LINE(token[0])) { + real_t j, w; + // joint_id should not be negative, weight may be negative + // TODO(syoyo): # of elements check + parseReal2(&j, &w, &token, -1.0); + + if (j < static_cast(0)) { + if (err) { + std::stringstream ss; + ss << "Failed parse `vw' line. joint_id is negative. " + "line " + << line_num << ".)\n"; + (*err) += ss.str(); + } + return false; } - if (commands[i].type == COMMAND_MTLLIB) { - mtllib_line_index = (int)i; + joint_and_weight_t jw; + + jw.joint_id = int(j); + jw.weight = w; + + sw.weightValues.push_back(jw); + + size_t n = strspn(token, " \t\r"); + token += n; + } + + vw.push_back(sw); + } + + warning_context context; + context.warn = warn; + context.line_number = line_num; + + // line + if (token[0] == 'l' && IS_SPACE((token[1]))) { + token += 2; + + __line_t line; + + while (!IS_NEW_LINE(token[0])) { + vertex_index_t vi; + if (!parseTriple(&token, static_cast(v.size() / 3), + static_cast(vn.size() / 3), + static_cast(vt.size() / 2), &vi, context)) { + if (err) { + (*err) += "Failed to parse `l' line (e.g. a zero value for vertex index. Line " + + toString(line_num) + ").\n"; + } + return false; + } + + line.vertex_indices.push_back(vi); + + size_t n = strspn(token, " \t\r"); + token += n; + } + + prim_group.lineGroup.push_back(line); + + continue; + } + + // points + if (token[0] == 'p' && IS_SPACE((token[1]))) { + token += 2; + + __points_t pts; + + while (!IS_NEW_LINE(token[0])) { + vertex_index_t vi; + if (!parseTriple(&token, static_cast(v.size() / 3), + static_cast(vn.size() / 3), + static_cast(vt.size() / 2), &vi, context)) { + if (err) { + (*err) += "Failed to parse `p' line (e.g. a zero value for vertex index. Line " + + toString(line_num) + ").\n"; + } + return false; + } + + pts.vertex_indices.push_back(vi); + + size_t n = strspn(token, " \t\r"); + token += n; + } + + prim_group.pointsGroup.push_back(pts); + + continue; + } + + // face + if (token[0] == 'f' && IS_SPACE((token[1]))) { + token += 2; + token += strspn(token, " \t"); + + face_t face; + + face.smoothing_group_id = current_smoothing_id; + face.vertex_indices.reserve(3); + + while (!IS_NEW_LINE(token[0])) { + vertex_index_t vi; + if (!parseTriple(&token, static_cast(v.size() / 3), + static_cast(vn.size() / 3), + static_cast(vt.size() / 2), &vi, context)) { + if (err) { + (*err) += "Failed to parse `f' line (e.g. a zero value for vertex index. Line " + + toString(line_num) + ").\n"; + } + return false; + } + + greatest_v_idx = greatest_v_idx > vi.v_idx ? greatest_v_idx : vi.v_idx; + greatest_vn_idx = + greatest_vn_idx > vi.vn_idx ? greatest_vn_idx : vi.vn_idx; + greatest_vt_idx = + greatest_vt_idx > vi.vt_idx ? greatest_vt_idx : vi.vt_idx; + + face.vertex_indices.push_back(vi); + size_t n = strspn(token, " \t\r"); + token += n; + } + + // replace with emplace_back + std::move on C++11 + prim_group.faceGroup.push_back(face); + + continue; + } + + // use mtl + if ((0 == strncmp(token, "usemtl", 6))) { + token += 6; + std::string namebuf = parseString(&token); + + int newMaterialId = -1; + std::map::const_iterator it = + material_map.find(namebuf); + if (it != material_map.end()) { + newMaterialId = it->second; + } else { + // { error!! material not found } + if (warn) { + (*warn) += "material [ '" + namebuf + "' ] not found in .mtl\n"; } } - } - } - /* line_infos are not used anymore. Release memory. */ - if (line_infos) { - TINYOBJ_FREE(line_infos); - } - - /* Load material (if it exists) */ - if (mtllib_line_index >= 0 && commands[mtllib_line_index].mtllib_name && - commands[mtllib_line_index].mtllib_name_len > 0) { - /* Maximum length allowed by Linux - higher than Windows and macOS */ - size_t obj_filename_len = my_strnlen(obj_filename, 4096 + 255) + 1; - char *mtl_filename; - char *mtllib_name; - size_t mtllib_name_len = 0; - int ret; - - mtllib_name_len = length_until_line_feed(commands[mtllib_line_index].mtllib_name, - commands[mtllib_line_index].mtllib_name_len); - - mtllib_name = my_strndup(commands[mtllib_line_index].mtllib_name, - mtllib_name_len); - - /* allow for NUL terminator */ - mtllib_name_len++; - mtl_filename = generate_mtl_filename(obj_filename, obj_filename_len, - mtllib_name, mtllib_name_len); - - ret = tinyobj_parse_and_index_mtl_file(&materials, &num_materials, - mtl_filename, obj_filename, - file_reader, ctx, - &material_table); - - if (ret != TINYOBJ_SUCCESS) { - /* warning. */ - fprintf(stderr, "TINYOBJ: Failed to parse material file '%s': %d\n", mtl_filename, ret); - } - TINYOBJ_FREE(mtl_filename); - TINYOBJ_FREE(mtllib_name); - } - - /* Construct attributes */ - - { - size_t v_count = 0; - size_t n_count = 0; - size_t t_count = 0; - size_t f_count = 0; - size_t face_count = 0; - int material_id = -1; /* -1 = default unknown material. */ - size_t i = 0; - - attrib->vertices = (float *)TINYOBJ_MALLOC(sizeof(float) * num_v * 3); - attrib->num_vertices = (unsigned int)num_v; - attrib->normals = (float *)TINYOBJ_MALLOC(sizeof(float) * num_vn * 3); - attrib->num_normals = (unsigned int)num_vn; - attrib->texcoords = (float *)TINYOBJ_MALLOC(sizeof(float) * num_vt * 2); - attrib->num_texcoords = (unsigned int)num_vt; - attrib->faces = (tinyobj_vertex_index_t *)TINYOBJ_MALLOC( - sizeof(tinyobj_vertex_index_t) * num_f); - attrib->num_faces = (unsigned int)num_f; - attrib->face_num_verts = (int *)TINYOBJ_MALLOC(sizeof(int) * num_faces); - attrib->material_ids = (int *)TINYOBJ_MALLOC(sizeof(int) * num_faces); - attrib->num_face_num_verts = (unsigned int)num_faces; - - for (i = 0; i < num_lines; i++) { - if (commands[i].type == COMMAND_EMPTY) { - continue; - } else if (commands[i].type == COMMAND_USEMTL) { - /* @todo - if (commands[t][i].material_name && - commands[t][i].material_name_len > 0) { - std::string material_name(commands[t][i].material_name, - commands[t][i].material_name_len); - - if (material_map.find(material_name) != material_map.end()) { - material_id = material_map[material_name]; - } else { - // Assign invalid material ID - material_id = -1; - } - } - */ - if (commands[i].material_name && - commands[i].material_name_len >0) - { - /* Create a null terminated string */ - char* material_name_null_term = (char*) TINYOBJ_MALLOC(commands[i].material_name_len + 1); - memcpy((void*) material_name_null_term, (const void*) commands[i].material_name, commands[i].material_name_len); - material_name_null_term[commands[i].material_name_len] = 0; - - if (hash_table_exists(material_name_null_term, &material_table)) - material_id = (int)hash_table_get(material_name_null_term, &material_table); - else - material_id = -1; - - TINYOBJ_FREE(material_name_null_term); - } - } else if (commands[i].type == COMMAND_V) { - attrib->vertices[3 * v_count + 0] = commands[i].vx; - attrib->vertices[3 * v_count + 1] = commands[i].vy; - attrib->vertices[3 * v_count + 2] = commands[i].vz; - v_count++; - } else if (commands[i].type == COMMAND_VN) { - attrib->normals[3 * n_count + 0] = commands[i].nx; - attrib->normals[3 * n_count + 1] = commands[i].ny; - attrib->normals[3 * n_count + 2] = commands[i].nz; - n_count++; - } else if (commands[i].type == COMMAND_VT) { - attrib->texcoords[2 * t_count + 0] = commands[i].tx; - attrib->texcoords[2 * t_count + 1] = commands[i].ty; - t_count++; - } else if (commands[i].type == COMMAND_F) { - size_t k = 0; - for (k = 0; k < commands[i].num_f; k++) { - tinyobj_vertex_index_t vi = commands[i].f[k]; - int v_idx = fixIndex(vi.v_idx, v_count); - int vn_idx = fixIndex(vi.vn_idx, n_count); - int vt_idx = fixIndex(vi.vt_idx, t_count); - attrib->faces[f_count + k].v_idx = v_idx; - attrib->faces[f_count + k].vn_idx = vn_idx; - attrib->faces[f_count + k].vt_idx = vt_idx; - } - - for (k = 0; k < commands[i].num_f_num_verts; k++) { - attrib->material_ids[face_count + k] = material_id; - attrib->face_num_verts[face_count + k] = commands[i].f_num_verts[k]; - } - - f_count += commands[i].num_f; - face_count += commands[i].num_f_num_verts; + if (newMaterialId != material) { + // Create per-face material. Thus we don't add `shape` to `shapes` at + // this time. + // just clear `faceGroup` after `exportGroupsToShape()` call. + exportGroupsToShape(&shape, prim_group, tags, material, name, + triangulate, v, warn); + prim_group.faceGroup.clear(); + material = newMaterialId; } - } - } - /* 5. Construct shape information. */ - { - unsigned int face_count = 0; - size_t i = 0; - size_t n = 0; - size_t shape_idx = 0; - - const char *shape_name = NULL; - unsigned int shape_name_len = 0; - const char *prev_shape_name = NULL; - unsigned int prev_shape_name_len = 0; - unsigned int prev_shape_face_offset = 0; - unsigned int prev_face_offset = 0; - tinyobj_shape_t prev_shape = {NULL, 0, 0}; - - /* Find the number of shapes in .obj */ - for (i = 0; i < num_lines; i++) { - if (commands[i].type == COMMAND_O || commands[i].type == COMMAND_G) { - n++; - } + continue; } - /* Allocate array of shapes with maximum possible size(+1 for unnamed - * group/object). - * Actual # of shapes found in .obj is determined in the later */ - (*shapes) = (tinyobj_shape_t*)TINYOBJ_MALLOC(sizeof(tinyobj_shape_t) * (n + 1)); + // load mtl + if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) { + if (readMatFn) { + token += 7; - for (i = 0; i < num_lines; i++) { - if (commands[i].type == COMMAND_O || commands[i].type == COMMAND_G) { - if (commands[i].type == COMMAND_O) { - shape_name = commands[i].object_name; - shape_name_len = commands[i].object_name_len; + std::vector filenames; + SplitString(std::string(token), ' ', '\\', filenames); + + if (filenames.empty()) { + if (warn) { + std::stringstream ss; + ss << "Looks like empty filename for mtllib. Use default " + "material (line " + << line_num << ".)\n"; + + (*warn) += ss.str(); + } } else { - shape_name = commands[i].group_name; - shape_name_len = commands[i].group_name_len; - } + bool found = false; + for (size_t s = 0; s < filenames.size(); s++) { + if (material_filenames.count(filenames[s]) > 0) { + found = true; + continue; + } - if (face_count == 0) { - /* 'o' or 'g' appears before any 'f' */ - prev_shape_name = shape_name; - prev_shape_name_len = shape_name_len; - prev_shape_face_offset = face_count; - prev_face_offset = face_count; - } else { - if (shape_idx == 0) { - /* 'o' or 'g' after some 'v' lines. */ - (*shapes)[shape_idx].name = my_strndup( - prev_shape_name, prev_shape_name_len); /* may be NULL */ - (*shapes)[shape_idx].face_offset = prev_shape.face_offset; - (*shapes)[shape_idx].length = face_count - prev_face_offset; - shape_idx++; + std::string warn_mtl; + std::string err_mtl; + bool ok = (*readMatFn)(filenames[s].c_str(), materials, + &material_map, &warn_mtl, &err_mtl); + if (warn && (!warn_mtl.empty())) { + (*warn) += warn_mtl; + } - prev_face_offset = face_count; + if (err && (!err_mtl.empty())) { + (*err) += err_mtl; + } - } else { - if ((face_count - prev_face_offset) > 0) { - (*shapes)[shape_idx].name = - my_strndup(prev_shape_name, prev_shape_name_len); - (*shapes)[shape_idx].face_offset = prev_face_offset; - (*shapes)[shape_idx].length = face_count - prev_face_offset; - shape_idx++; - prev_face_offset = face_count; + if (ok) { + found = true; + material_filenames.insert(filenames[s]); + break; } } - /* Record shape info for succeeding 'o' or 'g' command. */ - prev_shape_name = shape_name; - prev_shape_name_len = shape_name_len; - prev_shape_face_offset = face_count; + if (!found) { + if (warn) { + (*warn) += + "Failed to load material file(s). Use default " + "material.\n"; + } + } } } - if (commands[i].type == COMMAND_F) { - face_count++; - } + + continue; } - if ((face_count - prev_face_offset) > 0) { - size_t length = face_count - prev_shape_face_offset; - if (length > 0) { - (*shapes)[shape_idx].name = - my_strndup(prev_shape_name, prev_shape_name_len); - (*shapes)[shape_idx].face_offset = prev_face_offset; - (*shapes)[shape_idx].length = face_count - prev_face_offset; - shape_idx++; + // group name + if (token[0] == 'g' && IS_SPACE((token[1]))) { + // flush previous face group. + bool ret = exportGroupsToShape(&shape, prim_group, tags, material, name, + triangulate, v, warn); + (void)ret; // return value not used. + + if (shape.mesh.indices.size() > 0) { + shapes->push_back(shape); } - } else { - /* Guess no 'v' line occurrence after 'o' or 'g', so discards current - * shape information. */ + + shape = shape_t(); + + // material = -1; + prim_group.clear(); + + std::vector names; + + while (!IS_NEW_LINE(token[0])) { + std::string str = parseString(&token); + names.push_back(str); + token += strspn(token, " \t\r"); // skip tag + } + + // names[0] must be 'g' + + if (names.size() < 2) { + // 'g' with empty names + if (warn) { + std::stringstream ss; + ss << "Empty group name. line: " << line_num << "\n"; + (*warn) += ss.str(); + name = ""; + } + } else { + std::stringstream ss; + ss << names[1]; + + // tinyobjloader does not support multiple groups for a primitive. + // Currently we concatinate multiple group names with a space to get + // single group name. + + for (size_t i = 2; i < names.size(); i++) { + ss << " " << names[i]; + } + + name = ss.str(); + } + + continue; } - (*num_shapes) = shape_idx; + // object name + if (token[0] == 'o' && IS_SPACE((token[1]))) { + // flush previous face group. + bool ret = exportGroupsToShape(&shape, prim_group, tags, material, name, + triangulate, v, warn); + (void)ret; // return value not used. + + if (shape.mesh.indices.size() > 0 || shape.lines.indices.size() > 0 || + shape.points.indices.size() > 0) { + shapes->push_back(shape); + } + + // material = -1; + prim_group.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])) { + const int max_tag_nums = 8192; // FIXME(syoyo): Parameterize. + tag_t tag; + + token += 2; + + tag.name = parseString(&token); + + tag_sizes ts = parseTagTriple(&token); + + if (ts.num_ints < 0) { + ts.num_ints = 0; + } + if (ts.num_ints > max_tag_nums) { + ts.num_ints = max_tag_nums; + } + + if (ts.num_reals < 0) { + ts.num_reals = 0; + } + if (ts.num_reals > max_tag_nums) { + ts.num_reals = max_tag_nums; + } + + if (ts.num_strings < 0) { + ts.num_strings = 0; + } + if (ts.num_strings > max_tag_nums) { + ts.num_strings = max_tag_nums; + } + + tag.intValues.resize(static_cast(ts.num_ints)); + + for (size_t i = 0; i < static_cast(ts.num_ints); ++i) { + tag.intValues[i] = parseInt(&token); + } + + tag.floatValues.resize(static_cast(ts.num_reals)); + for (size_t i = 0; i < static_cast(ts.num_reals); ++i) { + tag.floatValues[i] = parseReal(&token); + } + + tag.stringValues.resize(static_cast(ts.num_strings)); + for (size_t i = 0; i < static_cast(ts.num_strings); ++i) { + tag.stringValues[i] = parseString(&token); + } + + tags.push_back(tag); + + continue; + } + + if (token[0] == 's' && IS_SPACE(token[1])) { + // smoothing group id + token += 2; + + // skip space. + token += strspn(token, " \t"); // skip space + + if (token[0] == '\0') { + continue; + } + + if (token[0] == '\r' || token[1] == '\n') { + continue; + } + + if (strlen(token) >= 3 && token[0] == 'o' && token[1] == 'f' && + token[2] == 'f') { + current_smoothing_id = 0; + } else { + // assume number + int smGroupId = parseInt(&token); + if (smGroupId < 0) { + // parse error. force set to 0. + // FIXME(syoyo): Report warning. + current_smoothing_id = 0; + } else { + current_smoothing_id = static_cast(smGroupId); + } + } + + continue; + } // smoothing group id + + // Ignore unknown command. } - if (commands) { - TINYOBJ_FREE(commands); + // not all vertices have colors, no default colors desired? -> clear colors + if (!found_all_colors && !default_vcols_fallback) { + vc.clear(); } - destroy_hash_table(&material_table); - - (*materials_out) = materials; - (*num_materials_out) = num_materials; - - return TINYOBJ_SUCCESS; -} - -void tinyobj_attrib_init(tinyobj_attrib_t *attrib) { - attrib->vertices = NULL; - attrib->num_vertices = 0; - attrib->normals = NULL; - attrib->num_normals = 0; - attrib->texcoords = NULL; - attrib->num_texcoords = 0; - attrib->faces = NULL; - attrib->num_faces = 0; - attrib->face_num_verts = NULL; - attrib->num_face_num_verts = 0; - attrib->material_ids = NULL; -} - -void tinyobj_attrib_free(tinyobj_attrib_t *attrib) { - if (attrib->vertices) TINYOBJ_FREE(attrib->vertices); - if (attrib->normals) TINYOBJ_FREE(attrib->normals); - if (attrib->texcoords) TINYOBJ_FREE(attrib->texcoords); - if (attrib->faces) TINYOBJ_FREE(attrib->faces); - if (attrib->face_num_verts) TINYOBJ_FREE(attrib->face_num_verts); - if (attrib->material_ids) TINYOBJ_FREE(attrib->material_ids); -} - -void tinyobj_shapes_free(tinyobj_shape_t *shapes, size_t num_shapes) { - size_t i; - if (shapes == NULL) return; - - for (i = 0; i < num_shapes; i++) { - if (shapes[i].name) TINYOBJ_FREE(shapes[i].name); + if (greatest_v_idx >= static_cast(v.size() / 3)) { + if (warn) { + std::stringstream ss; + ss << "Vertex indices out of bounds (line " << line_num << ".)\n\n"; + (*warn) += ss.str(); + } + } + if (greatest_vn_idx >= static_cast(vn.size() / 3)) { + if (warn) { + std::stringstream ss; + ss << "Vertex normal indices out of bounds (line " << line_num << ".)\n\n"; + (*warn) += ss.str(); + } + } + if (greatest_vt_idx >= static_cast(vt.size() / 2)) { + if (warn) { + std::stringstream ss; + ss << "Vertex texcoord indices out of bounds (line " << line_num << ".)\n\n"; + (*warn) += ss.str(); + } } - TINYOBJ_FREE(shapes); -} + bool ret = exportGroupsToShape(&shape, prim_group, tags, material, name, + triangulate, v, warn); + // exportGroupsToShape 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()) { // FIXME(syoyo): Support other prims(e.g. lines) + shapes->push_back(shape); + } + prim_group.clear(); // for safety -void tinyobj_materials_free(tinyobj_material_t *materials, - size_t num_materials) { - size_t i; - if (materials == NULL) return; - - for (i = 0; i < num_materials; i++) { - if (materials[i].name) TINYOBJ_FREE(materials[i].name); - if (materials[i].ambient_texname) TINYOBJ_FREE(materials[i].ambient_texname); - if (materials[i].diffuse_texname) TINYOBJ_FREE(materials[i].diffuse_texname); - if (materials[i].specular_texname) TINYOBJ_FREE(materials[i].specular_texname); - if (materials[i].specular_highlight_texname) - TINYOBJ_FREE(materials[i].specular_highlight_texname); - if (materials[i].bump_texname) TINYOBJ_FREE(materials[i].bump_texname); - if (materials[i].displacement_texname) - TINYOBJ_FREE(materials[i].displacement_texname); - if (materials[i].alpha_texname) TINYOBJ_FREE(materials[i].alpha_texname); + if (err) { + (*err) += errss.str(); } - TINYOBJ_FREE(materials); -} -#endif /* TINYOBJ_LOADER_C_IMPLEMENTATION */ + attrib->vertices.swap(v); + attrib->vertex_weights.swap(v); + attrib->normals.swap(vn); + attrib->texcoords.swap(vt); + attrib->texcoord_ws.swap(vt); + attrib->colors.swap(vc); + attrib->skin_weights.swap(vw); -#endif /* TINOBJ_LOADER_C_H_ */ + return true; +} + +bool LoadObjWithCallback(std::istream &inStream, const callback_t &callback, + void *user_data /*= NULL*/, + MaterialReader *readMatFn /*= NULL*/, + std::string *warn, /* = NULL*/ + std::string *err /*= NULL*/) { + std::stringstream errss; + + // material + std::set material_filenames; + std::map material_map; + int material_id = -1; // -1 = invalid + + std::vector indices; + std::vector materials; + std::vector names; + names.reserve(2); + std::vector 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; + real_t x, y, z; + real_t r, g, b; + + bool found_color = parseVertexWithColor(&x, &y, &z, &r, &g, &b, &token); + if (callback.vertex_cb) { + callback.vertex_cb(user_data, x, y, z, r); // r=w is optional + } + if (callback.vertex_color_cb) { + callback.vertex_color_cb(user_data, x, y, z, r, g, b, found_color); + } + 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_t 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(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; + std::map::const_iterator it = + material_map.find(namebuf); + if (it != material_map.end()) { + newMaterialId = it->second; + } else { + // { warn!! material not found } + if (warn && (!callback.usemtl_cb)) { + (*warn) += "material [ " + namebuf + " ] not found in .mtl\n"; + } + } + + 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 filenames; + SplitString(std::string(token), ' ', '\\', filenames); + + if (filenames.empty()) { + if (warn) { + (*warn) += + "Looks like empty filename for mtllib. Use default " + "material. \n"; + } + } else { + bool found = false; + for (size_t s = 0; s < filenames.size(); s++) { + if (material_filenames.count(filenames[s]) > 0) { + found = true; + continue; + } + + std::string warn_mtl; + std::string err_mtl; + bool ok = (*readMatFn)(filenames[s].c_str(), &materials, + &material_map, &warn_mtl, &err_mtl); + + if (warn && (!warn_mtl.empty())) { + (*warn) += warn_mtl; // This should be warn message. + } + + if (err && (!err_mtl.empty())) { + (*err) += err_mtl; + } + + if (ok) { + found = true; + material_filenames.insert(filenames[s]); + break; + } + } + + if (!found) { + if (warn) { + (*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(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); + + 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(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(ts.num_ints)); + + for (size_t i = 0; i < static_cast(ts.num_ints); ++i) { + tag.intValues[i] = atoi(token); + token += strcspn(token, "/ \t\r") + 1; + } + + tag.floatValues.resize(static_cast(ts.num_reals)); + for (size_t i = 0; i < static_cast(ts.num_reals); ++i) { + tag.floatValues[i] = parseReal(&token); + token += strcspn(token, "/ \t\r") + 1; + } + + tag.stringValues.resize(static_cast(ts.num_strings)); + for (size_t i = 0; i < static_cast(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; +} + +bool ObjReader::ParseFromFile(const std::string &filename, + const ObjReaderConfig &config) { + std::string mtl_search_path; + + if (config.mtl_search_path.empty()) { + // + // split at last '/'(for unixish system) or '\\'(for windows) to get + // the base directory of .obj file + // + size_t pos = filename.find_last_of("/\\"); + if (pos != std::string::npos) { + mtl_search_path = filename.substr(0, pos); + } + } else { + mtl_search_path = config.mtl_search_path; + } + + valid_ = LoadObj(&attrib_, &shapes_, &materials_, &warning_, &error_, + filename.c_str(), mtl_search_path.c_str(), + config.triangulate, config.vertex_color); + + return valid_; +} + +bool ObjReader::ParseFromString(const std::string &obj_text, + const std::string &mtl_text, + const ObjReaderConfig &config) { + std::stringbuf obj_buf(obj_text); + std::stringbuf mtl_buf(mtl_text); + + std::istream obj_ifs(&obj_buf); + std::istream mtl_ifs(&mtl_buf); + + MaterialStreamReader mtl_ss(mtl_ifs); + + valid_ = LoadObj(&attrib_, &shapes_, &materials_, &warning_, &error_, + &obj_ifs, &mtl_ss, config.triangulate, config.vertex_color); + + return valid_; +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif +} // namespace tinyobj + +#endif diff --git a/src/main.cpp b/src/main.cpp index 33a613f..261c21c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -11,12 +11,9 @@ #include #include "lib/loaders/stb_image.h" -#include "gfx/Texture.h" -#include "gfx/Mesh.h" -#include "gfx/Shader.h" -#include "gfx/Color.h" -#include "VoxelSpace.h" -#include "SomaSolve.h" +#include "gfx/main.cpp" +#include "VoxelSpace.cpp" +#include "SomaSolve.cpp" #include "lib/djstdlib/core.cpp" struct Entity; @@ -28,7 +25,7 @@ SceneGraphNode *get_scene_graph_node(int id); int new_graph_node(); void print_mat(glm::mat4* matrix) { - auto mat = *matrix; + glm::mat4 mat = *matrix; std::cout << mat[0][0] << mat[0][1] << mat[0][2] << mat[0][3] << std::endl; std::cout << mat[1][0] << mat[1][1] << mat[1][2] << mat[1][3] << std::endl; std::cout << mat[2][0] << mat[2][1] << mat[2][2] << mat[2][3] << std::endl; @@ -197,9 +194,9 @@ std::vector entities = std::vector(); std::vector scene_graph_nodes = std::vector(); void process_input(GLFWwindow *window) { - static bool wireframe = false; - static bool last_frame_state_press_enter = false; - static bool last_frame_state_press = false; + local_persist bool wireframe = false; + local_persist bool last_frame_state_press_enter = false; + local_persist bool last_frame_state_press = false; if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { glfwSetWindowShouldClose(window, true);