Crate tobj [] [src]

Tiny OBJ loader, inspired by Syoyo's excellent tinyobjloader. Aims to be a simple and lightweight option for loading OBJ files, simply returns two vecs containing loaded models and materials. All models are made of triangles, any quad faces in an OBJ file will be converted to two triangles.

Example

In this simple example we load the classic Cornell Box model that only defines positions and print out its attributes.

let cornell_box = load_obj(&Path::new("cornell_box.obj"));
assert!(cornell_box.is_ok());
let (models, materials) = cornell_box.unwrap();

println!("# of models: {}", models.len());
println!("# of materials: {}", materials.len());
for (i, m) in models.iter().enumerate() {
    let mesh = &m.mesh;
    println!("model[{}].name = {}", i, m.name);
    println!("model[{}].mesh.material_id = {:?}", i, mesh.material_id);
 
    println!("Size of model[{}].indices: {}", i, mesh.indices.len());
    for f in 0..(mesh.indices.len() / 3) {
        println!("    idx[{}] = {}, {}, {}.", f, mesh.indices[3 * f],
            mesh.indices[3 * f + 1], mesh.indices[3 * f + 2]);
    }
 
    // Normals and texture coordinates are also loaded, but not printed in this example
    println!("model[{}].vertices: {}", i, mesh.positions.len());
    assert!(mesh.positions.len() % 3 == 0);
    for v in 0..(mesh.positions.len() / 3) {
        println!("    v[{}] = ({}, {}, {})", v, mesh.positions[3 * v],
            mesh.positions[3 * v + 1], mesh.positions[3 * v + 2]);
    }
    print_material_info(materials);
}
for (i, m) in materials.iter().enumerate() {
    println!("material[{}].name = {}", i, m.name);
    println!("    material.Ka = ({}, {}, {})", m.ambient[0], m.ambient[1], m.ambient[2]);
    println!("    material.Kd = ({}, {}, {})", m.diffuse[0], m.diffuse[1], m.diffuse[2]);
    println!("    material.Ks = ({}, {}, {})", m.specular[0], m.specular[1], m.specular[2]);
    println!("    material.Ns = {}", m.shininess);
    println!("    material.d = {}", m.dissolve);
    println!("    material.map_Ka = {}", m.ambient_texture);
    println!("    material.map_Kd = {}", m.diffuse_texture);
    println!("    material.map_Ks = {}", m.specular_texture);
    println!("    material.map_Ns = {}", m.normal_texture);
    println!("    material.map_d = {}", m.dissolve_texture);
    for (k, v) in &m.unknown_param {
        println!("    material.{} = {}", k, v);
    }
}

Structs

Material

A material that may be referenced by one or more meshes. Standard MTL attributes are supported and any unrecognized ones will be stored as Strings in the unknown_param HashMap

Mesh

A mesh made up of triangles loaded from some OBJ file

Model

A named model within the file, associates some mesh with a name that was specified with an o or g keyword in the OBJ file

Enums

LoadError

Possible errors that may occur while loading OBJ and MTL files

Functions

load_mtl

Load the materials defined in a MTL file Returns a pair with a Vec holding all loaded materials and a HashMap containing a mapping of material names to indices in the Vec.

load_obj

Load the various objects specified in the OBJ file and any associated MTL file Returns a pair of Vecs containing the loaded models and materials from the file.

print_material_info

Print out all loaded properties of some materials

print_model_info

Print out all loaded properties of some models and associated materials

Type Definitions

LoadResult

LoadResult is a result containing all the models loaded from the file and any materials from referenced material libraries, or an error that occured while loading

MTLLoadResult

MTLLoadResult is a result containing all the materials loaded from the file and a map of MTL name to index or the error that occured while loading