178ef391c7
Dear all, As described in the issue https://github.com/syoyo/tinyobjloader/issues/188#issue-385341218 there is a memory leak in the function pyLoadObj(). The reference count for all created Python objects must be decreased after they are fed into the lists and dictionaries. The only exception from this is the function PyTuple_SetItem() in pyTupleFromfloat3(), which decreases the reference counter of the Python object *tuple automatically by calling this function. In all other cases like PyList_Insert(), the references are only borrowed and not decreased. Therefore, each created Python object will remain in the heap, since there is one reference to it left in the counter. These facts are explained in https://docs.python.org/2/c-api/intro.html#reference-counts in detail. Best regards Martin. P.S. sorry, that i did not put that much effort into a more readable code and just inserted the Py_DECREF() function at every necessary position.
tinyobjloader
https://github.com/syoyo/tinyobjloader
Tiny but powerful single file wavefront obj loader written in C++. 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 C89 version, please see https://github.com/syoyo/tinyobjloader-c .
Notice!
We have released new version v1.0.0 on 20 Aug, 2016.
Old version is available v0.9.x branch https://github.com/syoyo/tinyobjloader/tree/v0.9.x
What's new
- 20 Aug, 2016 : Bump version v1.0.0. New data structure and API!
Old version
Previous old version is avaiable in v0.9.x branch.
Example
tinyobjloader can successfully load 6M triangles Rungholt scene. http://casual-effects.com/data/index.html
- examples/viewer/ OpenGL .obj viewer
- examples/callback_api/ Callback API example
- examples/voxelize/ Voxelizer example
Use case
TinyObjLoader is successfully used in ...
New version(v1.0.x)
- Double precision support through
TINYOBJLOADER_USE_DOUBLEthanks 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
- Your project here! (Letting us know via github issue is welcome!)
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
- Material
- Unknown material attributes are returned as key-value(value is string) map.
- Crease tag('t'). This is OpenSubdiv specific(not in wavefront .obj specification)
- PBR material extension for .MTL. Its proposed here: http://exocortex.com/blog/extending_wavefront_mtl_to_support_pbr
- Callback API for custom loading.
- Double precision support(for HPC application).
- Smoothing group
TODO
- Fix obj_sticker example.
- More unit test codes.
- Texture options
License
Licensed under MIT license.
Usage
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 flas 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.
Example code
#define TINYOBJLOADER_IMPLEMENTATION // define this in only *one* .cc
#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 err;
bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, inputfile.c_str());
if (!err.empty()) { // `err` may contain warning message.
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++) {
int fv = 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*idx.vertex_index+0];
tinyobj::real_t vy = attrib.vertices[3*idx.vertex_index+1];
tinyobj::real_t vz = attrib.vertices[3*idx.vertex_index+2];
tinyobj::real_t nx = attrib.normals[3*idx.normal_index+0];
tinyobj::real_t ny = attrib.normals[3*idx.normal_index+1];
tinyobj::real_t nz = attrib.normals[3*idx.normal_index+2];
tinyobj::real_t tx = attrib.texcoords[2*idx.texcoord_index+0];
tinyobj::real_t ty = attrib.texcoords[2*idx.texcoord_index+1];
// Optional: vertex colors
// tinyobj::real_t red = attrib.colors[3*idx.vertex_index+0];
// tinyobj::real_t green = attrib.colors[3*idx.vertex_index+1];
// tinyobj::real_t blue = attrib.colors[3*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)
Tests
Unit tests are provided in tests directory. See tests/README.md for details.