tinymetabobjloader 2.0.0rc14.dev2__cp310-cp310-win_amd64.whl

python/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012-2019 Syoyo Fujita and many contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

python/Makefile

@@ -0,0 +1,7 @@
+all:
+	cd .. && python -m pip install .
+
+t:
+	python sample.py
+
+.PHONY: t

python/README.md

@@ -0,0 +1,87 @@
+# tinyobjloader, Wavefront .obj loader
+
+`tinyobjloader` is a python wrapper for C++ wavefront .obj loader.
+`tinyobjloader` is rather fast and feature rich than other pure python version of .obj loader.
+
+## Requirements
+
+* python 3.6+
+
+## Install
+
+You can install `tinyobjloader` with pip.
+
+```
+$ pip install tinyobjloader
+```
+
+## Quick tutorial
+
+```py
+import sys
+import tinyobjloader
+
+# Create reader.
+reader = tinyobjloader.ObjReader()
+
+filename = "cornellbox.obj"
+
+# Load .obj(and .mtl) using default configuration
+ret = reader.ParseFromFile(filename)
+
+if ret == False:
+    print("Warn:", reader.Warning())
+    pint("Err:", reader.Error())
+    print("Failed to load : ", filename)
+
+    sys.exit(-1)
+
+if reader.Warning():
+    print("Warn:", reader.Warning())
+
+attrib = reader.GetAttrib()
+print("attrib.vertices = ", len(attrib.vertices))
+print("attrib.normals = ", len(attrib.normals))
+print("attrib.texcoords = ", len(attrib.texcoords))
+
+materials = reader.GetMaterials()
+print("Num materials: ", len(materials))
+for m in materials:
+    print(m.name)
+    print(m.diffuse)
+
+shapes = reader.GetShapes()
+print("Num shapes: ", len(shapes))
+for shape in shapes:
+    print(shape.name)
+    print("num_indices = {}".format(len(shape.mesh.indices)))
+
+```
+
+## More detailed usage
+
+Please take a look at `python/sample.py` file in tinyobjloader git repo.
+
+https://github.com/syoyo/tinyobjloader/blob/master/python/sample.py
+
+## How to build
+
+Using `cibuildwheel` is a recommended way to build a python module.
+See $tinyobjloader/azure-pipelines.yml for details.
+
+### Developer build
+
+Assume pip is installed.
+
+```
+$ git clone https://github.com/tinyobjloader/tinyobjloader
+$ cd tinyobjloader
+$ python -m pip install .
+```
+
+## License
+
+MIT(tinyobjloader) and ISC(mapbox earcut) license.
+
+## TODO
+ * [ ] Writer saver

python/_version.py

@@ -0,0 +1,4 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+__version__ = version = '2.0.0rc14.dev2'
+__version_tuple__ = version_tuple = (2, 0, 0, 'dev2')

python/bindings.cc

@@ -0,0 +1,248 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+#include <cstring>
+
+// Use double precision for better python integration.
+#define TINYOBJLOADER_USE_DOUBLE
+
+// define some helper functions for pybind11
+#define TINY_OBJ_LOADER_PYTHON_BINDING
+#include "../tiny_obj_loader.h"
+
+namespace py = pybind11;
+
+using namespace tinyobj;
+
+PYBIND11_MODULE(tinyobjloader, tobj_module)
+{
+  tobj_module.doc() = "Python bindings for TinyObjLoader.";
+
+  // register struct
+  py::class_<ObjReaderConfig>(tobj_module, "ObjReaderConfig")
+    .def(py::init<>())
+    .def_readwrite("triangulate", &ObjReaderConfig::triangulate);
+
+  // py::init<>() for default constructor
+  py::class_<ObjReader>(tobj_module, "ObjReader")
+    .def(py::init<>())
+    .def("ParseFromFile", &ObjReader::ParseFromFile, py::arg("filename"), py::arg("option") = ObjReaderConfig())
+    .def("ParseFromString", &ObjReader::ParseFromString, py::arg("obj_text"), py::arg("mtl_text"), py::arg("option") = ObjReaderConfig())
+    .def("Valid", &ObjReader::Valid)
+    .def("GetAttrib", &ObjReader::GetAttrib)
+    .def("GetShapes", &ObjReader::GetShapes)
+    .def("GetMaterials", &ObjReader::GetMaterials)
+    .def("Warning", &ObjReader::Warning)
+    .def("Error", &ObjReader::Error);
+
+  py::class_<attrib_t>(tobj_module, "attrib_t")
+    .def(py::init<>())
+    .def_readonly("vertices", &attrib_t::vertices)
+    .def_readonly("vertex_weights", &attrib_t::vertex_weights)
+    .def_readonly("skin_weights", &attrib_t::skin_weights)
+    .def_readonly("normals", &attrib_t::normals)
+    .def_readonly("texcoords", &attrib_t::texcoords)
+    .def_readonly("colors", &attrib_t::colors)
+    .def("numpy_vertices", [] (attrib_t &instance) {
+        auto ret = py::array_t<real_t>(instance.vertices.size());
+        py::buffer_info buf = ret.request();
+        memcpy(buf.ptr, instance.vertices.data(), instance.vertices.size() * sizeof(real_t));
+        return ret;
+    })
+    .def("numpy_vertex_weights", [] (attrib_t &instance) {
+        auto ret = py::array_t<real_t>(instance.vertex_weights.size());
+        py::buffer_info buf = ret.request();
+        memcpy(buf.ptr, instance.vertex_weights.data(), instance.vertex_weights.size() * sizeof(real_t));
+        return ret;
+    })
+    .def("numpy_normals", [] (attrib_t &instance) {
+        auto ret = py::array_t<real_t>(instance.normals.size());
+        py::buffer_info buf = ret.request();
+        memcpy(buf.ptr, instance.normals.data(), instance.normals.size() * sizeof(real_t));
+        return ret;
+    })
+    .def("numpy_texcoords", [] (attrib_t &instance) {
+        auto ret = py::array_t<real_t>(instance.texcoords.size());
+        py::buffer_info buf = ret.request();
+        memcpy(buf.ptr, instance.texcoords.data(), instance.texcoords.size() * sizeof(real_t));
+        return ret;
+    })
+    .def("numpy_colors", [] (attrib_t &instance) {
+        auto ret = py::array_t<real_t>(instance.colors.size());
+        py::buffer_info buf = ret.request();
+        memcpy(buf.ptr, instance.colors.data(), instance.colors.size() * sizeof(real_t));
+        return ret;
+    })
+    ;
+
+  py::class_<shape_t>(tobj_module, "shape_t")
+    .def(py::init<>())
+    .def_readwrite("name", &shape_t::name)
+    .def_readwrite("mesh", &shape_t::mesh)
+    .def_readwrite("lines", &shape_t::lines)
+    .def_readwrite("points", &shape_t::points);
+
+  py::class_<index_t>(tobj_module, "index_t")
+    .def(py::init<>())
+    .def_readwrite("vertex_index", &index_t::vertex_index)
+    .def_readwrite("normal_index", &index_t::normal_index)
+    .def_readwrite("texcoord_index", &index_t::texcoord_index)
+    ;
+
+  // NOTE(syoyo): It looks it is rather difficult to expose assignment by array index to
+  // python world for array variable.
+  // For example following python scripting does not work well.
+  //
+  // print(mat.diffuse)
+  // >>> [0.1, 0.2, 0.3]
+  // mat.diffuse[1] = 1.0
+  // print(mat.diffuse)
+  // >>> [0.1, 0.2, 0.3]  # No modification
+  //
+  // https://github.com/pybind/pybind11/issues/1134
+  //
+  // so, we need to update array variable like this:
+  //
+  // diffuse = mat.diffuse
+  // diffuse[1] = 1.0
+  // mat.diffuse = diffuse
+  //
+  py::class_<material_t>(tobj_module, "material_t")
+    .def(py::init<>())
+    .def_readwrite("name", &material_t::name)
+    .def_property("ambient", &material_t::GetAmbient, &material_t::SetAmbient)
+    .def_property("diffuse", &material_t::GetDiffuse, &material_t::SetDiffuse)
+    .def_property("specular", &material_t::GetSpecular, &material_t::SetSpecular)
+    .def_property("transmittance", &material_t::GetTransmittance, &material_t::SetTransmittance)
+    .def_readwrite("shininess", &material_t::shininess)
+    .def_readwrite("ior", &material_t::ior)
+    .def_readwrite("dissolve", &material_t::dissolve)
+    .def_readwrite("illum", &material_t::illum)
+    .def_readwrite("ambient_texname", &material_t::ambient_texname)
+    .def_readwrite("diffuse_texname", &material_t::diffuse_texname)
+    .def_readwrite("specular_texname", &material_t::specular_texname)
+    .def_readwrite("specular_highlight_texname", &material_t::specular_highlight_texname)
+    .def_readwrite("bump_texname", &material_t::bump_texname)
+    .def_readwrite("displacement_texname", &material_t::displacement_texname)
+    .def_readwrite("alpha_texname", &material_t::alpha_texname)
+    .def_readwrite("reflection_texname", &material_t::reflection_texname)
+    // TODO(syoyo): Expose texture parameter
+    // PBR
+    .def_readwrite("roughness", &material_t::roughness)
+    .def_readwrite("metallic", &material_t::metallic)
+    .def_readwrite("sheen", &material_t::sheen)
+    .def_readwrite("clearcoat_thickness", &material_t::clearcoat_thickness)
+    .def_readwrite("clearcoat_roughness", &material_t::clearcoat_roughness)
+    .def_readwrite("anisotropy", &material_t::anisotropy)
+    .def_readwrite("anisotropy_rotation", &material_t::anisotropy_rotation)
+
+    .def_readwrite("roughness_texname", &material_t::roughness_texname)
+    .def_readwrite("metallic_texname", &material_t::metallic_texname)
+    .def_readwrite("sheen_texname", &material_t::sheen_texname)
+    .def_readwrite("emissive_texname", &material_t::emissive_texname)
+    .def_readwrite("normal_texname", &material_t::normal_texname)
+
+    .def("GetCustomParameter", &material_t::GetCustomParameter)
+    ;
+
+  py::class_<mesh_t>(tobj_module, "mesh_t", py::buffer_protocol())
+    .def(py::init<>())
+    .def_readonly("num_face_vertices", &mesh_t::num_face_vertices)
+    .def("numpy_num_face_vertices", [] (mesh_t &instance) {
+        auto ret = py::array_t<unsigned int>(instance.num_face_vertices.size());
+        py::buffer_info buf = ret.request();
+        memcpy(buf.ptr, instance.num_face_vertices.data(), instance.num_face_vertices.size() * sizeof(unsigned int));
+        return ret;
+    })
+    .def("vertex_indices", [](mesh_t &self) {
+      // NOTE: we cannot use py::buffer_info and py:buffer as a return type.
+      // py::memoriview is not suited for vertex indices usecase, since indices data may be used after
+      // deleting C++ mesh_t object in Python world.
+      //
+      // So create a dedicated Python object(std::vector<int>) 
+      
+      std::vector<int> indices;
+      indices.resize(self.indices.size());
+      for (size_t i = 0; i < self.indices.size(); i++) {
+        indices[i] = self.indices[i].vertex_index;
+      }
+
+      return indices;
+    })
+    .def("normal_indices", [](mesh_t &self) {
+      
+      std::vector<int> indices;
+      indices.resize(self.indices.size());
+      for (size_t i = 0; i < self.indices.size(); i++) {
+        indices[i] = self.indices[i].normal_index;
+      }
+
+      return indices;
+    })
+    .def("texcoord_indices", [](mesh_t &self) {
+      
+      std::vector<int> indices;
+      indices.resize(self.indices.size());
+      for (size_t i = 0; i < self.indices.size(); i++) {
+        indices[i] = self.indices[i].texcoord_index;
+      }
+
+      return indices;
+    })
+    .def_readonly("indices", &mesh_t::indices)
+    .def("numpy_indices", [] (mesh_t &instance) {
+        // Flatten indexes. index_t is composed of 3 ints(vertex_index, normal_index, texcoord_index).
+        // numpy_indices = [0, -1, -1, 1, -1, -1, ...]
+        // C++11 or later should pack POD struct tightly and does not reorder variables,
+        // so we can memcpy to copy data.
+        // Still, we check the size of struct and byte offsets of each variable just for sure.
+        static_assert(sizeof(index_t) == 12, "sizeof(index_t) must be 12");
+        static_assert(offsetof(index_t, vertex_index) == 0, "offsetof(index_t, vertex_index) must be 0");
+        static_assert(offsetof(index_t, normal_index) == 4, "offsetof(index_t, normal_index) must be 4");
+        static_assert(offsetof(index_t, texcoord_index) == 8, "offsetof(index_t, texcoord_index) must be 8");
+
+        auto ret = py::array_t<int>(instance.indices.size() * 3);
+        py::buffer_info buf = ret.request();
+        memcpy(buf.ptr, instance.indices.data(), instance.indices.size() * 3 * sizeof(int));
+        return ret;
+    })
+    .def_readonly("material_ids", &mesh_t::material_ids)
+    .def("numpy_material_ids", [] (mesh_t &instance) {
+        auto ret = py::array_t<int>(instance.material_ids.size());
+        py::buffer_info buf = ret.request();
+        memcpy(buf.ptr, instance.material_ids.data(), instance.material_ids.size() * sizeof(int));
+        return ret;
+    });
+
+  py::class_<lines_t>(tobj_module, "lines_t")
+    .def(py::init<>())
+    .def_readonly("indices", &lines_t::indices)
+    .def_readonly("num_line_vertices", &lines_t::num_line_vertices)
+    ;
+
+  py::class_<points_t>(tobj_module, "points_t")
+    .def(py::init<>())
+    .def_readonly("indices", &points_t::indices)
+    ;
+
+  py::class_<joint_and_weight_t>(tobj_module, "joint_and_weight_t")
+    .def(py::init<>())
+    .def_readonly("joint_id", &joint_and_weight_t::joint_id, "Joint index(NOTE: Joint info is provided externally, not from .obj")
+    .def_readonly("weight", &joint_and_weight_t::weight, "Weight value(NOTE: weight is not normalized)")
+    ;
+
+  py::class_<skin_weight_t>(tobj_module, "skin_weight_t")
+    .def(py::init<>())
+    .def_readonly("vertex_id", &skin_weight_t::vertex_id)
+    .def_readonly("weightValues", &skin_weight_t::weightValues)
+    ;
+
+  py::class_<tag_t>(tobj_module, "tag_t")
+    .def(py::init<>())
+    .def_readonly("name", &tag_t::name)
+    .def_readonly("intValues", &tag_t::intValues)  
+    .def_readonly("floatValues", &tag_t::floatValues)  
+    .def_readonly("stringValues", &tag_t::stringValues)  
+    ;
+}
+

python/sample.py

@@ -0,0 +1,138 @@
+import sys
+import tinyobjloader
+
+is_numpy_available = False
+try:
+    import numpy
+
+    is_numpy_available = True
+except:
+    print(
+        "NumPy not installed. Do not use numpy_*** API. If you encounter slow performance, see a performance tips for non-numpy API https://github.com/tinyobjloader/tinyobjloader/issues/275"
+    )
+
+filename = "../models/cornell_box.obj"
+
+if len(sys.argv) > 1:
+    filename = sys.argv[1]
+
+
+reader = tinyobjloader.ObjReader()
+
+# Load .obj(and .mtl) using default configuration
+ret = reader.ParseFromFile(filename)
+
+# Optionally you can set custom `config`
+# config = tinyobj.ObjReaderConfig()
+# config.triangulate = False
+# ret = reader.ParseFromFile(filename, config)
+
+if ret == False:
+    print("Failed to load : ", filename)
+    print("Warn:", reader.Warning())
+    print("Err:", reader.Error())
+    sys.exit(-1)
+
+if reader.Warning():
+    print("Warn:", reader.Warning())
+
+attrib = reader.GetAttrib()
+print("len(attrib.vertices) = ", len(attrib.vertices))
+print("len(attrib.vertex_weights) = ", len(attrib.vertex_weights))
+print("len(attrib.normals) = ", len(attrib.normals))
+print("len(attrib.texcoords) = ", len(attrib.texcoords))
+print("len(attrib.colors) = ", len(attrib.colors))
+print("len(attrib.skin_weights) = ", len(attrib.skin_weights))
+
+# vertex data must be `xyzxyzxyz...`
+assert len(attrib.vertices) % 3 == 0
+
+# normal data must be `xyzxyzxyz...`
+assert len(attrib.normals) % 3 == 0
+
+# texcoords data must be `uvuvuv...`
+assert len(attrib.texcoords) % 2 == 0
+
+# colors data must be `rgbrgbrgb...`
+assert len(attrib.texcoords) % 3 == 0
+
+# Performance note
+# (direct?) array access through member variable is quite slow.
+# https://github.com/tinyobjloader/tinyobjloader/issues/275#issuecomment-753465833
+#
+# We encourage first copy(?) varible to Python world:
+#
+# vertices = attrib.vertices
+#
+# for i in range(...)
+#   v = vertices[i]
+#
+# Or please consider using numpy_*** interface(e.g. numpy_vertices())
+
+for i, v in enumerate(attrib.vertices):
+    print("v[{}] = {}".format(i, v))
+
+# vw is filled with 1.0 if [w] component is not present in `v` line in .obj
+for i, w in enumerate(attrib.vertex_weights):
+    print("vweight[{}] = {}".format(i, w))
+
+for i, v in enumerate(attrib.normals):
+    print("vn[{}] = {}".format(i, v))
+
+for i, v in enumerate(attrib.texcoords):
+    print("vt[{}] = {}".format(i, v))
+
+for i, v in enumerate(attrib.colors):
+    print("vcol[{}] = {}".format(i, v))
+
+if len(attrib.skin_weights):
+    print("num skin weights", len(attrib.skin_weights))
+
+    for i, skin in enumerate(attrib.skin_weights):
+        print("skin_weight[{}]".format(i))
+        print("  vertex_id = ", skin.vertex_id)
+        print("  len(weights) = ", len(skin.weightValues))
+        for k, w in enumerate(skin.weightValues):
+            print("    [{}] joint_id: {}, weight: {}".format(k, w.joint_id, w.weight))
+
+if is_numpy_available:
+    print("numpy_v = {}".format(attrib.numpy_vertices()))
+    print("numpy_vn = {}".format(attrib.numpy_normals()))
+    print("numpy_vt = {}".format(attrib.numpy_texcoords()))
+    print("numpy_vcol = {}".format(attrib.numpy_colors()))
+
+materials = reader.GetMaterials()
+print("Num materials: ", len(materials))
+for m in materials:
+    print(m.name)
+    print(m.diffuse)
+    print(m.diffuse_texname)
+    # Partial update(array indexing) does not work
+    # m.diffuse[1] = 1.0
+
+    # Update with full object assignment works
+    m.diffuse = [1, 2, 3]
+    print(m.diffuse)
+
+    # print(m.shininess)
+    # print(m.illum)
+
+shapes = reader.GetShapes()
+print("Num shapes: ", len(shapes))
+for shape in shapes:
+    print(shape.name)
+    print("len(num_indices) = {}".format(len(shape.mesh.indices)))
+    for i, idx in enumerate(shape.mesh.indices):
+        print("[{}] v_idx {}".format(i, idx.vertex_index))
+        print("[{}] vn_idx {}".format(i, idx.normal_index))
+        print("[{}] vt_idx {}".format(i, idx.texcoord_index))
+    print("material_ids = {}".format(shape.mesh.material_ids))
+
+    # faster access to indices
+    a = shape.mesh.vertex_indices()
+    print("vertex_indices", shape.mesh.vertex_indices())
+
+    if is_numpy_available:
+        print("numpy_indices = {}".format(shape.mesh.numpy_indices()))
+        print("numpy_num_face_vertices = {}".format(shape.mesh.numpy_num_face_vertices()))
+        print("numpy_material_ids = {}".format(shape.mesh.numpy_material_ids()))

python/tiny_obj_loader.cc

@@ -0,0 +1,9 @@
+// Use double precision for better python integration.
+// Need also define this in `binding.cc`(and all compilation units)
+#define TINYOBJLOADER_USE_DOUBLE
+
+// Use robust triangulation by using Mapbox earcut.
+#define TINYOBJLOADER_USE_MAPBOX_EARCUT
+
+#define TINYOBJLOADER_IMPLEMENTATION
+#include "../tiny_obj_loader.h"

tinymetabobjloader-2.0.0rc14.dev2.dist-info/METADATA

@@ -0,0 +1,469 @@
+Metadata-Version: 2.4
+Name: tinymetabobjloader
+Version: 2.0.0rc14.dev2
+Summary: Tiny but powerful Wavefront OBJ loader
+Home-page: https://github.com/curvewise-forks/tinyobjloader
+Author: Syoyo Fujita, Paul Melnikow
+Author-email: syoyo@lighttransport.com, github@paulmelnikow.com
+License: MIT AND ISC
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Manufacturing
+Classifier: Topic :: Artistic Software
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: summary
+
+# tinyobjloader
+
+[![PyPI version](https://badge.fury.io/py/tinyobjloader.svg)](https://badge.fury.io/py/tinyobjloader)
+
+[![AZ Build Status](https://dev.azure.com/tinyobjloader/tinyobjloader/_apis/build/status/tinyobjloader.tinyobjloader?branchName=master)](https://dev.azure.com/tinyobjloader/tinyobjloader/_build/latest?definitionId=1&branchName=master)
+
+[![AppVeyor Build status](https://ci.appveyor.com/api/projects/status/m6wfkvket7gth8wn/branch/master?svg=true)](https://ci.appveyor.com/project/syoyo/tinyobjloader-6e4qf/branch/master)
+
+[![Coverage Status](https://coveralls.io/repos/github/syoyo/tinyobjloader/badge.svg?branch=master)](https://coveralls.io/github/syoyo/tinyobjloader?branch=master)
+
+[![AUR version](https://img.shields.io/aur/version/tinyobjloader?logo=arch-linux)](https://aur.archlinux.org/packages/tinyobjloader)
+
+Tiny but powerful single file wavefront obj loader written in C++03. No dependency except for C++ STL. It can parse over 10M polygons with moderate memory and time.
+
+`tinyobjloader` is good for embedding .obj loader to your (global illumination) renderer ;-)
+
+If you are looking for C99 version, please see https://github.com/syoyo/tinyobjloader-c .
+
+Version notice
+--------------
+
+We recommend to use `master`(`main`) branch. Its v2.0 release candidate. Most features are now nearly robust and stable(Remaining task for release v2.0 is polishing C++ and Python API, and fix built-in triangulation code).
+
+We have released new version v1.0.0 on 20 Aug, 2016.
+Old version is available as `v0.9.x` branch https://github.com/syoyo/tinyobjloader/tree/v0.9.x
+
+## What's new
+
+* 29 Jul, 2021 : Added Mapbox's earcut for robust triangulation. Also fixes triangulation bug(still there is some issue in built-in triangulation algorithm: https://github.com/tinyobjloader/tinyobjloader/issues/319).
+* 19 Feb, 2020 : The repository has been moved to https://github.com/tinyobjloader/tinyobjloader !
+* 18 May, 2019 : Python binding!(See `python` folder. Also see https://pypi.org/project/tinyobjloader/)
+* 14 Apr, 2019 : Bump version v2.0.0 rc0. New C++ API and python bindings!(1.x API still exists for backward compatibility)
+* 20 Aug, 2016 : Bump version v1.0.0. New data structure and API!
+
+## Requirements
+
+* C++03 compiler
+
+### Old version
+
+Previous old version is available in `v0.9.x` branch.
+
+## Example
+
+![Rungholt](images/rungholt.jpg)
+
+tinyobjloader can successfully load 6M triangles Rungholt scene.
+http://casual-effects.com/data/index.html
+
+![](images/sanmugel.png)
+
+* [examples/viewer/](examples/viewer) OpenGL .obj viewer
+* [examples/callback_api/](examples/callback_api/) Callback API example
+* [examples/voxelize/](examples/voxelize/) Voxelizer example
+
+## Use case
+
+TinyObjLoader is successfully used in ...
+
+### New version(v1.0.x)
+
+* Double precision support through `TINYOBJLOADER_USE_DOUBLE` thanks to noma
+* Loading models in Vulkan Tutorial https://vulkan-tutorial.com/Loading_models
+* .obj viewer with Metal https://github.com/middlefeng/NuoModelViewer/tree/master
+* Vulkan Cookbook https://github.com/PacktPublishing/Vulkan-Cookbook
+* cudabox: CUDA Solid Voxelizer Engine https://github.com/gaspardzoss/cudavox
+* Drake: A planning, control, and analysis toolbox for nonlinear dynamical systems https://github.com/RobotLocomotion/drake
+* VFPR - a Vulkan Forward Plus Renderer : https://github.com/WindyDarian/Vulkan-Forward-Plus-Renderer
+* glslViewer: https://github.com/patriciogonzalezvivo/glslViewer
+* Lighthouse2: https://github.com/jbikker/lighthouse2
+* rayrender(an open source R package for raytracing scenes in created in R): https://github.com/tylermorganwall/rayrender
+* liblava - A modern C++ and easy-to-use framework for the Vulkan API. [MIT]: https://github.com/liblava/liblava
+* rtxON - Simple Vulkan raytracing tutorials  https://github.com/iOrange/rtxON
+* metal-ray-tracer - Writing ray-tracer using Metal Performance Shaders https://github.com/sergeyreznik/metal-ray-tracer https://sergeyreznik.github.io/metal-ray-tracer/index.html
+* Supernova Engine - 2D and 3D projects with Lua or C++ in data oriented design: https://github.com/supernovaengine/supernova
+* AGE (Arc Game Engine) - An open-source engine for building 2D & 3D real-time rendering and interactive contents: https://github.com/MohitSethi99/ArcGameEngine
+* [Wicked Engine<img src="https://github.com/turanszkij/WickedEngine/blob/master/Content/logo_small.png" width="28px" align="center"/>](https://github.com/turanszkij/WickedEngine) - 3D engine with modern graphics
+* [Lumina Game Engine](https://github.com/MrDrElliot/LuminaEngine) - A modern, high-performance game engine built with Vulkan
+* Your project here! (Plese send PR)
+
+### Old version(v0.9.x)
+
+* bullet3 https://github.com/erwincoumans/bullet3
+* pbrt-v2 https://github.com/mmp/pbrt-v2
+* OpenGL game engine development http://swarminglogic.com/jotting/2013_10_gamedev01
+* mallie https://lighttransport.github.io/mallie
+* IBLBaker (Image Based Lighting Baker). http://www.derkreature.com/iblbaker/
+* Stanford CS148 http://web.stanford.edu/class/cs148/assignments/assignment3.pdf
+* Awesome Bump http://awesomebump.besaba.com/about/
+* sdlgl3-wavefront OpenGL .obj viewer https://github.com/chrisliebert/sdlgl3-wavefront
+* pbrt-v3 https://github.com/mmp/pbrt-v3
+* cocos2d-x https://github.com/cocos2d/cocos2d-x/
+* Android Vulkan demo https://github.com/SaschaWillems/Vulkan
+* voxelizer https://github.com/karimnaaji/voxelizer
+* Probulator https://github.com/kayru/Probulator
+* OptiX Prime baking https://github.com/nvpro-samples/optix_prime_baking
+* FireRays SDK https://github.com/GPUOpen-LibrariesAndSDKs/FireRays_SDK
+* parg, tiny C library of various graphics utilities and GL demos https://github.com/prideout/parg
+* Opengl unit of ChronoEngine https://github.com/projectchrono/chrono-opengl
+* Point Based Global Illumination on modern GPU https://pbgi.wordpress.com/code-source/
+* Fast OBJ file importing and parsing in CUDA http://researchonline.jcu.edu.au/42515/1/2015.CVM.OBJCUDA.pdf
+* Sorted Shading for Uni-Directional Pathtracing by Joshua Bainbridge https://nccastaff.bournemouth.ac.uk/jmacey/MastersProjects/MSc15/02Josh/joshua_bainbridge_thesis.pdf
+* GeeXLab http://www.geeks3d.com/hacklab/20160531/geexlab-0-12-0-0-released-for-windows/
+
+
+## Features
+
+* Group(parse multiple group name)
+* Vertex
+  * Vertex color(as an extension: https://blender.stackexchange.com/questions/31997/how-can-i-get-vertex-painted-obj-files-to-import-into-blender)
+* Texcoord
+* Normal
+* Crease tag('t'). This is OpenSubdiv specific(not in wavefront .obj specification)
+* Callback API for custom loading.
+* Double precision support(for HPC application).
+* Smoothing group
+* Python binding : See `python` folder.
+  * Precompiled binary(manylinux1-x86_64 only) is hosted at pypi https://pypi.org/project/tinyobjloader/)
+
+### Primitives
+
+* [x] face(`f`)
+* [x] lines(`l`)
+* [ ] points(`p`)
+* [ ] curve
+* [ ] 2D curve
+* [ ] surface.
+* [ ] Free form curve/surfaces
+
+### Material
+
+* PBR material extension for .MTL. Please see [pbr-mtl.md](pbr-mtl.md) for details.
+* Texture options
+* Unknown material attributes are returned as key-value(value is string) map.
+
+## TODO
+
+* [ ] Fix obj_sticker example.
+* [ ] More unit test codes.
+
+## License
+
+TinyObjLoader is licensed under MIT license.
+
+### Third party licenses.
+
+* pybind11 : BSD-style license.
+* mapbox earcut.hpp: ISC License.
+
+## Usage
+
+### Installation
+
+One option is to simply copy the header file into your project and to make sure that `TINYOBJLOADER_IMPLEMENTATION` is defined exactly once.
+
+### Building tinyobjloader - Using vcpkg(not recommended though)
+
+Although it is not a recommended way, you can download and install tinyobjloader using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    ./vcpkg install tinyobjloader
+
+The tinyobjloader port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+### Data format
+
+`attrib_t` contains single and linear array of vertex data(position, normal and texcoord).
+
+```
+attrib_t::vertices => 3 floats per vertex
+
+       v[0]        v[1]        v[2]        v[3]               v[n-1]
+  +-----------+-----------+-----------+-----------+      +-----------+
+  | x | y | z | x | y | z | x | y | z | x | y | z | .... | x | y | z |
+  +-----------+-----------+-----------+-----------+      +-----------+
+
+attrib_t::normals => 3 floats per vertex
+
+       n[0]        n[1]        n[2]        n[3]               n[n-1]
+  +-----------+-----------+-----------+-----------+      +-----------+
+  | x | y | z | x | y | z | x | y | z | x | y | z | .... | x | y | z |
+  +-----------+-----------+-----------+-----------+      +-----------+
+
+attrib_t::texcoords => 2 floats per vertex
+
+       t[0]        t[1]        t[2]        t[3]               t[n-1]
+  +-----------+-----------+-----------+-----------+      +-----------+
+  |  u  |  v  |  u  |  v  |  u  |  v  |  u  |  v  | .... |  u  |  v  |
+  +-----------+-----------+-----------+-----------+      +-----------+
+
+attrib_t::colors => 3 floats per vertex(vertex color. optional)
+
+       c[0]        c[1]        c[2]        c[3]               c[n-1]
+  +-----------+-----------+-----------+-----------+      +-----------+
+  | x | y | z | x | y | z | x | y | z | x | y | z | .... | x | y | z |
+  +-----------+-----------+-----------+-----------+      +-----------+
+
+```
+
+Each `shape_t::mesh_t` does not contain vertex data but contains array index to `attrib_t`.
+See `loader_example.cc` for more details.
+
+
+```
+
+mesh_t::indices => array of vertex indices.
+
+  +----+----+----+----+----+----+----+----+----+----+     +--------+
+  | i0 | i1 | i2 | i3 | i4 | i5 | i6 | i7 | i8 | i9 | ... | i(n-1) |
+  +----+----+----+----+----+----+----+----+----+----+     +--------+
+
+Each index has an array index to attrib_t::vertices, attrib_t::normals and attrib_t::texcoords.
+
+mesh_t::num_face_vertices => array of the number of vertices per face(e.g. 3 = triangle, 4 = quad , 5 or more = N-gons).
+
+
+  +---+---+---+        +---+
+  | 3 | 4 | 3 | ...... | 3 |
+  +---+---+---+        +---+
+    |   |   |            |
+    |   |   |            +-----------------------------------------+
+    |   |   |                                                      |
+    |   |   +------------------------------+                       |
+    |   |                                  |                       |
+    |   +------------------+               |                       |
+    |                      |               |                       |
+    |/                     |/              |/                      |/
+
+ mesh_t::indices
+
+  |    face[0]   |       face[1]     |    face[2]   |     |      face[n-1]           |
+  +----+----+----+----+----+----+----+----+----+----+     +--------+--------+--------+
+  | i0 | i1 | i2 | i3 | i4 | i5 | i6 | i7 | i8 | i9 | ... | i(n-3) | i(n-2) | i(n-1) |
+  +----+----+----+----+----+----+----+----+----+----+     +--------+--------+--------+
+
+```
+
+Note that when `triangulate` flag is true in `tinyobj::LoadObj()` argument, `num_face_vertices` are all filled with 3(triangle).
+
+### float data type
+
+TinyObjLoader now use `real_t` for floating point data type.
+Default is `float(32bit)`.
+You can enable `double(64bit)` precision by using `TINYOBJLOADER_USE_DOUBLE` define.
+
+### Robust triangulation
+
+When you enable `triangulation`(default is enabled),
+TinyObjLoader triangulate polygons(faces with 4 or more vertices).
+
+Built-in triangulation code may not work well in some polygon shape.
+
+You can define `TINYOBJLOADER_USE_MAPBOX_EARCUT` for robust triangulation using `mapbox/earcut.hpp`.
+This requires C++11 compiler though. And you need to copy `mapbox/earcut.hpp` to your project.
+If you have your own `mapbox/earcut.hpp` file incuded in your project, you can define `TINYOBJLOADER_DONOT_INCLUDE_MAPBOX_EARCUT` so that `mapbox/earcut.hpp` is not included inside of `tiny_obj_loader.h`.
+
+#### Example code (Deprecated API)
+
+```c++
+#define TINYOBJLOADER_IMPLEMENTATION // define this in only *one* .cc
+// Optional. define TINYOBJLOADER_USE_MAPBOX_EARCUT gives robust triangulation. Requires C++11
+//#define TINYOBJLOADER_USE_MAPBOX_EARCUT
+#include "tiny_obj_loader.h"
+
+std::string inputfile = "cornell_box.obj";
+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, inputfile.c_str());
+
+if (!warn.empty()) {
+  std::cout << warn << std::endl;
+}
+
+if (!err.empty()) {
+  std::cerr << err << std::endl;
+}
+
+if (!ret) {
+  exit(1);
+}
+
+// Loop over shapes
+for (size_t s = 0; s < shapes.size(); s++) {
+  // Loop over faces(polygon)
+  size_t index_offset = 0;
+  for (size_t f = 0; f < shapes[s].mesh.num_face_vertices.size(); f++) {
+    size_t fv = size_t(shapes[s].mesh.num_face_vertices[f]);
+
+    // Loop over vertices in the face.
+    for (size_t v = 0; v < fv; v++) {
+      // access to vertex
+      tinyobj::index_t idx = shapes[s].mesh.indices[index_offset + v];
+
+      tinyobj::real_t vx = attrib.vertices[3*size_t(idx.vertex_index)+0];
+      tinyobj::real_t vy = attrib.vertices[3*size_t(idx.vertex_index)+1];
+      tinyobj::real_t vz = attrib.vertices[3*size_t(idx.vertex_index)+2];
+
+      // Check if `normal_index` is zero or positive. negative = no normal data
+      if (idx.normal_index >= 0) {
+        tinyobj::real_t nx = attrib.normals[3*size_t(idx.normal_index)+0];
+        tinyobj::real_t ny = attrib.normals[3*size_t(idx.normal_index)+1];
+        tinyobj::real_t nz = attrib.normals[3*size_t(idx.normal_index)+2];
+      }
+
+      // Check if `texcoord_index` is zero or positive. negative = no texcoord data
+      if (idx.texcoord_index >= 0) {
+        tinyobj::real_t tx = attrib.texcoords[2*size_t(idx.texcoord_index)+0];
+        tinyobj::real_t ty = attrib.texcoords[2*size_t(idx.texcoord_index)+1];
+      }
+      // Optional: vertex colors
+      // tinyobj::real_t red   = attrib.colors[3*size_t(idx.vertex_index)+0];
+      // tinyobj::real_t green = attrib.colors[3*size_t(idx.vertex_index)+1];
+      // tinyobj::real_t blue  = attrib.colors[3*size_t(idx.vertex_index)+2];
+    }
+    index_offset += fv;
+
+    // per-face material
+    shapes[s].mesh.material_ids[f];
+  }
+}
+
+```
+
+#### Example code (New Object Oriented API)
+
+```c++
+#define TINYOBJLOADER_IMPLEMENTATION // define this in only *one* .cc
+// Optional. define TINYOBJLOADER_USE_MAPBOX_EARCUT gives robust triangulation. Requires C++11
+//#define TINYOBJLOADER_USE_MAPBOX_EARCUT
+#include "tiny_obj_loader.h"
+
+
+std::string inputfile = "cornell_box.obj";
+tinyobj::ObjReaderConfig reader_config;
+reader_config.mtl_search_path = "./"; // Path to material files
+
+tinyobj::ObjReader reader;
+
+if (!reader.ParseFromFile(inputfile, reader_config)) {
+  if (!reader.Error().empty()) {
+      std::cerr << "TinyObjReader: " << reader.Error();
+  }
+  exit(1);
+}
+
+if (!reader.Warning().empty()) {
+  std::cout << "TinyObjReader: " << reader.Warning();
+}
+
+auto& attrib = reader.GetAttrib();
+auto& shapes = reader.GetShapes();
+auto& materials = reader.GetMaterials();
+
+// Loop over shapes
+for (size_t s = 0; s < shapes.size(); s++) {
+  // Loop over faces(polygon)
+  size_t index_offset = 0;
+  for (size_t f = 0; f < shapes[s].mesh.num_face_vertices.size(); f++) {
+    size_t fv = size_t(shapes[s].mesh.num_face_vertices[f]);
+
+    // Loop over vertices in the face.
+    for (size_t v = 0; v < fv; v++) {
+      // access to vertex
+      tinyobj::index_t idx = shapes[s].mesh.indices[index_offset + v];
+      tinyobj::real_t vx = attrib.vertices[3*size_t(idx.vertex_index)+0];
+      tinyobj::real_t vy = attrib.vertices[3*size_t(idx.vertex_index)+1];
+      tinyobj::real_t vz = attrib.vertices[3*size_t(idx.vertex_index)+2];
+
+      // Check if `normal_index` is zero or positive. negative = no normal data
+      if (idx.normal_index >= 0) {
+        tinyobj::real_t nx = attrib.normals[3*size_t(idx.normal_index)+0];
+        tinyobj::real_t ny = attrib.normals[3*size_t(idx.normal_index)+1];
+        tinyobj::real_t nz = attrib.normals[3*size_t(idx.normal_index)+2];
+      }
+
+      // Check if `texcoord_index` is zero or positive. negative = no texcoord data
+      if (idx.texcoord_index >= 0) {
+        tinyobj::real_t tx = attrib.texcoords[2*size_t(idx.texcoord_index)+0];
+        tinyobj::real_t ty = attrib.texcoords[2*size_t(idx.texcoord_index)+1];
+      }
+
+      // Optional: vertex colors
+      // tinyobj::real_t red   = attrib.colors[3*size_t(idx.vertex_index)+0];
+      // tinyobj::real_t green = attrib.colors[3*size_t(idx.vertex_index)+1];
+      // tinyobj::real_t blue  = attrib.colors[3*size_t(idx.vertex_index)+2];
+    }
+    index_offset += fv;
+
+    // per-face material
+    shapes[s].mesh.material_ids[f];
+  }
+}
+
+```
+
+
+
+## Optimized loader
+
+Optimized multi-threaded .obj loader is available at `experimental/` directory.
+If you want absolute performance to load .obj data, this optimized loader will fit your purpose.
+Note that the optimized loader uses C++11 thread and it does less error checks but may work most .obj data.
+
+Here is some benchmark result. Time are measured on MacBook 12(Early 2016, Core m5 1.2GHz).
+
+* Rungholt scene(6M triangles)
+  * old version(v0.9.x): 15500 msecs.
+  * baseline(v1.0.x): 6800 msecs(2.3x faster than old version)
+  * optimised: 1500 msecs(10x faster than old version, 4.5x faster than baseline)
+
+## Python binding
+
+```
+$ python -m pip install tinyobjloader
+```
+
+See [python/sample.py](python/sample.py) for example use of Python binding of tinyobjloader.
+
+### CI + PyPI upload
+
+cibuildwheels + twine upload for each git tagging event is handled in Github Actions and Cirrus CI(arm builds).
+
+#### How to bump version(For developer)
+
+* Apply `black` to python files(`python/sample.py`)
+* Bump version in CMakeLists.txt
+* Commit and push `release`. Confirm C.I. build is OK.
+* Create tag starting with `v`(e.g. `v2.1.0`)
+* `git push --tags`
+  * version settings is automatically handled in python binding through setuptools_scm.
+  * cibuildwheels + pypi upload(through twine) will be automatically triggered in Github Actions + Cirrus CI.
+
+## Tests
+
+Unit tests are provided in `tests` directory. See `tests/README.md` for details.

tinymetabobjloader-2.0.0rc14.dev2.dist-info/RECORD

@@ -0,0 +1,13 @@
+tinyobjloader.cp310-win_amd64.pyd,sha256=VTSgsY2djv09mCoqEtccytBf4K_z_h3y4TrGPiF9aOo,393216
+python/LICENSE,sha256=zxZlfK-dwbDoKmVi6SSoKzvbGR7TGeDQxXHf36TOPJs,1128
+python/Makefile,sha256=uDtusDhGSIW8p_fe4S73bQNzdl6Oaqpxv9qutjsGfYA,79
+python/README.md,sha256=EaY4a53EUCIKY954YFcZQJcSxBXpgGK1UXqpI3Ehhjg,1893
+python/_version.py,sha256=XpkgYRA-nGXDvYmS6BQq8GHknkH4ia1gytHze5v6hks,181
+python/bindings.cc,sha256=ujGUjeEBf40yl8aKq0PIGT5rINjXFltORAjObmRs6Tc,10777
+python/sample.py,sha256=r4GCwMYeWz9d5-8fM32w-7kE3RdgTTeNiErIBoYnJE0,4499
+python/tiny_obj_loader.cc,sha256=HuUwlkfSXxD_YYsL27VPzkq0pjCa4_NY0WFmDmH_IOg,328
+tinymetabobjloader-2.0.0rc14.dev2.dist-info/licenses/LICENSE,sha256=ddIXyxs8b0qljS_X4P-c8squ9ukaQetbeJPbio08y_s,1944
+tinymetabobjloader-2.0.0rc14.dev2.dist-info/METADATA,sha256=JW5RFGbkSlOKuRc7OdjYM6ybQ6MDuyQ-DHDfMhiMbdA,19824
+tinymetabobjloader-2.0.0rc14.dev2.dist-info/WHEEL,sha256=OmlgzUCveukBveBvfr5iRzssF3erRUmVofl2cpSC8x4,101
+tinymetabobjloader-2.0.0rc14.dev2.dist-info/top_level.txt,sha256=JcbQXTgJJCPmQ8h_DXoxzE9oLfj8MSkGGZAz9PQdCzY,21
+tinymetabobjloader-2.0.0rc14.dev2.dist-info/RECORD,,

tinymetabobjloader-2.0.0rc14.dev2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-win_amd64
+

tinymetabobjloader-2.0.0rc14.dev2.dist-info/licenses/LICENSE

@@ -0,0 +1,42 @@
+The MIT License (MIT)
+
+Copyright (c) 2012-2019 Syoyo Fujita and many contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+----------------------------------
+
+mapbox/earcut.hpp
+
+ISC License
+
+Copyright (c) 2015, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+

tinymetabobjloader-2.0.0rc14.dev2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+python
+tinyobjloader