| #include "mesh-util.hh" |
| |
| #include <cassert> |
| #include <fstream> |
| #include <iostream> |
| #include <sstream> |
| |
| // ../common/ |
| #define TINYOBJLOADER_IMPLEMENTATION |
| #include "tiny_obj_loader.h" |
| |
| // Include defines |
| #include "tiny_gltf.h" |
| |
| namespace example { |
| |
| #if 0 |
| static inline int32_t GetComponentSizeInBytes(uint32_t componentType) { |
| if (componentType == TINYGLTF_COMPONENT_TYPE_BYTE) { |
| return 1; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) { |
| return 1; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_SHORT) { |
| return 2; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) { |
| return 2; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_INT) { |
| return 4; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) { |
| return 4; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_FLOAT) { |
| return 4; |
| } else if (componentType == TINYGLTF_COMPONENT_TYPE_DOUBLE) { |
| return 8; |
| } else { |
| // Unknown componenty type |
| return -1; |
| } |
| } |
| #endif |
| |
| static inline int32_t GetNumComponentsInType(uint32_t ty) { |
| if (ty == TINYGLTF_TYPE_SCALAR) { |
| return 1; |
| } else if (ty == TINYGLTF_TYPE_VEC2) { |
| return 2; |
| } else if (ty == TINYGLTF_TYPE_VEC3) { |
| return 3; |
| } else if (ty == TINYGLTF_TYPE_VEC4) { |
| return 4; |
| } else if (ty == TINYGLTF_TYPE_MAT2) { |
| return 4; |
| } else if (ty == TINYGLTF_TYPE_MAT3) { |
| return 9; |
| } else if (ty == TINYGLTF_TYPE_MAT4) { |
| return 16; |
| } else { |
| // Unknown componenty type |
| return -1; |
| } |
| } |
| |
| size_t VertexAttrib::numElements() const { |
| size_t n = GetNumComponentsInType(data_type); |
| |
| return data.size() / n; |
| } |
| |
| // https://stackoverflow.com/questions/8520560/get-a-file-name-from-a-path |
| std::string GetBaseFilename(const std::string &filepath) { |
| return filepath.substr(filepath.find_last_of("/\\") + 1); |
| } |
| |
| template <typename T> |
| std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) { |
| os << "("; |
| for (size_t i = 0; i < v.size(); i++) { |
| os << v[i]; |
| if (i != (v.size() - 1)) { |
| os << ", "; |
| } |
| } |
| os << ")"; |
| |
| return os; |
| } |
| |
| #if 0 |
| static std::string PrintMode(int mode) { |
| if (mode == TINYGLTF_MODE_POINTS) { |
| return "POINTS"; |
| } else if (mode == TINYGLTF_MODE_LINE) { |
| return "LINE"; |
| } else if (mode == TINYGLTF_MODE_LINE_LOOP) { |
| return "LINE_LOOP"; |
| } else if (mode == TINYGLTF_MODE_TRIANGLES) { |
| return "TRIANGLES"; |
| } else if (mode == TINYGLTF_MODE_TRIANGLE_FAN) { |
| return "TRIANGLE_FAN"; |
| } else if (mode == TINYGLTF_MODE_TRIANGLE_STRIP) { |
| return "TRIANGLE_STRIP"; |
| } |
| return "**UNKNOWN**"; |
| } |
| |
| static std::string PrintTarget(int target) { |
| if (target == 34962) { |
| return "GL_ARRAY_BUFFER"; |
| } else if (target == 34963) { |
| return "GL_ELEMENT_ARRAY_BUFFER"; |
| } else { |
| return "**UNKNOWN**"; |
| } |
| } |
| #endif |
| |
| static std::string PrintType(int ty) { |
| if (ty == TINYGLTF_TYPE_SCALAR) { |
| return "SCALAR"; |
| } else if (ty == TINYGLTF_TYPE_VECTOR) { |
| return "VECTOR"; |
| } else if (ty == TINYGLTF_TYPE_VEC2) { |
| return "VEC2"; |
| } else if (ty == TINYGLTF_TYPE_VEC3) { |
| return "VEC3"; |
| } else if (ty == TINYGLTF_TYPE_VEC4) { |
| return "VEC4"; |
| } else if (ty == TINYGLTF_TYPE_MATRIX) { |
| return "MATRIX"; |
| } else if (ty == TINYGLTF_TYPE_MAT2) { |
| return "MAT2"; |
| } else if (ty == TINYGLTF_TYPE_MAT3) { |
| return "MAT3"; |
| } else if (ty == TINYGLTF_TYPE_MAT4) { |
| return "MAT4"; |
| } |
| return "**UNKNOWN**"; |
| } |
| |
| static std::string PrintComponentType(int ty) { |
| if (ty == TINYGLTF_COMPONENT_TYPE_BYTE) { |
| return "BYTE"; |
| } else if (ty == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) { |
| return "UNSIGNED_BYTE"; |
| } else if (ty == TINYGLTF_COMPONENT_TYPE_SHORT) { |
| return "SHORT"; |
| } else if (ty == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) { |
| return "UNSIGNED_SHORT"; |
| } else if (ty == TINYGLTF_COMPONENT_TYPE_INT) { |
| return "INT"; |
| } else if (ty == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) { |
| return "UNSIGNED_INT"; |
| } else if (ty == TINYGLTF_COMPONENT_TYPE_FLOAT) { |
| return "FLOAT"; |
| } else if (ty == TINYGLTF_COMPONENT_TYPE_DOUBLE) { |
| return "DOUBLE"; |
| } |
| |
| return "**UNKNOWN**"; |
| } |
| |
| // TODO(syoyo): Specify CCW(Counter-ClockWise) or CW(ClockWise) |
| static void CalcNormal(float N[3], float v0[3], float v1[3], float v2[3]) { |
| float v10[3]; |
| v10[0] = v1[0] - v0[0]; |
| v10[1] = v1[1] - v0[1]; |
| v10[2] = v1[2] - v0[2]; |
| |
| float v20[3]; |
| v20[0] = v2[0] - v0[0]; |
| v20[1] = v2[1] - v0[1]; |
| v20[2] = v2[2] - v0[2]; |
| |
| N[0] = v20[1] * v10[2] - v20[2] * v10[1]; |
| N[1] = v20[2] * v10[0] - v20[0] * v10[2]; |
| N[2] = v20[0] * v10[1] - v20[1] * v10[0]; |
| |
| float len2 = N[0] * N[0] + N[1] * N[1] + N[2] * N[2]; |
| if (len2 > 0.0f) { |
| float len = sqrtf(len2); |
| |
| N[0] /= len; |
| N[1] /= len; |
| N[2] /= len; |
| } |
| } |
| |
| static std::string make_triple(int i, bool has_vn, bool has_vt) { |
| std::stringstream ss; |
| |
| if (has_vn && has_vt) { |
| ss << i << "/" << i << "/" << i; |
| } else if (has_vn) { |
| ss << i << "//" << i; |
| } else if (has_vt) { |
| ss << i << "/" << i; |
| } else { |
| ss << i; |
| } |
| |
| return ss.str(); |
| } |
| |
| namespace { |
| |
| tinygltf::Accessor ConvertToGLTFAccessor(const VertexAttrib &attrib, |
| int bufferView, size_t byteOffset) { |
| tinygltf::Accessor accessor; |
| |
| accessor.bufferView = bufferView; |
| accessor.name = attrib.name; |
| accessor.byteOffset = byteOffset; |
| accessor.componentType = attrib.component_type; |
| accessor.count = attrib.numElements(); |
| accessor.type = attrib.data_type; |
| accessor.minValues = attrib.minValues; |
| accessor.maxValues = attrib.maxValues; |
| |
| return accessor; |
| } |
| |
| // data is appended to `buf` |
| bool SerializeVertexAttribToBuffer(const VertexAttrib &attrib, |
| std::vector<uint8_t> *buf, size_t *begin_loc, |
| size_t *end_loc) { |
| (*begin_loc) = buf->size(); |
| |
| if (attrib.component_type == TINYGLTF_COMPONENT_TYPE_BYTE) { |
| for (size_t i = 0; i < attrib.data.size(); i++) { |
| int8_t d = static_cast<int8_t>(attrib.data[i]); |
| buf->push_back(static_cast<uint8_t>(d)); |
| } |
| } else if (attrib.component_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) { |
| for (size_t i = 0; i < attrib.data.size(); i++) { |
| uint8_t d = static_cast<uint8_t>(attrib.data[i]); |
| buf->push_back(d); |
| } |
| } else if (attrib.component_type == TINYGLTF_COMPONENT_TYPE_SHORT) { |
| for (size_t i = 0; i < attrib.data.size(); i++) { |
| int16_t d = static_cast<int16_t>(attrib.data[i]); |
| uint8_t *ptr = reinterpret_cast<uint8_t *>(&d); |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| } |
| } else if (attrib.component_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) { |
| for (size_t i = 0; i < attrib.data.size(); i++) { |
| uint16_t d = static_cast<uint16_t>(attrib.data[i]); |
| uint8_t *ptr = reinterpret_cast<uint8_t *>(&d); |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| } |
| } else if (attrib.component_type == TINYGLTF_COMPONENT_TYPE_INT) { |
| for (size_t i = 0; i < attrib.data.size(); i++) { |
| int32_t d = static_cast<int32_t>(attrib.data[i]); |
| uint8_t *ptr = reinterpret_cast<uint8_t *>(&d); |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| } |
| } else if (attrib.component_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) { |
| for (size_t i = 0; i < attrib.data.size(); i++) { |
| uint32_t d = static_cast<uint32_t>(attrib.data[i]); |
| uint8_t *ptr = reinterpret_cast<uint8_t *>(&d); |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| } |
| } else if (attrib.component_type == TINYGLTF_COMPONENT_TYPE_FLOAT) { |
| for (size_t i = 0; i < attrib.data.size(); i++) { |
| float d = attrib.data[i]; |
| uint8_t *ptr = reinterpret_cast<uint8_t *>(&d); |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| } |
| } else { |
| std::cerr << "Unsupported component type: " |
| << PrintComponentType(attrib.component_type) << "\n"; |
| return false; |
| } |
| |
| (*end_loc) = buf->size(); |
| |
| return true; |
| } |
| |
| // data is appended to `buf` |
| bool SerializeVertexIndicesToBuffer(const std::vector<uint32_t> &indices, |
| int data_type, std::vector<uint8_t> *buf, |
| size_t *begin_loc, size_t *end_loc) { |
| // TODO(syoyo): Check alignment |
| |
| (*begin_loc) = buf->size(); |
| |
| if (data_type == TINYGLTF_COMPONENT_TYPE_BYTE) { |
| for (size_t i = 0; i < indices.size(); i++) { |
| int8_t d = static_cast<int8_t>(indices[i]); |
| buf->push_back(static_cast<uint8_t>(d)); |
| } |
| } else if (data_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) { |
| for (size_t i = 0; i < indices.size(); i++) { |
| uint8_t d = static_cast<uint8_t>(indices[i]); |
| buf->push_back(d); |
| } |
| } else if (data_type == TINYGLTF_COMPONENT_TYPE_SHORT) { |
| for (size_t i = 0; i < indices.size(); i++) { |
| int16_t d = static_cast<int16_t>(indices[i]); |
| uint8_t *ptr = reinterpret_cast<uint8_t *>(&d); |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| } |
| } else if (data_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) { |
| for (size_t i = 0; i < indices.size(); i++) { |
| uint16_t d = static_cast<uint16_t>(indices[i]); |
| uint8_t *ptr = reinterpret_cast<uint8_t *>(&d); |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| } |
| } else if (data_type == TINYGLTF_COMPONENT_TYPE_INT) { |
| for (size_t i = 0; i < indices.size(); i++) { |
| int32_t d = static_cast<int32_t>(indices[i]); |
| uint8_t *ptr = reinterpret_cast<uint8_t *>(&d); |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| } |
| } else if (data_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) { |
| for (size_t i = 0; i < indices.size(); i++) { |
| uint32_t d = static_cast<uint32_t>(indices[i]); |
| uint8_t *ptr = reinterpret_cast<uint8_t *>(&d); |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| ptr++; |
| buf->push_back(*ptr); |
| } |
| } else { |
| std::cerr << "Unsupported data type: " << PrintType(data_type) << "\n"; |
| return false; |
| } |
| |
| (*end_loc) = buf->size(); |
| |
| return true; |
| } |
| |
| bool ConvertToGLTFMesh(const MeshPrim &mesh, int buffer_id, |
| tinygltf::Mesh *gltfmesh, |
| std::vector<tinygltf::Accessor> *accessors, |
| std::vector<tinygltf::BufferView> *bufferViews, |
| tinygltf::Buffer *buffer) { |
| std::vector<uint8_t> buf; |
| |
| // single primitive per mesh |
| tinygltf::Primitive primitive; |
| |
| // vertex index |
| { |
| size_t s, e; |
| if (!SerializeVertexIndicesToBuffer(mesh.indices, mesh.indices_type, &buf, |
| &s, &e)) { |
| return false; |
| } |
| std::cout << "indices: [" << s << ", " << e << "]\n"; |
| |
| tinygltf::BufferView bufferView; |
| bufferView.buffer = buffer_id; |
| bufferView.byteLength = e - s; |
| bufferView.byteOffset = s; |
| bufferView.target = TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER; |
| bufferViews->push_back(bufferView); |
| |
| tinygltf::Accessor accessor; |
| accessor.bufferView = bufferViews->size() - 1; |
| accessor.minValues.resize(1); |
| accessor.minValues[0] = mesh.indices_min; |
| accessor.maxValues.resize(1); |
| accessor.maxValues[0] = mesh.indices_max; |
| accessor.count = mesh.indices.size(); |
| accessor.componentType = mesh.indices_type; |
| accessor.type = TINYGLTF_TYPE_SCALAR; |
| accessors->push_back(accessor); |
| |
| primitive.indices = accessors->size() - 1; |
| } |
| |
| // position |
| { |
| size_t s, e; |
| if (!SerializeVertexAttribToBuffer(mesh.position, &buf, &s, &e)) { |
| return false; |
| } |
| std::cout << "postion.byteRange: [" << s << ", " << e << "]\n"; |
| |
| tinygltf::BufferView bufferView; |
| bufferView.buffer = buffer_id; |
| bufferView.byteLength = e - s; |
| bufferView.byteOffset = s; |
| bufferView.target = TINYGLTF_TARGET_ARRAY_BUFFER; |
| bufferViews->push_back(bufferView); |
| |
| tinygltf::Accessor accessor = ConvertToGLTFAccessor( |
| mesh.position, bufferViews->size() - 1, /* offset */ 0); |
| accessors->push_back(accessor); |
| |
| primitive.attributes["POSITION"] = accessors->size() - 1; |
| } |
| |
| if (mesh.normal.data.size() > 0) { |
| size_t s, e; |
| if (!SerializeVertexAttribToBuffer(mesh.normal, &buf, &s, &e)) { |
| return false; |
| } |
| std::cout << "normal.byteRange: [" << s << ", " << e << "]\n"; |
| |
| tinygltf::BufferView bufferView; |
| bufferView.buffer = buffer_id; |
| bufferView.byteLength = e - s; |
| bufferView.byteOffset = s; |
| bufferView.target = TINYGLTF_TARGET_ARRAY_BUFFER; |
| bufferViews->push_back(bufferView); |
| |
| tinygltf::Accessor accessor = ConvertToGLTFAccessor( |
| mesh.normal, bufferViews->size() - 1, /* offset */ 0); |
| accessors->push_back(accessor); |
| |
| primitive.attributes["NORMAL"] = accessors->size() - 1; |
| } |
| |
| if (mesh.tangent.data.size() > 0) { |
| size_t s, e; |
| if (!SerializeVertexAttribToBuffer(mesh.tangent, &buf, &s, &e)) { |
| return false; |
| } |
| std::cout << "tangent.byteRange: [" << s << ", " << e << "]\n"; |
| |
| tinygltf::BufferView bufferView; |
| bufferView.buffer = buffer_id; |
| bufferView.byteLength = e - s; |
| bufferView.byteOffset = s; |
| bufferView.target = TINYGLTF_TARGET_ARRAY_BUFFER; |
| bufferViews->push_back(bufferView); |
| |
| tinygltf::Accessor accessor = ConvertToGLTFAccessor( |
| mesh.tangent, bufferViews->size() - 1, /* offset */ 0); |
| accessors->push_back(accessor); |
| |
| primitive.attributes["TANGENT"] = accessors->size() - 1; |
| } |
| |
| if (mesh.texcoords.size() > 0) { |
| for (const auto &item : mesh.texcoords) { |
| size_t s, e; |
| if (!SerializeVertexAttribToBuffer(item.second, &buf, &s, &e)) { |
| return false; |
| } |
| std::cout << "tangent.byteRange: [" << s << ", " << e << "]\n"; |
| |
| tinygltf::BufferView bufferView; |
| bufferView.buffer = buffer_id; |
| bufferView.byteLength = e - s; |
| bufferView.byteOffset = s; |
| bufferView.target = TINYGLTF_TARGET_ARRAY_BUFFER; |
| bufferViews->push_back(bufferView); |
| |
| tinygltf::Accessor accessor = ConvertToGLTFAccessor( |
| item.second, bufferViews->size() - 1, /* offset */ 0); |
| accessors->push_back(accessor); |
| |
| std::string target = "TEXCOORD_" + std::to_string(item.first); |
| primitive.attributes[target] = accessors->size() - 1; |
| } |
| } |
| |
| if (mesh.joints.size() > 0) { |
| for (const auto &item : mesh.joints) { |
| size_t s, e; |
| if (!SerializeVertexAttribToBuffer(item.second, &buf, &s, &e)) { |
| return false; |
| } |
| std::cout << "joint[" << item.first << "].byteRange: [" << s << ", " << e |
| << "]\n"; |
| |
| tinygltf::BufferView bufferView; |
| bufferView.buffer = buffer_id; |
| bufferView.byteLength = e - s; |
| bufferView.byteOffset = s; |
| bufferView.target = TINYGLTF_TARGET_ARRAY_BUFFER; |
| bufferViews->push_back(bufferView); |
| |
| tinygltf::Accessor accessor = ConvertToGLTFAccessor( |
| mesh.tangent, bufferViews->size() - 1, /* offset */ 0); |
| accessors->push_back(accessor); |
| |
| std::string target = "JOINTS_" + std::to_string(item.first); |
| primitive.attributes[target] = accessors->size() - 1; |
| } |
| } |
| |
| if (mesh.weights.size() > 0) { |
| for (const auto &item : mesh.weights) { |
| size_t s, e; |
| if (!SerializeVertexAttribToBuffer(item.second, &buf, &s, &e)) { |
| return false; |
| } |
| std::cout << "weight[" << item.first << "].byteRange: [" << s << ", " << e |
| << "]\n"; |
| |
| tinygltf::BufferView bufferView; |
| bufferView.buffer = buffer_id; |
| bufferView.byteLength = e - s; |
| bufferView.byteOffset = s; |
| bufferView.target = TINYGLTF_TARGET_ARRAY_BUFFER; |
| bufferViews->push_back(bufferView); |
| |
| tinygltf::Accessor accessor = ConvertToGLTFAccessor( |
| mesh.tangent, bufferViews->size() - 1, /* offset */ 0); |
| accessors->push_back(accessor); |
| |
| std::string target = "WEIGHTS_" + std::to_string(item.first); |
| primitive.attributes[target] = accessors->size() - 1; |
| } |
| } |
| |
| primitive.mode = mesh.mode; |
| |
| gltfmesh->primitives.push_back(primitive); |
| |
| buffer->data = buf; |
| buffer->name = "bufffer0"; // temporary |
| |
| return true; |
| } |
| |
| } // namespace |
| |
| bool SaveAsObjMesh(const std::string &filename, const MeshPrim &mesh, |
| bool flip_texcoord_y) { |
| std::ofstream ofs(filename); |
| if (!ofs) { |
| std::cerr << "Failed to open .obj to write: " << filename << "\n"; |
| return false; |
| } |
| |
| bool has_vn = false; |
| bool has_vt = false; |
| |
| has_vn = mesh.normal.data.size() == mesh.position.data.size(); |
| has_vt = mesh.texcoords.count(0) && |
| (mesh.texcoords.at(0).data.size() > 0); // TEXCOORD_0 |
| |
| // v |
| for (size_t i = 0; i < mesh.position.data.size() / 3; i++) { |
| ofs << "v " << mesh.position.data[3 * i + 0] << " " |
| << mesh.position.data[3 * i + 1] << " " << mesh.position.data[3 * i + 2] |
| << "\n"; |
| } |
| |
| // vn |
| for (size_t i = 0; i < mesh.normal.data.size() / 3; i++) { |
| ofs << "vn " << mesh.normal.data[3 * i + 0] << " " |
| << mesh.normal.data[3 * i + 1] << " " << mesh.normal.data[3 * i + 2] |
| << "\n"; |
| } |
| |
| assert((mesh.texcoords.at(0).data.size() / 2) == |
| (mesh.position.data.size() / 3)); |
| |
| // vt |
| for (size_t i = 0; i < mesh.texcoords.at(0).data.size() / 2; i++) { |
| float y = mesh.texcoords.at(0).data[2 * i + 1]; |
| if (flip_texcoord_y) { |
| y = 1.0f - y; |
| } |
| ofs << "vt " << mesh.texcoords.at(0).data[2 * i + 0] << " " << y << "\n"; |
| } |
| |
| // v, vn, vt has same index |
| for (size_t i = 0; i < mesh.indices.size() / 3; i++) { |
| // .obj's index start with 1. |
| int f0 = int(mesh.indices[3 * i + 0]) + 1; |
| int f1 = int(mesh.indices[3 * i + 1]) + 1; |
| int f2 = int(mesh.indices[3 * i + 2]) + 1; |
| |
| ofs << "f " << make_triple(f0, has_vn, has_vt) << " " |
| << make_triple(f1, has_vn, has_vt) << " " |
| << make_triple(f2, has_vn, has_vt) << "\n"; |
| } |
| |
| // TODO(syoyo): Write joints/weights |
| |
| return true; |
| } |
| |
| bool SaveAsGLTFMesh(const std::string &filename, const MeshPrim &mesh) { |
| tinygltf::TinyGLTF ctx; |
| tinygltf::Model model; |
| |
| bool embedImages = false; |
| bool embedBuffers = false; |
| bool prettyPrint = true; |
| bool writeBinary = false; |
| |
| // Create dummy node |
| tinygltf::Node node; |
| node.mesh = 0; |
| node.name = "mesh"; |
| |
| tinygltf::Scene scene; |
| scene.nodes.push_back(0); |
| |
| model.defaultScene = 0; |
| model.scenes.push_back(scene); |
| model.nodes.push_back(node); |
| |
| int buffer_id = 0; |
| tinygltf::Mesh gltfmesh; |
| tinygltf::Buffer buffer; |
| if (!ConvertToGLTFMesh(mesh, buffer_id, &gltfmesh, &(model.accessors), |
| &(model.bufferViews), &buffer)) { |
| std::cerr << "Failed to convert Mesh\n"; |
| return false; |
| } |
| |
| std::cout << "mesh.name: " << mesh.name << "\n"; |
| gltfmesh.name = mesh.name; |
| |
| model.meshes.push_back(gltfmesh); |
| |
| model.buffers.push_back(buffer); |
| |
| // Fill some required fields |
| tinygltf::Asset asset; |
| asset.version = "2.0"; // required |
| asset.generator = "mesh-modify"; |
| |
| model.asset = asset; |
| |
| bool ret = ctx.WriteGltfSceneToFile(&model, filename, embedImages, |
| embedBuffers, prettyPrint, writeBinary); |
| |
| return ret; |
| } |
| |
| bool RequireFacevaringLayout(const tinyobj::attrib_t &attrib, |
| const std::vector<tinyobj::shape_t> &shapes) { |
| // Check if all normals and texcoords has same index with vertex |
| if ((attrib.texcoords.size() / 2) != attrib.vertices.size() / 3) { |
| std::cerr << "Texcoords and Vertices length mismatch. Mesh data cannot be " |
| "represented as non-facevarying. texcoords.size = " |
| << (attrib.texcoords.size() / 2) |
| << ", vertices.size = " << (attrib.vertices.size() / 3) << "\n"; |
| return true; |
| } |
| if ((attrib.normals.size() / 3) != attrib.vertices.size() / 3) { |
| std::cerr << "Normals and Vertices length mismatch. Mesh data cannot be " |
| "represented as non-facevarying. normals.size = " |
| << (attrib.normals.size() / 3) |
| << ", vertices.szie = " << (attrib.vertices.size() / 3) << "\n"; |
| return true; |
| } |
| |
| // Check indices. |
| for (size_t s = 0; s < shapes.size(); s++) { |
| const tinyobj::shape_t &shape = shapes[s]; |
| |
| for (size_t f = 0; f < shape.mesh.indices.size() / 3; f++) { |
| tinyobj::index_t idx0 = shape.mesh.indices[3 * f + 0]; |
| tinyobj::index_t idx1 = shape.mesh.indices[3 * f + 1]; |
| tinyobj::index_t idx2 = shape.mesh.indices[3 * f + 2]; |
| |
| // index must be all same |
| if ((idx0.vertex_index != idx0.normal_index) || |
| (idx0.vertex_index != idx0.texcoord_index)) { |
| return true; |
| } |
| |
| if ((idx1.vertex_index != idx1.normal_index) || |
| (idx1.vertex_index != idx1.texcoord_index)) { |
| return true; |
| } |
| |
| if ((idx2.vertex_index != idx2.normal_index) || |
| (idx2.vertex_index != idx2.texcoord_index)) { |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| static void ConstructVertexSkinWeight( |
| const std::vector<tinyobj::real_t> &vertices, |
| const std::vector<tinyobj::skin_weight_t> &skin_weights, |
| std::vector<tinyobj::skin_weight_t> *vertex_skin_weights) { |
| size_t num_vertices = vertices.size() / 3; |
| |
| vertex_skin_weights->resize(num_vertices); |
| |
| for (size_t i = 0; i < skin_weights.size(); i++) { |
| const tinyobj::skin_weight_t &skin = skin_weights[i]; |
| |
| assert(skin.vertex_id >= 0); |
| assert(skin.vertex_id < num_vertices); |
| |
| (*vertex_skin_weights)[skin.vertex_id] = skin; |
| } |
| |
| // now you can lookup i'th vertex skin weight by `vertex_skin_weights[i]` |
| } |
| |
| bool LoadObjMesh(const std::string &filename, bool facevarying, |
| MeshPrim *mesh) { |
| tinyobj::attrib_t attrib; |
| std::vector<tinyobj::shape_t> shapes; |
| std::vector<tinyobj::material_t> materials; |
| |
| std::string warn; |
| std::string err; |
| bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, |
| filename.c_str(), /* base_path */ nullptr, |
| /* triangulate */ true); |
| if (!warn.empty()) { |
| std::cout << "WARN: " << warn << std::endl; |
| } |
| |
| if (!err.empty()) { |
| std::cerr << "ERR: " << err << std::endl; |
| } |
| |
| if (!ret) { |
| std::cerr << "Failed to load wavefront .obj\n"; |
| return false; |
| } |
| |
| if (!facevarying) { |
| // TODO(syoyo): Allow per-shape non-facevarying layout |
| facevarying = RequireFacevaringLayout(attrib, shapes); |
| } |
| |
| bool has_texcoord = (attrib.texcoords.size() > 0); |
| bool has_normal = (attrib.normals.size() > 0); |
| |
| float bmin[3]; |
| float bmax[3]; |
| bmin[0] = bmin[1] = bmin[2] = std::numeric_limits<float>::max(); |
| bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits<float>::max(); |
| |
| // reorder texcoords and normals so that it has same indexing to vertices. |
| if (facevarying) { |
| mesh->position.data.clear(); |
| mesh->normal.data.clear(); |
| mesh->tangent.data.clear(); |
| mesh->texcoords[0] = VertexAttrib(); |
| |
| // Concat shapes |
| for (size_t s = 0; s < shapes.size(); s++) { |
| const tinyobj::shape_t &shape = shapes[s]; |
| |
| for (size_t f = 0; f < shape.mesh.indices.size() / 3; f++) { |
| tinyobj::index_t idx0 = shape.mesh.indices[3 * f + 0]; |
| tinyobj::index_t idx1 = shape.mesh.indices[3 * f + 1]; |
| tinyobj::index_t idx2 = shape.mesh.indices[3 * f + 2]; |
| |
| float tc[3][2]; |
| if (has_texcoord) { |
| if ((idx0.texcoord_index < 0) || (idx1.texcoord_index < 0) || |
| (idx2.texcoord_index < 0)) { |
| // This face does contain valid texcoord |
| tc[0][0] = 0.0f; |
| tc[0][1] = 0.0f; |
| tc[1][0] = 0.0f; |
| tc[1][1] = 0.0f; |
| tc[2][0] = 0.0f; |
| tc[2][1] = 0.0f; |
| } else { |
| assert(attrib.texcoords.size() > |
| size_t(2 * idx0.texcoord_index + 1)); |
| assert(attrib.texcoords.size() > |
| size_t(2 * idx1.texcoord_index + 1)); |
| assert(attrib.texcoords.size() > |
| size_t(2 * idx2.texcoord_index + 1)); |
| |
| // Flip Y coord. |
| tc[0][0] = attrib.texcoords[2 * idx0.texcoord_index]; |
| tc[0][1] = 1.0f - attrib.texcoords[2 * idx0.texcoord_index + 1]; |
| tc[1][0] = attrib.texcoords[2 * idx1.texcoord_index]; |
| tc[1][1] = 1.0f - attrib.texcoords[2 * idx1.texcoord_index + 1]; |
| tc[2][0] = attrib.texcoords[2 * idx2.texcoord_index]; |
| tc[2][1] = 1.0f - attrib.texcoords[2 * idx2.texcoord_index + 1]; |
| } |
| } else { |
| tc[0][0] = 0.0f; |
| tc[0][1] = 0.0f; |
| tc[1][0] = 0.0f; |
| tc[1][1] = 0.0f; |
| tc[2][0] = 0.0f; |
| tc[2][1] = 0.0f; |
| } |
| |
| float v[3][3]; |
| for (int k = 0; k < 3; k++) { |
| int f0 = idx0.vertex_index; |
| int f1 = idx1.vertex_index; |
| int f2 = idx2.vertex_index; |
| assert(f0 >= 0); |
| assert(f1 >= 0); |
| assert(f2 >= 0); |
| |
| v[0][k] = attrib.vertices[3 * f0 + k]; |
| v[1][k] = attrib.vertices[3 * f1 + k]; |
| v[2][k] = attrib.vertices[3 * f2 + k]; |
| bmin[k] = std::min(v[0][k], bmin[k]); |
| bmin[k] = std::min(v[1][k], bmin[k]); |
| bmin[k] = std::min(v[2][k], bmin[k]); |
| bmax[k] = std::max(v[0][k], bmax[k]); |
| bmax[k] = std::max(v[1][k], bmax[k]); |
| bmax[k] = std::max(v[2][k], bmax[k]); |
| } |
| |
| float n[3][3]; |
| if (has_normal) { |
| if ((idx0.normal_index < 0) || (idx1.normal_index < 0) || |
| (idx2.normal_index < 0)) { |
| // This face does contain valid normal |
| // Calc geometric normal |
| CalcNormal(n[0], v[0], v[1], v[2]); |
| n[1][0] = n[0][0]; |
| n[1][1] = n[0][1]; |
| n[1][2] = n[0][2]; |
| |
| n[2][0] = n[0][0]; |
| n[2][1] = n[0][1]; |
| n[2][2] = n[0][2]; |
| |
| } else { |
| int nf0 = idx0.normal_index; |
| int nf1 = idx1.normal_index; |
| int nf2 = idx2.normal_index; |
| |
| for (int k = 0; k < 3; k++) { |
| assert(size_t(3 * nf0 + k) < attrib.normals.size()); |
| assert(size_t(3 * nf1 + k) < attrib.normals.size()); |
| assert(size_t(3 * nf2 + k) < attrib.normals.size()); |
| n[0][k] = attrib.normals[3 * nf0 + k]; |
| n[1][k] = attrib.normals[3 * nf1 + k]; |
| n[2][k] = attrib.normals[3 * nf2 + k]; |
| } |
| } |
| } else { |
| // Calc geometric normal |
| CalcNormal(n[0], v[0], v[1], v[2]); |
| n[1][0] = n[0][0]; |
| n[1][1] = n[0][1]; |
| n[1][2] = n[0][2]; |
| |
| n[2][0] = n[0][0]; |
| n[2][1] = n[0][1]; |
| n[2][2] = n[0][2]; |
| } |
| |
| mesh->position.data.push_back(v[0][0]); |
| mesh->position.data.push_back(v[0][1]); |
| mesh->position.data.push_back(v[0][2]); |
| |
| mesh->position.data.push_back(v[1][0]); |
| mesh->position.data.push_back(v[1][1]); |
| mesh->position.data.push_back(v[1][2]); |
| |
| mesh->position.data.push_back(v[2][0]); |
| mesh->position.data.push_back(v[2][1]); |
| mesh->position.data.push_back(v[2][2]); |
| |
| mesh->normal.data.push_back(n[0][0]); |
| mesh->normal.data.push_back(n[0][1]); |
| mesh->normal.data.push_back(n[0][2]); |
| |
| mesh->normal.data.push_back(n[1][0]); |
| mesh->normal.data.push_back(n[1][1]); |
| mesh->normal.data.push_back(n[1][2]); |
| |
| mesh->normal.data.push_back(n[2][0]); |
| mesh->normal.data.push_back(n[2][1]); |
| mesh->normal.data.push_back(n[2][2]); |
| |
| mesh->texcoords[0].data.push_back(tc[0][0]); |
| mesh->texcoords[0].data.push_back(tc[0][1]); |
| |
| mesh->texcoords[0].data.push_back(tc[1][0]); |
| mesh->texcoords[0].data.push_back(tc[1][1]); |
| |
| mesh->texcoords[0].data.push_back(tc[2][0]); |
| mesh->texcoords[0].data.push_back(tc[2][1]); |
| |
| size_t idx = mesh->indices.size(); |
| mesh->indices.push_back(int(idx) + 0); |
| mesh->indices.push_back(int(idx) + 1); |
| mesh->indices.push_back(int(idx) + 2); |
| } |
| } |
| |
| // weights/joints |
| if (attrib.skin_weights.size() > 0) { |
| // Reorder vertex skin weights |
| std::vector<tinyobj::skin_weight_t> vertex_skin_weights; |
| ConstructVertexSkinWeight(attrib.vertices, attrib.skin_weights, |
| &vertex_skin_weights); |
| |
| // Find max # of slots. |
| size_t maxn = 0; |
| for (size_t i = 0; i < vertex_skin_weights.size(); i++) { |
| maxn = std::max(vertex_skin_weights[i].weightValues.size(), maxn); |
| } |
| |
| int num_slots = 0; |
| if (maxn > 0) { |
| num_slots = (((maxn - 1) / 4) + 1) * 4; |
| } |
| std::cout << "# of slots = " << num_slots << "\n"; |
| |
| for (size_t t = 0; t < size_t(num_slots); t++) { |
| VertexAttrib weights, joints; |
| |
| size_t num_faceverts = mesh->indices.size(); |
| |
| // facevarying weights/joints Fill with zeros |
| weights.data.resize(4 * num_faceverts, 0.0f); |
| joints.data.resize(4 * num_faceverts, 0.0f); |
| |
| for (size_t s = 0; s < shapes.size(); s++) { |
| const tinyobj::shape_t &shape = shapes[s]; |
| |
| for (size_t f = 0; f < shape.mesh.indices.size(); f++) { |
| tinyobj::index_t idx = shape.mesh.indices[f]; |
| |
| size_t vid = idx.vertex_index; |
| |
| assert(vid < vertex_skin_weights.size()); |
| const tinyobj::skin_weight_t &sw = vertex_skin_weights[vid]; |
| |
| for (size_t j0 = 0; j0 < 4; j0++) { |
| size_t j = t * 4 + j0; |
| if (j < sw.weightValues.size()) { |
| joints.data[4 * vid + j0] = float(sw.weightValues[j].joint_id); |
| weights.data[4 * vid + j0] = float(sw.weightValues[j].weight); |
| } |
| } |
| } |
| } |
| |
| mesh->weights[t] = weights; |
| mesh->joints[t] = joints; |
| } |
| } |
| |
| } else { |
| // position/texcoord/normal can be represented in shared vertex manner |
| |
| mesh->position.data.clear(); |
| for (size_t v = 0; v < attrib.vertices.size(); v++) { |
| mesh->position.data.push_back(attrib.vertices[v]); |
| } |
| |
| mesh->normal.data.clear(); |
| for (size_t v = 0; v < attrib.normals.size(); v++) { |
| mesh->normal.data.push_back(attrib.normals[v]); |
| } |
| |
| mesh->texcoords[0] = VertexAttrib(); |
| for (size_t v = 0; v < attrib.texcoords.size(); v++) { |
| mesh->texcoords[0].data.push_back(attrib.texcoords[v]); |
| } |
| |
| mesh->indices_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT; |
| mesh->indices.clear(); |
| |
| size_t face_index_offset = 0; |
| for (size_t s = 0; s < shapes.size(); s++) { |
| const tinyobj::shape_t &shape = shapes[s]; |
| |
| for (size_t f = 0; f < shape.mesh.indices.size(); f++) { |
| mesh->indices.push_back(uint32_t(face_index_offset) + |
| uint32_t(shape.mesh.indices[f].vertex_index)); |
| } |
| |
| face_index_offset = mesh->indices.size(); |
| } |
| |
| // weights/joints |
| if (attrib.skin_weights.size() > 0) { |
| // Find max # of slots. |
| size_t maxn = 0; |
| for (size_t i = 0; i < attrib.skin_weights.size(); i++) { |
| maxn = std::max(attrib.skin_weights[i].weightValues.size(), maxn); |
| } |
| |
| int num_slots = 0; |
| if (maxn > 0) { |
| num_slots = (((maxn - 1) / 4) + 1) * 4; |
| } |
| std::cout << "# of slots = " << num_slots << "\n"; |
| |
| for (size_t s = 0; s < size_t(num_slots); s++) { |
| VertexAttrib weights, joints; |
| |
| // Fill with zeros |
| weights.data.resize(4 * (mesh->position.data.size() / 3), 0.0f); |
| joints.data.resize(4 * (mesh->position.data.size() / 3), 0.0f); |
| |
| for (size_t v = 0; v < attrib.skin_weights.size(); v++) { |
| const tinyobj::skin_weight_t &sw = attrib.skin_weights[v]; |
| |
| assert(sw.vertex_id < (mesh->position.data.size() / 3)); |
| |
| size_t dst_vid = sw.vertex_id; |
| |
| for (size_t j0 = 0; j0 < 4; j0++) { |
| size_t j = s * 4 + j0; |
| if (j < sw.weightValues.size()) { |
| joints.data[4 * dst_vid + j0] = |
| float(sw.weightValues[j].joint_id); |
| weights.data[4 * dst_vid + j0] = float(sw.weightValues[j].weight); |
| } |
| } |
| } |
| |
| weights.data_type = TINYGLTF_TYPE_VEC4; |
| weights.component_type = |
| TINYGLTF_COMPONENT_TYPE_FLOAT; // storage format |
| mesh->weights[s] = weights; |
| |
| joints.data_type = TINYGLTF_TYPE_VEC4; |
| joints.component_type = |
| TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT; // storage format |
| |
| mesh->joints[s] = joints; |
| } |
| } |
| } |
| |
| // postprocessing. e.g. find min/max |
| { |
| { |
| uint32_t minv = 0.0; |
| uint32_t maxv = 0.0; |
| for (size_t i = 0; i < mesh->indices.size(); i++) { |
| minv = std::min(minv, uint32_t(mesh->indices[i])); |
| maxv = std::max(maxv, uint32_t(mesh->indices[i])); |
| } |
| |
| mesh->indices_min = int(minv); |
| mesh->indices_max = int(maxv); |
| |
| mesh->indices_type = TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT; |
| } |
| |
| { |
| float bmin[3]; |
| float bmax[3]; |
| bmin[0] = bmin[1] = bmin[2] = std::numeric_limits<float>::max(); |
| bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits<float>::max(); |
| |
| for (size_t i = 0; i < mesh->position.data.size() / 3; i++) { |
| for (size_t k = 0; k < 3; k++) { |
| bmin[k] = std::min(bmin[k], mesh->position.data[3 * i + k]); |
| bmax[k] = std::max(bmax[k], mesh->position.data[3 * i + k]); |
| } |
| } |
| |
| mesh->position.minValues.resize(3); |
| mesh->position.minValues[0] = bmin[0]; |
| mesh->position.minValues[1] = bmin[1]; |
| mesh->position.minValues[2] = bmin[2]; |
| |
| mesh->position.maxValues.resize(3); |
| mesh->position.maxValues[0] = bmax[0]; |
| mesh->position.maxValues[1] = bmax[1]; |
| mesh->position.maxValues[2] = bmax[2]; |
| |
| mesh->position.data_type = TINYGLTF_TYPE_VEC3; |
| mesh->position.component_type = TINYGLTF_COMPONENT_TYPE_FLOAT; |
| } |
| |
| { |
| float bmin[3]; |
| float bmax[3]; |
| bmin[0] = bmin[1] = bmin[2] = std::numeric_limits<float>::max(); |
| bmax[0] = bmax[1] = bmax[2] = -std::numeric_limits<float>::max(); |
| |
| for (size_t i = 0; i < mesh->normal.data.size() / 3; i++) { |
| for (size_t k = 0; k < 3; k++) { |
| bmin[k] = std::min(bmin[k], mesh->normal.data[3 * i + k]); |
| bmax[k] = std::max(bmax[k], mesh->normal.data[3 * i + k]); |
| } |
| } |
| |
| mesh->normal.minValues.resize(3); |
| mesh->normal.minValues[0] = bmin[0]; |
| mesh->normal.minValues[1] = bmin[1]; |
| mesh->normal.minValues[2] = bmin[2]; |
| |
| mesh->normal.maxValues.resize(3); |
| mesh->normal.maxValues[0] = bmax[0]; |
| mesh->normal.maxValues[1] = bmax[1]; |
| mesh->normal.maxValues[2] = bmax[2]; |
| |
| mesh->normal.data_type = TINYGLTF_TYPE_VEC3; |
| mesh->normal.component_type = TINYGLTF_COMPONENT_TYPE_FLOAT; |
| } |
| |
| { |
| float bmin[4]; |
| float bmax[4]; |
| bmin[0] = bmin[1] = bmin[2] = bmin[3] = std::numeric_limits<float>::max(); |
| bmax[0] = bmax[1] = bmax[2] = bmin[3] = |
| -std::numeric_limits<float>::max(); |
| |
| size_t n = 3; |
| |
| for (size_t i = 0; i < mesh->tangent.data.size() / n; i++) { |
| for (size_t k = 0; k < n; k++) { |
| bmin[k] = std::min(bmin[k], mesh->tangent.data[n * i + k]); |
| bmax[k] = std::max(bmax[k], mesh->tangent.data[n * i + k]); |
| } |
| } |
| |
| mesh->tangent.minValues.resize(n); |
| mesh->tangent.maxValues.resize(n); |
| for (size_t k = 0; k < n; k++) { |
| mesh->tangent.minValues[k] = bmin[k]; |
| mesh->tangent.maxValues[k] = bmax[k]; |
| } |
| |
| mesh->tangent.data_type = |
| (n == 3) ? TINYGLTF_TYPE_VEC3 : TINYGLTF_TYPE_VEC4; |
| mesh->tangent.component_type = TINYGLTF_COMPONENT_TYPE_FLOAT; |
| } |
| |
| // texcoord |
| for (auto &item : mesh->texcoords) { |
| float bmin[2]; |
| float bmax[2]; |
| bmin[0] = bmin[1] = std::numeric_limits<float>::max(); |
| bmax[0] = bmax[1] = -std::numeric_limits<float>::max(); |
| |
| for (size_t i = 0; i < item.second.data.size() / 2; i++) { |
| for (size_t k = 0; k < 2; k++) { |
| bmin[k] = std::min(bmin[k], item.second.data[2 * i + k]); |
| bmax[k] = std::max(bmax[k], item.second.data[2 * i + k]); |
| } |
| } |
| |
| item.second.minValues.resize(2); |
| item.second.maxValues.resize(2); |
| for (size_t k = 0; k < 2; k++) { |
| item.second.minValues[k] = bmin[k]; |
| item.second.maxValues[k] = bmax[k]; |
| } |
| |
| item.second.data_type = TINYGLTF_TYPE_VEC2; |
| item.second.component_type = TINYGLTF_COMPONENT_TYPE_FLOAT; |
| } |
| |
| // joints |
| for (auto &item : mesh->joints) { |
| float bmin; |
| float bmax; |
| bmin = std::numeric_limits<float>::max(); |
| bmax = -std::numeric_limits<float>::max(); |
| |
| for (size_t i = 0; i < item.second.data.size(); i++) { |
| bmin = std::min(bmin, item.second.data[i]); |
| bmax = std::max(bmax, item.second.data[i]); |
| } |
| |
| item.second.minValues.resize(1); |
| item.second.maxValues.resize(1); |
| |
| item.second.minValues[0] = bmin; |
| item.second.maxValues[0] = bmax; |
| |
| item.second.data_type = TINYGLTF_TYPE_VEC4; |
| item.second.component_type = |
| TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT; // storage format |
| } |
| |
| // weights |
| for (auto &item : mesh->weights) { |
| float bmin; |
| float bmax; |
| bmin = std::numeric_limits<float>::max(); |
| bmax = -std::numeric_limits<float>::max(); |
| |
| for (size_t i = 0; i < item.second.data.size(); i++) { |
| bmin = std::min(bmin, item.second.data[i]); |
| bmax = std::max(bmax, item.second.data[i]); |
| } |
| |
| item.second.minValues.resize(1); |
| item.second.maxValues.resize(1); |
| |
| item.second.minValues[0] = bmin; |
| item.second.maxValues[0] = bmax; |
| |
| item.second.data_type = TINYGLTF_TYPE_VEC4; |
| item.second.component_type = |
| TINYGLTF_COMPONENT_TYPE_FLOAT; // storage format |
| } |
| } |
| |
| // Use filename as mesh's name |
| mesh->name = GetBaseFilename(filename); |
| |
| mesh->mode = TINYGLTF_MODE_TRIANGLES; |
| |
| return true; |
| } |
| |
| void PrintMeshPrim(const MeshPrim &mesh) { |
| std::cout << "indices.component_type : " |
| << PrintComponentType(mesh.indices_type) << "\n"; |
| std::cout << "# of indices : " << mesh.indices.size() << "\n"; |
| std::cout << " indices.min = " << mesh.indices_min |
| << ", max = " << mesh.indices_max << "\n"; |
| for (size_t i = 0; i < mesh.indices.size(); i++) { |
| std::cout << " index[" << i << "] = " << mesh.indices[i] << "\n"; |
| } |
| |
| std::cout << "position.type : " << PrintType(mesh.position.data_type) << "\n"; |
| std::cout << "position.component_type : " |
| << PrintComponentType(mesh.position.component_type) << "\n"; |
| std::cout << "# of positions : " << mesh.position.data.size() / 3 << "\n"; |
| if ((mesh.position.minValues.size() == 3) && |
| (mesh.position.maxValues.size() == 3)) { |
| std::cout << " position.min = " << mesh.position.minValues |
| << ", max = " << mesh.position.maxValues << "\n"; |
| } |
| for (size_t i = 0; i < mesh.position.data.size() / 3; i++) { |
| std::cout << " position[" << i << "] = " << mesh.position.data[3 * i + 0] |
| << ", " << mesh.position.data[3 * i + 1] << ", " |
| << mesh.position.data[3 * i + 2] << std::endl; |
| } |
| |
| std::cout << "normal.type : " << PrintType(mesh.normal.data_type) << "\n"; |
| std::cout << "normal.component_type : " |
| << PrintComponentType(mesh.normal.component_type) << "\n"; |
| std::cout << "# of normals : " << mesh.normal.data.size() / 3 << "\n"; |
| if ((mesh.normal.minValues.size() == 3) && |
| (mesh.normal.maxValues.size() == 3)) { |
| std::cout << " normal.min = " << mesh.normal.minValues |
| << ", max = " << mesh.normal.maxValues << "\n"; |
| } |
| for (size_t i = 0; i < mesh.normal.data.size() / 3; i++) { |
| std::cout << " normal[" << i << "] = " << mesh.normal.data[3 * i + 0] |
| << ", " << mesh.normal.data[3 * i + 1] << ", " |
| << mesh.normal.data[3 * i + 2] << std::endl; |
| } |
| |
| if (mesh.tangent.data.size() > 0) { |
| assert((mesh.tangent.data_type == TINYGLTF_TYPE_VEC3) || |
| (mesh.tangent.data_type == TINYGLTF_TYPE_VEC4)); |
| |
| size_t n = mesh.tangent.data_type == TINYGLTF_TYPE_VEC3 ? 3 : 4; |
| |
| std::cout << "tangent.type : " << PrintType(mesh.tangent.data_type) << "\n"; |
| std::cout << "tangent.component_type : " |
| << PrintComponentType(mesh.tangent.component_type) << "\n"; |
| std::cout << "# of tangents : " << mesh.tangent.data.size() / n << "\n"; |
| if ((mesh.tangent.minValues.size() == 3) && |
| (mesh.tangent.maxValues.size() == 3)) { |
| std::cout << " tangent.min = " << mesh.tangent.minValues |
| << ", max = " << mesh.tangent.maxValues << "\n"; |
| } |
| for (size_t i = 0; i < mesh.tangent.data.size() / n; i++) { |
| std::cout << " tangent[" << i << "] = " << mesh.tangent.data[n * i + 0] |
| << ", " << mesh.tangent.data[n * i + 1] << ", " |
| << mesh.tangent.data[n * i + 2]; |
| |
| if (n == 4) { |
| std::cout << ", " << mesh.tangent.data[n * i + 3]; |
| } |
| std::cout << std::endl; |
| } |
| } |
| |
| std::cout << "# of texcoord slots : " << mesh.texcoords.size() << "\n"; |
| for (const auto &item : mesh.texcoords) { |
| std::cout << "TEXCOORD_" << item.first << "\n"; |
| |
| assert(item.second.data_type == TINYGLTF_TYPE_VEC2); |
| std::cout << "texcoord.type : " << PrintType(item.second.data_type) << "\n"; |
| std::cout << "texcoord.component_type : " |
| << PrintComponentType(item.second.component_type) << "\n"; |
| std::cout << "# of texcoords : " << item.second.data.size() / 2 << "\n"; |
| if ((item.second.minValues.size() == 2) && |
| (item.second.maxValues.size() == 2)) { |
| std::cout << " texcood.min = " << item.second.minValues |
| << ", max = " << item.second.maxValues << "\n"; |
| } |
| for (size_t i = 0; i < item.second.data.size() / 2; i++) { |
| std::cout << " texcoord[" << i << "] = " << item.second.data[2 * i + 0] |
| << ", " << item.second.data[2 * i + 1]; |
| std::cout << std::endl; |
| } |
| } |
| |
| assert(mesh.joints.size() == mesh.weights.size()); |
| std::cout << "# of joints/weights slots : " << mesh.joints.size() << "\n"; |
| for (const auto &item : mesh.joints) { |
| assert(mesh.weights.count(item.first)); |
| |
| assert(item.second.data_type == TINYGLTF_TYPE_VEC4); |
| |
| // joint must be uint8 or uint16 |
| assert( |
| (item.second.component_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) || |
| (item.second.component_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT)); |
| |
| std::cout << "joint.type : " << PrintType(item.second.data_type) << "\n"; |
| std::cout << "joint.component_type : " |
| << PrintComponentType(item.second.component_type) << "\n"; |
| |
| std::cout << "JOINTS_" << item.first << "\n"; |
| for (size_t i = 0; i < item.second.data.size(); i++) { |
| std::cout << " joints[" << i << "] = " << int(item.second.data[i]) |
| << "\n"; |
| } |
| |
| const VertexAttrib &attrib = mesh.weights.at(item.first); |
| |
| // weight must be uint8 or uint16(normalized), or float |
| assert((attrib.component_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) || |
| (attrib.component_type == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) || |
| (attrib.component_type == TINYGLTF_COMPONENT_TYPE_FLOAT)); |
| |
| std::cout << "weight.type : " << PrintType(attrib.data_type) << "\n"; |
| std::cout << "weight.component_type : " |
| << PrintComponentType(attrib.component_type) << "\n"; |
| std::cout << "WEIGHTS_" << item.first << "\n"; |
| for (size_t i = 0; i < attrib.data.size(); i++) { |
| std::cout << " weights[" << i << "] = " << attrib.data[i] << "\n"; |
| } |
| } |
| } |
| |
| } // namespace example |
