tinyobj

tinyobj

tinyobj/tinyobj.adept is a port of the TinyOBJLoader-C library.

It can be used to load basic .obj 3D model files.

Structures

struct tinyobj_material_t (
    name *ubyte,
    ambient 3 float,
    diffuse 3 float,
    specular 3 float,
    transmittance 3 float,
    emission 3 float,
    shininess float,
    ior float, // index of refraction
    dissolve float, // 1 == opaque, 0 == transparent
    illum int, // illumination
    pad0 int,
    ambient_texname *ubyte,
    diffuse_texname *ubyte,
    specular_texname *ubyte,
    specular_highlight_texname *ubyte,
    bump_texname *ubyte,
    displacement_texname *ubyte,
    alpha_texname *ubyte
)

struct tinyobj_shape_t (
    name *ubyte, // group or object name
    face_offset uint,
    length uint
)

struct tinyobj_vertex_index_t (v_idx, vt_idx, vn_idx int)

struct tinyobj_attrib_t (
    num_vertices uint,
    num_normals uint,
    num_texcoords uint,
    num_faces uint,
    num_face_num_verts uint,
    pad0 int,
    vertices *float,
    normals *float,
    texcoords *float,
    faces *tinyobj_vertex_index_t,
    face_num_verts *int,
    material_ids *int
)

Constants

define TINYOBJ_FLAG_TRIANGULATE = 1
define TINYOBJ_INVALID_INDEX = 0x80000000
define TINYOBJ_SUCCESS = 0
define TINYOBJ_ERROR_EMPTY = -1
define TINYOBJ_ERROR_INVALID_PARAMETER = -2
define TINYOBJ_ERROR_FILE_OPERATION = -3

define TINYOBJ_MAX_FACES_PER_F_LINE = 16

Functions

• func tinyobj_parse_obj(attrib *tinyobj_attrib_t, shapes **tinyobj_shape_t, num_shapes *usize, materials_out **tinyobj_material_t, num_materials_out *usize, buf *ubyte, len usize, flags uint) int

• func tinyobj_parse_obj_ex(attrib *tinyobj_attrib_t, shapes **tinyobj_shape_t, num_shapes *usize, materials_out **tinyobj_material_t, num_materials_out *usize, buf *ubyte, len usize, flags uint, material_path *ubyte) int

• func tinyobj_attrib_free(attrib *tinyobj_attrib_t) void

• func tinyobj_shapes_free(shapes *tinyobj_shape_t, num_shapes usize) void

• func tinyobj_materials_free(materials *tinyobj_material_t, num_materials usize) void

• Lesser used functions omitted

Some Sample Code

#default get_file_contents_32_bit false

#unless get_file_contents_32_bit
    #if __windows__
        foreign fseeko64(*FILE, long, int) int
        foreign ftello64(*FILE) long
    #else
        import 'unix/off_t.adept'
        foreign fseeko(*FILE, off_t, int) int
        foreign ftello(*FILE) off_t
    #end
#end

import cstdio
import cstdlib
import String
import List
import Array
import Vector2f
import Vector3f
import array_util
import list_util

// Some Abstract OpenGL Helper Utilities
import 'VAO.adept'
import 'EBO.adept'
import 'Texture.adept'

// A Generic 3D Model with a Single Texture
struct Model (vao VAO, ebo EBO, texture *Texture) {
    func destroy {
        this.vao.destroy()
        this.ebo.destroy()
        // Texture is not destroyed
    }
    
    func render {
        this.vao.bind()
        this.vao.enableAttribArrays()
        this.ebo.bind()
        
        if this.texture {
            glActiveTexture(GL_TEXTURE0)
            glBindTexture(GL_TEXTURE_2D, this.texture.id)
        }
        
        glDrawElements(GL_TRIANGLES, this.ebo.size, GL_UNSIGNED_INT, null)
        
        this.ebo.unbind()
        this.vao.disableAttribArrays()
        this.vao.unbind()
    }
}

func model(vao POD VAO, ebo POD EBO, texture *Texture) Model {
    model POD Model
    model.vao = POD vao
    model.ebo = POD ebo
    model.texture = texture
    return model
}

func model(filename String, texture *Texture) Model {
    empty_model POD Model
    
    filename_cstr *ubyte = filename.cstr()
    defer delete filename_cstr
    
    attrib tinyobj_attrib_t
    shapes *tinyobj_shape_t = null
    num_shapes usize = undef
    materials *tinyobj_material_t = null
    num_materials usize = undef
    
    data_len usize = 0
    data *ubyte = getFileContentsAsNullTerminatedString(filename_cstr, &data_len)
    
    if data == null {
        fprintf(stderr, 'model(String, *Texture) failed to read file "%s"\n', filename_cstr)
        return empty_model
    }
    
    defer delete data
    
    material_path_cstr *ubyte = null
    defer delete material_path_cstr
    
    last_slash long = max(filename.last('/'ub), filename.last('\\'ub))
    
    if last_slash >= 0 {
        material_path String = filename.range(0, last_slash + 1)
        material_path_cstr = material_path.cstr()
    }
    
    flags uint = TINYOBJ_FLAG_TRIANGULATE
    ret int = tinyobj_parse_obj_ex(&attrib, &shapes, &num_shapes, &materials, &num_materials, data, data_len, flags, material_path_cstr)
    if ret != TINYOBJ_SUCCESS, fprintf(stderr, 'model(String, *Texture) failed to load model "%s"\n', filename_cstr); return empty_model
    
    vertices <float> List
    texture_coords <float> List
    normals <float> List
    indices <uint> List
    tangents <float> List
    
    each tinyobj_vertex_index_t in [attrib.faces, attrib.num_faces] {
        vertices.add(attrib.vertices[it.v_idx * 3 + 0])
        vertices.add(attrib.vertices[it.v_idx * 3 + 1])
        vertices.add(attrib.vertices[it.v_idx * 3 + 2])
        
        texture_coords.add(attrib.texcoords[it.vt_idx * 2 + 0])
        texture_coords.add(attrib.texcoords[it.vt_idx * 2 + 1])
        
        normals.add(attrib.normals[it.vn_idx * 3 + 0])
        normals.add(attrib.normals[it.vn_idx * 3 + 1])
        normals.add(attrib.normals[it.vn_idx * 3 + 2])
        
        // Lazy indices
        indices.add(indices.length as uint)
    }
    
    tangents = computeTangents(vertices, texture_coords, normals, indices)
    
    vertices_vbo POD VBO = vbo(VBOType::VERTICES, array(vertices.items, vertices.length))
    texture_coords_vbo POD VBO = vbo(VBOType::TEXTURE_COORDS, array(texture_coords.items, texture_coords.length))
    normals_vbo POD VBO = vbo(VBOType::NORMALS, array(normals.items, normals.length))
    tangents_vbo POD VBO = vbo(VBOType::TANGENTS, array(tangents.items, tangents.length))
    
    vao POD VAO = POD vao()
    vao.addVBO(vertices_vbo)
    vao.addVBO(texture_coords_vbo)
    vao.addVBO(normals_vbo)
    vao.addVBO(tangents_vbo)
    
    ebo POD EBO = ebo(array(indices.items, indices.length))
    
    defer tinyobj_attrib_free(&attrib)
    defer tinyobj_shapes_free(shapes, num_shapes)
    defer tinyobj_materials_free(materials, num_materials)
    return model(vao, ebo, texture)
}

func computeTangents(vertices, uvs, normals <float> List, indices <uint> List) <float> List {
    vertex_count usize = vertices.length / 3
    
    tan_a <Vector3f> List
    repeat vertex_count, tan_a.add(vector3f(0.0f, 0.0f, 0.0f))
    
    i usize = 0; while i < indices.length {
        i0 uint = indices.get(i)
        i1 uint = indices.get(i + 1)
        i2 uint = indices.get(i + 2)
        
        pos0 Vector3f = vector3f(vertices.get(i0 * 3 + 0), vertices.get(i0 * 3 + 1), vertices.get(i0 * 3 + 2))
        pos1 Vector3f = vector3f(vertices.get(i1 * 3 + 0), vertices.get(i1 * 3 + 1), vertices.get(i1 * 3 + 2))
        pos2 Vector3f = vector3f(vertices.get(i2 * 3 + 0), vertices.get(i2 * 3 + 1), vertices.get(i2 * 3 + 2))
        
        tex0 Vector2f = vector2f(uvs.get(i0 * 2 + 0), uvs.get(i0 * 2 + 1))
        tex1 Vector2f = vector2f(uvs.get(i1 * 2 + 0), uvs.get(i1 * 2 + 1))
        tex2 Vector2f = vector2f(uvs.get(i2 * 2 + 0), uvs.get(i2 * 2 + 1))
        
        edge1 Vector3f = pos1 - pos0
        edge2 Vector3f = pos2 - pos0
        
        uv1 Vector2f = tex1 - tex0
        uv2 Vector2f = tex2 - tex0
        
        r float = 1.0f / (uv1.x * uv2.y - uv1.y * uv2.x)
        
        tangent Vector3f = vector3f(
            ((edge1.x * uv2.y) - (edge2.x * uv1.y)) * r,
            ((edge1.y * uv2.y) - (edge2.y * uv1.y)) * r,
            ((edge1.z * uv2.y) - (edge2.z * uv1.y)) * r)
        
        tan_a.getPointer(i0).add(tangent)
        tan_a.getPointer(i1).add(tangent)
        tan_a.getPointer(i2).add(tangent)
        
        i += 3
    }
    
    result <float> List
    repeat vertex_count {
        n Vector3f = vector3f(normals.get(idx * 3), normals.get(idx * 3 + 1), normals.get(idx * 3 + 2))
        t0 Vector3f = tan_a.get(idx)
        t Vector3f = t0 - (n * n.dot(t0))
        t.normalize()
        result.add(t.x)
        result.add(t.y)
        result.add(t.z)
    }
    
    return result
}

func getFileContentsAsNullTerminatedString(in filename *ubyte, out size *usize) *ubyte {
    // NOTE: Only works for files smaller than ~4GB
    // NOTE: Might work with files larger than ~4GB now, haven't tested yet
    
    
    buffer *ubyte = null
    length long = undef
    f *FILE = fopen(filename, 'r')
    unless f, return null
    defer fclose(f)
    
    #if get_file_contents_32_bit
        fseek(f, 0, SEEK_END)
        length = ftell(f)
        fseek(f, 0, SEEK_SET)
    #elif __windows__
        fseeko64(f, 0, SEEK_END)
        length = ftello64(f)
        fseeko64(f, 0, SEEK_SET)
    #else
        fseeko(f, 0, SEEK_END)
        length = ftello(f)
        fseeko(f, 0, SEEK_SET)
    #end
    
    buffer = malloc(length + 1)
    if buffer {
        if fread(buffer, 1, length, f) != length, return null
        buffer[length] = 0x00ub
    }
    *size = length
    return buffer
}